refactor(flags): tighten numeric validation, document serialId/metadata (review M/L)

Remaining PR1 review follow-ups:
- M1: integer flags require a whole number; number/float require a finite value
  (reject NaN/Infinity) so native parsers round-trip.
- M2: document that serialId is intentionally not propagated (no FlagCacheEntry
  slot; native snapshot omits it too).
- L3: comment that only flags (and obfuscated) are load-bearing; the rest of the
  response attributes are optional/ignored on purpose.
- L1/L5: broaden round-trip fixture (number + nested object flags) and add tests
  for fractional integer, non-finite number, and a structurally broken response.

L2 (distinguishing parse-failure from valid-but-empty) is intentionally left to
PR2 (FFL-2688). L4 (configurationToString vs the reference's bug) is correct as-is.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: btthomas

packages/core/src/flags/configuration/__tests__/precomputed.test.ts

@@ -178,6 +178,35 @@ describe('decodePrecomputedFlags', () => {
         expect(decodePrecomputedFlags(responseWith({}))).toEqual({});
     });
 
+    it('omits an integer flag with a fractional value', () => {
+        const cache = decodePrecomputedFlags(
+            responseWith({
+                frac: flag({ variationType: 'integer', variationValue: 7.9 })
+            })
+        );
+
+        expect(cache.frac).toBeUndefined();
+        expect(InternalLog.log).toHaveBeenCalled();
+    });
+
+    it('omits a number flag whose value is not finite', () => {
+        const cache = decodePrecomputedFlags(
+            responseWith({
+                inf: flag({ variationType: 'number', variationValue: Infinity })
+            })
+        );
+
+        expect(cache.inf).toBeUndefined();
+    });
+
+    it('returns an empty map for a structurally broken response', () => {
+        expect(
+            decodePrecomputedFlags(
+                ({} as unknown) as Parameters<typeof decodePrecomputedFlags>[0]
+            )
+        ).toEqual({});
+    });
+
     it('rejects an array value for an object flag', () => {
         const cache = decodePrecomputedFlags(
             responseWith({

packages/core/src/flags/configuration/__tests__/wire.test.ts

@@ -25,6 +25,24 @@ const buildResponse = () => ({
                     reason: 'STATIC',
                     doLog: false,
                     extraLogging: {}
+                },
+                'num-flag': {
+                    variationType: 'number',
+                    variationValue: 1.5,
+                    variationKey: '1.5',
+                    allocationKey: 'alloc-2',
+                    reason: 'STATIC',
+                    doLog: true,
+                    extraLogging: {}
+                },
+                'obj-flag': {
+                    variationType: 'object',
+                    variationValue: { nested: { a: 1 }, list: [1, 2] },
+                    variationKey: 'obj',
+                    allocationKey: 'alloc-3',
+                    reason: 'TARGETING_MATCH',
+                    doLog: false,
+                    extraLogging: { extra: 'x' }
                 }
             }
         }

packages/core/src/flags/configuration/precomputed.ts

@@ -90,6 +90,9 @@ const toFlagCacheEntry = (
         return null;
     }
 
+    // `serialId` is intentionally not propagated: `FlagCacheEntry` has no slot for it
+    // and the native CDN-fetched snapshot omits it too, so dropping it keeps
+    // offline/online parity.
     return {
         key,
         value: variationValue,
@@ -113,9 +116,13 @@ const valueMatchesVariationType = (
         case 'string':
             return typeof value === 'string';
         case 'number':
-        case 'integer':
         case 'float':
-            return typeof value === 'number';
+            // Reject NaN/Infinity: native parsers can't round-trip them.
+            return typeof value === 'number' && Number.isFinite(value);
+        case 'integer':
+            // A fractional value under an integer flag would be truncated/mis-parsed
+            // natively, so require a whole number.
+            return Number.isInteger(value);
         case 'object':
             // Object flags are a JSON object at the root; arrays are not valid values.
             return (

packages/core/src/flags/configuration/types.ts

@@ -65,6 +65,9 @@ export interface PrecomputedConfigurationResponse {
         id?: string;
         type?: string;
         attributes: {
+            // Only `flags` is load-bearing (and `obfuscated`, which gates support). The
+            // remaining fields are metadata the decoder ignores; typed loosely/optional
+            // on purpose so payload variation across environments doesn't matter.
             obfuscated?: boolean;
             createdAt?: string;
             format?: string;