fix(capacity): treat NaN as unknown in capacity comparator (refs #82)

Number.isFinite() replaces the typeof === 'number' guard in extractCapacity
so that NaN values (which pass typeof but cause NaN subtraction in
compareNullable) are folded into the unknown/null bucket and sort last
alongside absent/zero/null fields. The previous code would produce NaN from
the subtraction path, violating the Array.prototype.sort contract and causing
unstable ordering whenever a details blob contained a NaN vcpu or memory_gb.

Adds three discriminating tests via a recRaw() helper that bypasses the
existing rec() guard to inject NaN directly into the details blob: NaN vcpu
sorts after known vcpu, NaN memory_gb sorts after known memory_gb when vcpu
ties, and two all-NaN recs fall back to the resource_type tiebreaker without
any NaN-comparison instability.

compareByCapacity is left as a utility without wiring to the recommendations
table sort: adding a vcpu/memory column requires a UX decision (new
RecommendationsColumnId, rendered column header, default direction). See the
extractCapacity docstring and issue #82.

Author: cristim

frontend/src/__tests__/capacity.test.ts

@@ -32,6 +32,15 @@ function recNoDetails(resourceType: string): { details: undefined; resource_type
   return { details: undefined, resource_type: resourceType };
 }
 
+/** Builds a rec with raw numeric values including NaN/Infinity (bypasses rec() guards). */
+function recRaw(
+  resourceType: string,
+  vcpu: unknown,
+  memoryGb: unknown
+): { details: unknown; resource_type: string } {
+  return { details: { vcpu, memory_gb: memoryGb }, resource_type: resourceType };
+}
+
 // ---------------------------------------------------------------------------
 // Basic ordering
 // ---------------------------------------------------------------------------
@@ -114,6 +123,35 @@ describe('compareByCapacity — null/absent/zero sort last', () => {
     const nullMem = rec('something', 4, null);
     expect(compareByCapacity(known, nullMem)).toBeLessThan(0);
   });
+
+  // NaN guard: typeof NaN === 'number' but NaN is not a finite capacity value.
+  // extractCapacity must fold NaN into the unknown bucket (null) so that
+  // compareNullable never sees it; NaN subtraction would return NaN and violate
+  // the sort contract (NaN is neither < 0 nor > 0 nor === 0).
+  it('NaN vcpu is treated as unknown and sorts after positive vcpu', () => {
+    const known = rec('m5.large', 2, 8);
+    const nanVcpu = recRaw('bad-type', NaN, 8);
+    expect(compareByCapacity(known, nanVcpu)).toBeLessThan(0);
+    expect(compareByCapacity(nanVcpu, known)).toBeGreaterThan(0);
+  });
+
+  it('NaN memoryGB is treated as unknown and sorts after known memoryGB when vCPU ties', () => {
+    const known = rec('c5.xlarge', 4, 8);
+    const nanMem = recRaw('r5.xlarge', 4, NaN);
+    expect(compareByCapacity(known, nanMem)).toBeLessThan(0);
+    expect(compareByCapacity(nanMem, known)).toBeGreaterThan(0);
+  });
+
+  it('two NaN-vcpu recs: tie resolved by resource_type (no NaN-comparison instability)', () => {
+    const a = recRaw('alpha', NaN, NaN);
+    const b = recRaw('beta', NaN, NaN);
+    const ab = compareByCapacity(a, b);
+    const ba = compareByCapacity(b, a);
+    expect(ab).toBeLessThan(0);
+    expect(ba).toBeGreaterThan(0);
+    // Symmetry: sign must flip, not collapse to 0 or NaN.
+    expect(Math.sign(ab)).toBe(-Math.sign(ba));
+  });
 });
 
 // ---------------------------------------------------------------------------

frontend/src/lib/capacity.ts

@@ -66,9 +66,18 @@ export function compareByCapacity(
 
 /**
  * extractCapacity pulls vcpu / memory_gb from an opaque details blob.
- * Returns zeros (treated as unknown by the comparator) for non-compute
- * payloads or absent fields, matching the ComputeDetails omitempty
- * behaviour on the wire.
+ * Returns null for non-compute payloads or absent/non-finite fields,
+ * matching the ComputeDetails omitempty behaviour on the wire.
+ *
+ * Note: Number.isFinite() is used (not typeof === 'number') to reject NaN,
+ * which passes the typeof check but would produce NaN subtraction results in
+ * compareNullable and cause an unstable sort. NaN falls into the unknown bucket
+ * and sorts last alongside null/absent/0 values.
+ *
+ * Intended consumer: the recommendations table capacity sort (clicking the
+ * vCPU/Memory column header). Wiring that column requires a UX decision
+ * (adding a new RecommendationsColumnId entry and a rendered column header);
+ * see issue #82 for context.
  */
 function extractCapacity(details: unknown): ComputeCapacity {
   if (
@@ -78,9 +87,8 @@ function extractCapacity(details: unknown): ComputeCapacity {
   ) {
     const d = details as Record<string, unknown>;
     return {
-      vcpu: typeof d['vcpu'] === 'number' ? d['vcpu'] : null,
-      memory_gb:
-        typeof d['memory_gb'] === 'number' ? d['memory_gb'] : null,
+      vcpu: Number.isFinite(d['vcpu']) ? (d['vcpu'] as number) : null,
+      memory_gb: Number.isFinite(d['memory_gb']) ? (d['memory_gb'] as number) : null,
     };
   }
   return { vcpu: null, memory_gb: null };