fix(capacity): parse scheduling-row quantities with the shared Quantity parser

The byte parser's suffix table stops at Ti and falls back to the bare
number, so a 1PiB aggregate memory capacity read as 1 byte. The shared
parser covers Pi/Ei and exponent forms; a zero-test on the raw string
preserves the card's null-means-unknown contract.

Author: nadaverell

web/src/components/capacity/ClusterSchedulingCard.tsx

@@ -7,7 +7,7 @@ import {
 import { Badge } from "@skyhook-io/k8s-ui/components/ui/Badge";
 import {
   parseCPUToNanocores,
-  parseMemoryToBytes,
+  parseQuantityToNumber,
 } from "@skyhook-io/k8s-ui/utils/format";
 import {
   CertaintyGlyph,
@@ -96,16 +96,15 @@ export function quantityToNumber(
     }
     return null;
   }
-  // Milli quantities before the byte parser — it ignores the `m` suffix and
-  // would read 3000m as 3000, a 1000× distortion.
-  const milli = /^(-?\d+(?:\.\d+)?)m$/.exec(value);
-  if (milli) return Number(milli[1]) / 1000;
-  const parsed = parseMemoryToBytes(value);
-  if (Number.isFinite(parsed) && (parsed !== 0 || /^[0.]+\D*$/.test(value))) {
+  // The shared parser knows the full suffix table — the byte parser stops at
+  // Ti, so a 1PiB aggregate would read as 1 byte. It returns 0 for input it
+  // cannot parse, so distinguish a real zero to preserve the null (= unknown,
+  // not zero) contract of this card.
+  const parsed = parseQuantityToNumber(value);
+  if (parsed !== 0 || /^[+-]?[0.]+\D*$/.test(value)) {
     return parsed;
   }
-  const plain = Number(value);
-  return Number.isFinite(plain) ? plain : null;
+  return null;
 }
 
 function worstCertainty(

web/src/components/capacity/schedulingBar.test.ts

@@ -202,6 +202,16 @@ describe("quantityToNumber", () => {
     expect(quantityToNumber("example.com/widget", "3000m")).toBe(3);
     expect(quantityToNumber("cpu", "1500m")).toBe(1.5e9);
   });
+
+  // Aggregate memory on a large cluster reaches suffixes the byte parser
+  // never knew (its table stops at Ti) — "1Pi" must not read as 1 byte.
+  it("parses the large suffixes an aggregate capacity can carry", () => {
+    expect(quantityToNumber("memory", "1Pi")).toBe(1024 ** 5);
+    expect(quantityToNumber("memory", "1Ei")).toBe(1024 ** 6);
+    expect(quantityToNumber("pods", "1k")).toBe(1000);
+    expect(quantityToNumber("pods", "1e3")).toBe(1000);
+    expect(quantityToNumber("memory", "0Gi")).toBe(0);
+  });
 });
 
 describe("claimStagesDetail", () => {