json-as 1.3.7 → 1.3.9

package/assembly/deserialize/swar/array/integer.ts

@@ -1,27 +1,25 @@
-import { deserializeIntegerField } from "../../index/integer";
-import { deserializeUnsignedField } from "../../index/unsigned";
-import { deserializeIntegerArray as deserializeIntegerArray_NAIVE } from "../../simple/array/integer";
+import { deserializeIntegerArray_NAIVE } from "../../naive/array/integer";
 import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
 import { isSpace } from "../../../util";
 import { ensureArrayElementSlot, ensureArrayField } from "./shared";
-
-const ASCII_LANE_MASK_4: u64 = 0x00ff00ff00ff00ff;
-const ASCII_ZERO_4: u64 = 0x0030003000300030;
-const ASCII_RANGE_MASK_4: u64 = 0xfff0fff0fff0fff0;
-const ASCII_RANGE_ADD_4: u64 = 0x0006000600060006;
-
-
-@inline function storeSignedInteger<T extends number[]>(
+import { parse4Digits_PairMul } from "../../../util/swar-int";
+
+// Store helpers parameterised on the element type `E` directly, so they
+// serve both `Array<E>` and `TypedArray<E>` callers. The integer-array
+// callers below all pass `valueof<T>` and AS folds the resulting tower of
+// `sizeof<E>` comparisons at compile time — same codegen as the prior
+// `T extends number[]` version, but reusable from `swar/typedarray.ts`.
+@inline function storeSignedIntegerE<E extends number>(
   slot: usize,
   value: i64,
 ): void {
-  if (sizeof<valueof<T>>() == sizeof<i8>()) {
+  if (sizeof<E>() == sizeof<i8>()) {
     store<i8>(slot, <i8>value);
-  } else if (sizeof<valueof<T>>() == sizeof<i16>()) {
+  } else if (sizeof<E>() == sizeof<i16>()) {
     store<i16>(slot, <i16>value);
-  } else if (sizeof<valueof<T>>() == sizeof<i32>()) {
+  } else if (sizeof<E>() == sizeof<i32>()) {
     store<i32>(slot, <i32>value);
-  } else if (sizeof<valueof<T>>() == sizeof<isize>()) {
+  } else if (sizeof<E>() == sizeof<isize>()) {
     store<isize>(slot, <isize>value);
   } else {
     store<i64>(slot, value);
@@ -29,45 +27,33 @@ const ASCII_RANGE_ADD_4: u64 = 0x0006000600060006;
 }
 
 
-@inline function storeUnsignedInteger<T extends number[]>(
+@inline function storeUnsignedIntegerE<E extends number>(
   slot: usize,
   value: u64,
 ): void {
-  if (sizeof<valueof<T>>() == sizeof<u8>()) {
+  if (sizeof<E>() == sizeof<u8>()) {
     store<u8>(slot, <u8>value);
-  } else if (sizeof<valueof<T>>() == sizeof<u16>()) {
+  } else if (sizeof<E>() == sizeof<u16>()) {
     store<u16>(slot, <u16>value);
-  } else if (sizeof<valueof<T>>() == sizeof<u32>()) {
+  } else if (sizeof<E>() == sizeof<u32>()) {
     store<u32>(slot, <u32>value);
-  } else if (sizeof<valueof<T>>() == sizeof<usize>()) {
+  } else if (sizeof<E>() == sizeof<usize>()) {
     store<usize>(slot, <usize>value);
   } else {
     store<u64>(slot, value);
   }
 }
 
-
-@inline function parse4DigitsASCII(block: u64): u32 {
-  const digits = (block & ASCII_LANE_MASK_4) - ASCII_ZERO_4;
-  if (((digits | (digits + ASCII_RANGE_ADD_4)) & ASCII_RANGE_MASK_4) != 0)
-    return U32.MAX_VALUE;
-
-  return <u32>(
-    (<u32>(digits & 0xffff) * 1000 +
-      <u32>((digits >> 16) & 0xffff) * 100 +
-      <u32>((digits >> 32) & 0xffff) * 10 +
-      <u32>(digits >> 48))
-  );
-}
-
 // The four parse helpers below take a `slot` pointer (`writePtr`) and store
 // the value directly via `store<valueof<T>>(slot, ...)`. The outer dispatcher
 // owns the array's `out.length = maxElements` pre-allocation and the
 // `writePtr` advance, so the per-element `Array.push` capacity check and
 // length write are eliminated for every integer width, not just the u8/i8
 // narrow-lane path.
-
-@inline function parseSignedIntegerScalar<T extends number[]>(
+// Parsers are also E-parameterised so they're shareable with
+// `swar/typedarray.ts`. The body is byte-identical to the prior version
+// modulo s/valueof<T>/E/.
+@inline export function parseSignedIntegerScalar<E extends number>(
   srcStart: usize,
   srcEnd: usize,
   slot: usize,
@@ -93,12 +79,12 @@ const ASCII_RANGE_ADD_4: u64 = 0x0006000600060006;
     srcStart += 2;
   }
 
-  storeSignedInteger<T>(slot, negative ? -(<i64>value) : <i64>value);
+  storeSignedIntegerE<E>(slot, negative ? -(<i64>value) : <i64>value);
   return srcStart;
 }
 
 
-@inline function parseUnsignedIntegerScalar<T extends number[]>(
+@inline export function parseUnsignedIntegerScalar<E extends number>(
   srcStart: usize,
   srcEnd: usize,
   slot: usize,
@@ -115,12 +101,12 @@ const ASCII_RANGE_ADD_4: u64 = 0x0006000600060006;
     srcStart += 2;
   }
 
-  storeUnsignedInteger<T>(slot, value);
+  storeUnsignedIntegerE<E>(slot, value);
   return srcStart;
 }
 
 
-@inline function parseSignedIntegerSWAR<T extends number[]>(
+@inline export function parseSignedIntegerSWAR<E extends number>(
   srcStart: usize,
   srcEnd: usize,
   slot: usize,
@@ -140,12 +126,17 @@ const ASCII_RANGE_ADD_4: u64 = 0x0006000600060006;
   let value: u64 = digit;
   srcStart += 2;
 
+  // Signed scan uses parse4 + scalar only (matches the asymmetric tuning in
+  // swar/integer.ts:deserializeIntegerField_SWAR). The leading minus shifts
+  // the digit run into parse8's "terminator-in-load" zone where validate-fail
+  // is common, so parse4's smaller failure unit wins.
+  //
   // i8 tops out at 3 digits (-128..127), so the 4-digit kernel can never fire
   // and the failing load + range check just burns cycles. Gate on the lane
   // width so AS folds the loop away at compile time.
-  if (sizeof<valueof<T>>() > 1) {
+  if (sizeof<E>() > 1) {
     while (srcStart + 6 < srcEnd) {
-      const parsed = parse4DigitsASCII(load<u64>(srcStart));
+      const parsed = parse4Digits_PairMul(load<u64>(srcStart));
       if (parsed == U32.MAX_VALUE) break;
       value = value * 10000 + parsed;
       srcStart += 8;
@@ -159,12 +150,12 @@ const ASCII_RANGE_ADD_4: u64 = 0x0006000600060006;
     srcStart += 2;
   }
 
-  storeSignedInteger<T>(slot, negative ? -(<i64>value) : <i64>value);
+  storeSignedIntegerE<E>(slot, negative ? -(<i64>value) : <i64>value);
   return srcStart;
 }
 
 
-@inline function parseUnsignedIntegerSWAR<T extends number[]>(
+@inline export function parseUnsignedIntegerSWAR<E extends number>(
   srcStart: usize,
   srcEnd: usize,
   slot: usize,
@@ -173,7 +164,7 @@ const ASCII_RANGE_ADD_4: u64 = 0x0006000600060006;
   // the element terminator, then a fixed-count fold with no per-digit break.
   // TurboFan tends to schedule this better than a single combined
   // scan-and-fold loop because the fold has no data-dependent exit.
-  if (sizeof<valueof<T>>() <= 2) {
+  if (sizeof<E>() <= 2) {
     const first = <u32>load<u16>(srcStart) - 48;
     if (first > 9) return 0;
     const lastIndex = srcStart;
@@ -189,7 +180,7 @@ const ASCII_RANGE_ADD_4: u64 = 0x0006000600060006;
       value = value * 10 + (<u32>load<u16>(p) - 48);
       p += 2;
     }
-    storeUnsignedInteger<T>(slot, value);
+    storeUnsignedIntegerE<E>(slot, value);
     return srcStart;
   }
 
@@ -199,8 +190,14 @@ const ASCII_RANGE_ADD_4: u64 = 0x0006000600060006;
   let value: u64 = digit;
   srcStart += 2;
 
+  // Array unsigned path uses parse4 + scalar (not parse8 + scalar as in the
+  // struct-field path swar/integer.ts:deserializeUnsignedField_SWAR). The
+  // bench corpus for arrays mixes element widths (e.g. 1/4/7/10 digits in
+  // u32-64mib), so most parse8 strides hit the `,` separator mid-load and
+  // pay the load+validate cost for a guaranteed miss. parse4 has a smaller
+  // failure unit and matches the typical 1-4 digit run between separators.
   while (srcStart + 6 < srcEnd) {
-    const parsed = parse4DigitsASCII(load<u64>(srcStart));
+    const parsed = parse4Digits_PairMul(load<u64>(srcStart));
     if (parsed == U32.MAX_VALUE) break;
     value = value * 10000 + parsed;
     srcStart += 8;
@@ -213,7 +210,7 @@ const ASCII_RANGE_ADD_4: u64 = 0x0006000600060006;
     srcStart += 2;
   }
 
-  storeUnsignedInteger<T>(slot, value);
+  storeUnsignedIntegerE<E>(slot, value);
   return srcStart;
 }
 
@@ -240,7 +237,6 @@ export function deserializeIntegerArray_SLOW<T extends number[]>(
   let index = 0;
 
   out.length = 0;
-  srcStart = skipIntegerArrayWhitespace(srcStart, srcEnd);
   if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) {
     throw new Error("Failed to parse JSON!");
   }
@@ -274,7 +270,7 @@ export function deserializeIntegerArray_SLOW<T extends number[]>(
         srcStart += 2;
       }
 
-      storeSignedInteger<T>(
+      storeSignedIntegerE<valueof<T>>(
         ensureArrayElementSlot<T>(out, index),
         negative ? -(<i64>value) : <i64>value,
       );
@@ -291,7 +287,10 @@ export function deserializeIntegerArray_SLOW<T extends number[]>(
         srcStart += 2;
       }
 
-      storeUnsignedInteger<T>(ensureArrayElementSlot<T>(out, index), value);
+      storeUnsignedIntegerE<valueof<T>>(
+        ensureArrayElementSlot<T>(out, index),
+        value,
+      );
     }
 
     index++;
@@ -355,7 +354,7 @@ export function deserializeIntegerArray_SLOW<T extends number[]>(
 
           if (sizeof<valueof<T>>() > 1) {
             while (srcStart + 6 < srcEnd) {
-              const parsed = parse4DigitsASCII(load<u64>(srcStart));
+              const parsed = parse4Digits_PairMul(load<u64>(srcStart));
               if (parsed == U32.MAX_VALUE) break;
               value = value * 10000 + parsed;
               srcStart += 8;
@@ -370,7 +369,7 @@ export function deserializeIntegerArray_SLOW<T extends number[]>(
           }
 
           if (index >= reusableLength) break;
-          storeSignedInteger<T>(
+          storeSignedIntegerE<valueof<T>>(
             dataStart + <usize>index * sizeof<valueof<T>>(),
             negative ? -(<i64>value) : <i64>value,
           );
@@ -398,7 +397,7 @@ export function deserializeIntegerArray_SLOW<T extends number[]>(
 
           if (sizeof<valueof<T>>() > 1) {
             while (srcStart + 6 < srcEnd) {
-              const parsed = parse4DigitsASCII(load<u64>(srcStart));
+              const parsed = parse4Digits_PairMul(load<u64>(srcStart));
               if (parsed == U32.MAX_VALUE) break;
               value = value * 10000 + parsed;
               srcStart += 8;
@@ -413,7 +412,7 @@ export function deserializeIntegerArray_SLOW<T extends number[]>(
           }
 
           if (index >= reusableLength) break;
-          storeUnsignedInteger<T>(
+          storeUnsignedIntegerE<valueof<T>>(
             dataStart + <usize>index * sizeof<valueof<T>>(),
             value,
           );
@@ -462,8 +461,8 @@ export function deserializeIntegerArray_SLOW<T extends number[]>(
     if (isSigned<valueof<T>>()) {
       while (srcStart < srcEnd) {
         const next = useSWAR
-          ? parseSignedIntegerSWAR<T>(srcStart, srcEnd, writePtr)
-          : parseSignedIntegerScalar<T>(srcStart, srcEnd, writePtr);
+          ? parseSignedIntegerSWAR<valueof<T>>(srcStart, srcEnd, writePtr)
+          : parseSignedIntegerScalar<valueof<T>>(srcStart, srcEnd, writePtr);
         if (!next) break;
         writePtr += elementSize;
         srcStart = next;
@@ -483,8 +482,8 @@ export function deserializeIntegerArray_SLOW<T extends number[]>(
     } else {
       while (srcStart < srcEnd) {
         const next = useSWAR
-          ? parseUnsignedIntegerSWAR<T>(srcStart, srcEnd, writePtr)
-          : parseUnsignedIntegerScalar<T>(srcStart, srcEnd, writePtr);
+          ? parseUnsignedIntegerSWAR<valueof<T>>(srcStart, srcEnd, writePtr)
+          : parseUnsignedIntegerScalar<valueof<T>>(srcStart, srcEnd, writePtr);
         if (!next) break;
         writePtr += elementSize;
         srcStart = next;
@@ -515,15 +514,6 @@ export function deserializeIntegerArray_SLOW<T extends number[]>(
   );
 }
 
-// @ts-ignore: Decorator valid here
-export function deserializeIntegerArray<T extends number[]>(
-  srcStart: usize,
-  srcEnd: usize,
-  dst: usize,
-): T {
-  return deserializeIntegerArrayImpl<T>(srcStart, srcEnd, dst, false);
-}
-
 // @ts-ignore: Decorator valid here
 export function deserializeIntegerArray_SWAR<T extends number[]>(
   srcStart: usize,
@@ -655,7 +645,7 @@ function deserializeNarrowIntegerArray_SWAR<T extends number[]>(
 }
 
 
-@inline export function deserializeIntegerArrayInto<T extends number[]>(
+@inline function deserializeIntegerArrayBody<T extends number[]>(
   srcStart: usize,
   srcEnd: usize,
   out: T,
@@ -665,6 +655,7 @@ function deserializeNarrowIntegerArray_SWAR<T extends number[]>(
   do {
     if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) break;
     srcStart += 2;
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
     if (srcStart >= srcEnd) break;
     if (load<u16>(srcStart) == BRACKET_RIGHT) {
       out.length = 0;
@@ -673,19 +664,35 @@ function deserializeNarrowIntegerArray_SWAR<T extends number[]>(
 
     while (srcStart < srcEnd) {
       const slot = ensureArrayElementSlot<T>(out, index);
+      // Inline the array-optimized SWAR parser directly. The top-level
+      // (`deserializeIntegerArrayImpl`) and the typed-array path
+      // (`swar/typedarray.ts`) already call these — having the field path
+      // call them too means the per-element parser is identical across all
+      // three call sites (parse4 + scalar fold for both signed and
+      // unsigned, narrow-lane special case for i8/u8/i16/u16).
+      //
+      // Why not `deserializeUnsignedField_SWAR` (which uses parse8 + scalar)?
+      // That tuning targets the struct-single-field path where the digit
+      // run is one aligned token. In an array, mixed element widths cause
+      // parse8 to fail-and-retry at element boundaries — see u32-64mib's
+      // 23% regression when parse8 was tried in the array path.
       srcStart = isSigned<valueof<T>>()
-        ? deserializeIntegerField<valueof<T>>(srcStart, srcEnd, slot)
-        : deserializeUnsignedField<valueof<T>>(srcStart, srcEnd, slot);
-      if (!srcStart || srcStart >= srcEnd) break;
+        ? parseSignedIntegerSWAR<valueof<T>>(srcStart, srcEnd, slot)
+        : parseUnsignedIntegerSWAR<valueof<T>>(srcStart, srcEnd, slot);
+      if (!srcStart) break;
+      while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+      if (srcStart >= srcEnd) break;
 
       const code = load<u16>(srcStart);
       if (code == COMMA) {
         srcStart += 2;
+        while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
         index++;
         continue;
       }
       if (code == BRACKET_RIGHT) {
-        out.length = index + 1;
+        const nextLen = index + 1;
+        if (out.length != nextLen) out.length = nextLen;
         return srcStart + 2;
       }
       break;
@@ -701,7 +708,7 @@ function deserializeNarrowIntegerArray_SWAR<T extends number[]>(
   srcEnd: usize,
   fieldPtr: usize,
 ): usize {
-  return deserializeIntegerArrayInto<T>(
+  return deserializeIntegerArrayBody<T>(
     srcStart,
     srcEnd,
     ensureArrayField<T>(fieldPtr),

package/assembly/deserialize/swar/array/map.ts

@@ -1,3 +1,4 @@
+import { deserializeGenericArrayBody } from "./generic";
 import { ensureArrayField } from "./shared";
 
 
@@ -6,6 +7,9 @@ import { ensureArrayField } from "./shared";
   srcEnd: usize,
   fieldPtr: usize,
 ): usize {
-  ensureArrayField<T>(fieldPtr);
-  throw new Error("Failed to parse JSON!");
+  return deserializeGenericArrayBody<T>(
+    srcStart,
+    srcEnd,
+    ensureArrayField<T>(fieldPtr),
+  );
 }

package/assembly/deserialize/swar/array/object.ts

@@ -1,8 +1,14 @@
+import { JSON } from "../../..";
 import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
-import { ensureArrayElementSlot, ensureArrayField } from "./shared";
+import {
+  ensureArrayElementSlot,
+  ensureArrayField,
+  scanValueEnd,
+  skipWhitespace,
+} from "./shared";
 
 
-@inline export function deserializeObjectArrayInto<T extends unknown[]>(
+@inline function deserializeObjectArrayBody<T extends unknown[]>(
   srcStart: usize,
   srcEnd: usize,
   out: T,
@@ -12,6 +18,7 @@ import { ensureArrayElementSlot, ensureArrayField } from "./shared";
   do {
     if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) break;
     srcStart += 2;
+    srcStart = skipWhitespace(srcStart, srcEnd);
     if (srcStart >= srcEnd) break;
     if (load<u16>(srcStart) == BRACKET_RIGHT) {
       out.length = 0;
@@ -20,44 +27,29 @@ import { ensureArrayElementSlot, ensureArrayField } from "./shared";
 
     while (srcStart < srcEnd) {
       const slot = ensureArrayElementSlot<T>(out, index);
-      let value = load<valueof<T>>(slot);
-      if (changetype<usize>(value) == 0) {
-        value = changetype<valueof<T>>(
-          __new(offsetof<nonnull<valueof<T>>>(), idof<nonnull<valueof<T>>>()),
-        );
-        // @ts-ignore: supplied by transform
-        if (isDefined(changetype<nonnull<valueof<T>>>(value).__INITIALIZE)) {
-          // @ts-ignore: supplied by transform
-          changetype<nonnull<valueof<T>>>(value).__INITIALIZE();
-        }
-        store<valueof<T>>(slot, value);
-      }
-
       const valueStart = srcStart;
-      // @ts-ignore: supplied by transform
-      if (
-        isDefined(changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_FAST)
-      ) {
-        // @ts-ignore: supplied by transform
-        srcStart = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_FAST<
-          valueof<T>
-        >(valueStart, srcEnd, value);
-      } else {
-        // @ts-ignore: supplied by transform
-        srcStart = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_SLOW<
-          valueof<T>
-        >(valueStart, srcEnd, value);
-      }
-      if (!srcStart || srcStart >= srcEnd) break;
+      const valueEnd = scanValueEnd(valueStart, srcEnd);
+      if (!valueEnd) break;
+
+      const value = JSON.__deserialize<valueof<T>>(
+        valueStart,
+        valueEnd,
+        changetype<usize>(load<valueof<T>>(slot)),
+      );
+      store<valueof<T>>(slot, value);
+      srcStart = valueEnd;
 
+      srcStart = skipWhitespace(srcStart, srcEnd);
       const code = load<u16>(srcStart);
       if (code == COMMA) {
         srcStart += 2;
+        srcStart = skipWhitespace(srcStart, srcEnd);
         index++;
         continue;
       }
       if (code == BRACKET_RIGHT) {
-        out.length = index + 1;
+        const nextLen = index + 1;
+        if (out.length != nextLen) out.length = nextLen;
         return srcStart + 2;
       }
       break;
@@ -73,7 +65,7 @@ import { ensureArrayElementSlot, ensureArrayField } from "./shared";
   srcEnd: usize,
   fieldPtr: usize,
 ): usize {
-  return deserializeObjectArrayInto<T>(
+  return deserializeObjectArrayBody<T>(
     srcStart,
     srcEnd,
     ensureArrayField<T>(fieldPtr),

package/assembly/deserialize/swar/array/raw.ts

@@ -1,4 +1,5 @@
 import { JSON } from "../../..";
+import { deserializeGenericArrayBody } from "./generic";
 import { ensureArrayField } from "./shared";
 
 
@@ -7,6 +8,9 @@ import { ensureArrayField } from "./shared";
   srcEnd: usize,
   fieldPtr: usize,
 ): usize {
-  ensureArrayField<JSON.Raw[]>(fieldPtr);
-  throw new Error("Failed to parse JSON!");
+  return deserializeGenericArrayBody<JSON.Raw[]>(
+    srcStart,
+    srcEnd,
+    ensureArrayField<JSON.Raw[]>(fieldPtr),
+  );
 }

package/assembly/deserialize/swar/array/shared.ts

@@ -7,6 +7,14 @@ import {
   COMMA,
   QUOTE,
 } from "../../../custom/chars";
+import { isSpace } from "../../../util";
+
+/** Advance past JSON whitespace (space, tab, LF, CR). */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function skipWhitespace(srcStart: usize, srcEnd: usize): usize {
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  return srcStart;
+}
 
 
 @inline export function ensureArrayField<T extends Array<any>>(
@@ -50,13 +58,21 @@ import {
 ): usize {
   const nextLength = index + 1;
   if (out.length < nextLength) {
-    out.length = nextLength;
-    const slot = out.dataStart + <usize>index * sizeof<valueof<T>>();
-    // Reference arrays can allocate recursively before the caller stores the new element.
-    // Zero the newly exposed slot immediately so incremental GC never observes a garbage pointer.
-    if (isManaged<valueof<T>>() || isReference<valueof<T>>())
-      store<usize>(slot, 0);
-    return slot;
+    // Grow via `push`, not `out.length = nextLength`. AS's `length=`
+    // setter calls `ensureCapacity(canGrow=false)` which reallocates to
+    // *exactly* the requested size — fine for a one-shot resize, but
+    // catastrophic in the per-element loop (every push triggers a full
+    // copy of the array, giving O(N²) growth cost). `push` goes through
+    // `canGrow=true`, doubling capacity geometrically as needed.
+    //
+    // We push a zero-bit default: `0` for primitives, the null reference
+    // for managed/reference element types. The caller overwrites this
+    // slot immediately, so the placeholder is never observed.
+    if (isManaged<valueof<T>>() || isReference<valueof<T>>()) {
+      out.push(changetype<valueof<T>>(0));
+    } else {
+      out.push(<valueof<T>>0);
+    }
   }
   return out.dataStart + <usize>index * sizeof<valueof<T>>();
 }
@@ -127,7 +143,15 @@ import {
 
   while (srcStart < srcEnd) {
     const code = load<u16>(srcStart);
-    if (code == COMMA || code == BRACKET_RIGHT || code == BRACE_RIGHT)
+    // Stop at the structural terminator OR trailing whitespace, so the returned
+    // range is the exact value (scalar parsers assume no trailing whitespace).
+    // Callers skip whitespace to reach the following `,`/`]`/`}`.
+    if (
+      code == COMMA ||
+      code == BRACKET_RIGHT ||
+      code == BRACE_RIGHT ||
+      isSpace(code)
+    )
       return srcStart;
     srcStart += 2;
   }