json-as 1.4.0 → 1.6.0

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

@@ -1,18 +1,16 @@
 import { deserializeIntegerArray_NAIVE } from "../../naive/array/integer";
 import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
 import { isSpace } from "../../../util";
+import { markProductionParseError } from "../../error";
 import { ensureArrayElementSlot, ensureArrayField } from "./shared";
 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
+// `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 {
+function storeSignedIntegerE<E extends number>(slot: usize, value: i64): void {
   if (sizeof<E>() == sizeof<i8>()) {
     store<i8>(slot, <i8>value);
   } else if (sizeof<E>() == sizeof<i16>()) {
@@ -26,8 +24,7 @@ import { parse4Digits_PairMul } from "../../../util/swar-int";
   }
 }
 
-
-@inline function storeUnsignedIntegerE<E extends number>(
+function storeUnsignedIntegerE<E extends number>(
   slot: usize,
   value: u64,
 ): void {
@@ -44,7 +41,7 @@ import { parse4Digits_PairMul } from "../../../util/swar-int";
   }
 }
 
-// The four parse helpers below take a `slot` pointer (`writePtr`) and store
+// The 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
@@ -53,57 +50,6 @@ import { parse4Digits_PairMul } from "../../../util/swar-int";
 // 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/.
-export function parseSignedIntegerScalar<E extends number>(
-  srcStart: usize,
-  srcEnd: usize,
-  slot: usize,
-): usize {
-  let negative = false;
-  let code = load<u16>(srcStart);
-  if (code == 45) {
-    negative = true;
-    srcStart += 2;
-    if (srcStart >= srcEnd) return 0;
-    code = load<u16>(srcStart);
-  }
-
-  let digit = <u32>code - 48;
-  if (digit > 9) return 0;
-
-  let value: u64 = digit;
-  srcStart += 2;
-  while (srcStart < srcEnd) {
-    digit = <u32>load<u16>(srcStart) - 48;
-    if (digit > 9) break;
-    value = value * 10 + digit;
-    srcStart += 2;
-  }
-
-  storeSignedIntegerE<E>(slot, negative ? -(<i64>value) : <i64>value);
-  return srcStart;
-}
-
-export function parseUnsignedIntegerScalar<E extends number>(
-  srcStart: usize,
-  srcEnd: usize,
-  slot: usize,
-): usize {
-  let digit = <u32>load<u16>(srcStart) - 48;
-  if (digit > 9) return 0;
-
-  let value: u64 = digit;
-  srcStart += 2;
-  while (srcStart < srcEnd) {
-    digit = <u32>load<u16>(srcStart) - 48;
-    if (digit > 9) break;
-    value = value * 10 + digit;
-    srcStart += 2;
-  }
-
-  storeUnsignedIntegerE<E>(slot, value);
-  return srcStart;
-}
-
 export function parseSignedIntegerSWAR<E extends number>(
   srcStart: usize,
   srcEnd: usize,
@@ -211,11 +157,7 @@ export function parseUnsignedIntegerSWAR<E extends number>(
   return srcStart;
 }
 
-
-@inline function skipIntegerArrayWhitespace(
-  srcStart: usize,
-  srcEnd: usize,
-): usize {
+function skipIntegerArrayWhitespace(srcStart: usize, srcEnd: usize): usize {
   while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) {
     srcStart += 2;
   }
@@ -235,7 +177,8 @@ export function deserializeIntegerArray_SLOW<T extends number[]>(
 
   out.length = 0;
   if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) {
-    throw new Error("Failed to parse JSON!");
+    markProductionParseError();
+    return changetype<T>(0);
   }
 
   srcStart += 2;
@@ -303,7 +246,8 @@ export function deserializeIntegerArray_SLOW<T extends number[]>(
     break;
   }
 
-  throw new Error("Failed to parse JSON!");
+  markProductionParseError();
+  return changetype<T>(0);
 }
 
 function deserializeIntegerArrayImpl<T extends number[]>(
@@ -316,7 +260,10 @@ function deserializeIntegerArrayImpl<T extends number[]>(
     dst || changetype<usize>(instantiate<T>()),
   );
   const originalSrcStart = srcStart;
-  const reusableLength = out.length;
+  const reusableLength = load<i32>(
+    changetype<usize>(out),
+    offsetof<T>("length_"),
+  );
 
   if (useSWAR && reusableLength != 0) {
     const dataStart = out.dataStart;
@@ -456,9 +403,11 @@ function deserializeIntegerArrayImpl<T extends number[]>(
 
     if (isSigned<valueof<T>>()) {
       while (srcStart < srcEnd) {
-        const next = useSWAR
-          ? parseSignedIntegerSWAR<valueof<T>>(srcStart, srcEnd, writePtr)
-          : parseSignedIntegerScalar<valueof<T>>(srcStart, srcEnd, writePtr);
+        const next = parseSignedIntegerSWAR<valueof<T>>(
+          srcStart,
+          srcEnd,
+          writePtr,
+        );
         if (!next) break;
         writePtr += elementSize;
         srcStart = next;
@@ -477,9 +426,11 @@ function deserializeIntegerArrayImpl<T extends number[]>(
       }
     } else {
       while (srcStart < srcEnd) {
-        const next = useSWAR
-          ? parseUnsignedIntegerSWAR<valueof<T>>(srcStart, srcEnd, writePtr)
-          : parseUnsignedIntegerScalar<valueof<T>>(srcStart, srcEnd, writePtr);
+        const next = parseUnsignedIntegerSWAR<valueof<T>>(
+          srcStart,
+          srcEnd,
+          writePtr,
+        );
         if (!next) break;
         writePtr += elementSize;
         srcStart = next;
@@ -661,7 +612,7 @@ function deserializeIntegerArrayBody<T extends number[]>(
       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
+      // (`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).
@@ -669,7 +620,7 @@ function deserializeIntegerArrayBody<T extends number[]>(
       // 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
+      // 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>>()
         ? parseSignedIntegerSWAR<valueof<T>>(srcStart, srcEnd, slot)
@@ -694,11 +645,11 @@ function deserializeIntegerArrayBody<T extends number[]>(
     }
   } while (false);
 
-  throw new Error("Failed to parse JSON!");
+  markProductionParseError();
+  return 0;
 }
 
-
-@inline export function deserializeIntegerArrayField<T extends number[]>(
+export function deserializeIntegerArrayField<T extends number[]>(
   srcStart: usize,
   srcEnd: usize,
   fieldPtr: usize,

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

@@ -1,8 +1,7 @@
 import { deserializeGenericArrayBody } from "./generic";
 import { ensureArrayField } from "./shared";
 
-
-@inline export function deserializeMapArrayField<T extends Map<any, any>[]>(
+export function deserializeMapArrayField<T extends Map<any, any>[]>(
   srcStart: usize,
   srcEnd: usize,
   fieldPtr: usize,

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

@@ -13,6 +13,12 @@ function deserializeObjectArrayBody<T extends unknown[]>(
   out: T,
 ): usize {
   let index = 0;
+  const reusableLength = load<i32>(
+    changetype<usize>(out),
+    offsetof<T>("length_"),
+  );
+  const reusableDataStart = out.dataStart;
+  const elementSize = sizeof<valueof<T>>();
 
   do {
     if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) break;
@@ -25,7 +31,10 @@ function deserializeObjectArrayBody<T extends unknown[]>(
     }
 
     while (srcStart < srcEnd) {
-      const slot = ensureArrayElementSlot<T>(out, index);
+      const slot =
+        index < reusableLength
+          ? reusableDataStart + <usize>index * elementSize
+          : ensureArrayElementSlot<T>(out, index);
       const valueStart = srcStart;
       const valueEnd = scanValueEnd(valueStart, srcEnd);
       if (!valueEnd) break;
@@ -48,7 +57,7 @@ function deserializeObjectArrayBody<T extends unknown[]>(
       }
       if (code == BRACKET_RIGHT) {
         const nextLen = index + 1;
-        if (out.length != nextLen) out.length = nextLen;
+        if (reusableLength != nextLen) out.length = nextLen;
         return srcStart + 2;
       }
       break;
@@ -58,8 +67,7 @@ function deserializeObjectArrayBody<T extends unknown[]>(
   throw new Error("Failed to parse JSON!");
 }
 
-
-@inline export function deserializeObjectArrayField<T extends unknown[]>(
+export function deserializeObjectArrayField<T extends unknown[]>(
   srcStart: usize,
   srcEnd: usize,
   fieldPtr: usize,

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

@@ -2,8 +2,7 @@ import { JSON } from "../../..";
 import { deserializeGenericArrayBody } from "./generic";
 import { ensureArrayField } from "./shared";
 
-
-@inline export function deserializeRawArrayField(
+export function deserializeRawArrayField(
   srcStart: usize,
   srcEnd: usize,
   fieldPtr: usize,

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

@@ -10,16 +10,12 @@ import {
 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 {
+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>>(
-  fieldPtr: usize,
-): T {
+export function ensureArrayField<T extends Array<any>>(fieldPtr: usize): T {
   let out = load<T>(fieldPtr);
   if (!changetype<usize>(out)) {
     out = changetype<T>(instantiate<T>());
@@ -28,8 +24,7 @@ import { isSpace } from "../../../util";
   return out;
 }
 
-
-@inline export function ensureArrayFieldAt<T extends Array<any>>(
+export function ensureArrayFieldAt<T extends Array<any>>(
   dstObj: usize,
   dstOffset: usize,
 ): T {
@@ -41,8 +36,7 @@ import { isSpace } from "../../../util";
   return out;
 }
 
-
-@inline function backslashOrQuoteMask(block: u64): u64 {
+function backslashOrQuoteMask(block: u64): u64 {
   const b = block ^ 0x005c_005c_005c_005c;
   const q = block ^ 0x0022_0022_0022_0022;
   return (
@@ -51,8 +45,7 @@ import { isSpace } from "../../../util";
   );
 }
 
-
-@inline export function ensureArrayElementSlot<T extends Array<any>>(
+export function ensureArrayElementSlot<T extends Array<any>>(
   out: T,
   index: i32,
 ): usize {
@@ -60,7 +53,7 @@ import { isSpace } from "../../../util";
   if (out.length < nextLength) {
     // 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
+    // *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.
@@ -79,7 +72,7 @@ import { isSpace } from "../../../util";
 
 export function scanQuotedValueEnd_SWAR(srcStart: usize, srcEnd: usize): usize {
   srcStart += 2;
-  const srcEnd8 = srcEnd >= 8 ? srcEnd - 8 : 0;
+  const srcEnd8 = srcEnd - 8;
 
   while (srcStart <= srcEnd8) {
     let mask = backslashOrQuoteMask(load<u64>(srcStart));

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

@@ -7,12 +7,9 @@ import {
 import { isSpace } from "../../../util";
 import { ensureArrayElementSlot, ensureArrayField } from "./shared";
 import { deserializeStringField_SWAR } from "../string";
+import { markProductionParseError } from "../../error";
 
-
-@inline function skipStringArrayWhitespace(
-  srcStart: usize,
-  srcEnd: usize,
-): usize {
+function skipStringArrayWhitespace(srcStart: usize, srcEnd: usize): usize {
   while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   return srcStart;
 }
@@ -23,6 +20,15 @@ function deserializeStringArrayBody<T extends string[]>(
   out: T,
 ): usize {
   let index = 0;
+  // Reused struct fields normally retain their array backing store. Cache the
+  // original slot range so the common path avoids an Array.length load and
+  // growth branch for every string.
+  const reusableLength = load<i32>(
+    changetype<usize>(out),
+    offsetof<T>("length_"),
+  );
+  const reusableDataStart = out.dataStart;
+  const elementSize = sizeof<valueof<T>>();
 
   do {
     if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) break;
@@ -35,13 +41,16 @@ function deserializeStringArrayBody<T extends string[]>(
     }
 
     while (srcStart < srcEnd) {
-      const slot = ensureArrayElementSlot<T>(out, index);
+      const slot =
+        index < reusableLength
+          ? reusableDataStart + <usize>index * elementSize
+          : ensureArrayElementSlot<T>(out, index);
       // Null fast path for `(string | null)[]`. "null" is 4 UTF-16 chars
       // = 8 bytes, exactly one u64 compare. Store 0 (the AS null reference)
       // and skip 8 bytes.
       //
       // We accept null tokens unconditionally rather than gating on
-      // `isNullable<valueof<T>>()` — AS's `valueof` of a nullable-array
+      // `isNullable<valueof<T>>()` - AS's `valueof` of a nullable-array
       // element type doesn't always preserve the nullable marker through
       // the dispatcher's `<T>` cast, so the gate would mis-fire for the
       // very case it's meant to handle. The runtime cost on plain
@@ -70,18 +79,18 @@ function deserializeStringArrayBody<T extends string[]>(
       }
       if (code == BRACKET_RIGHT) {
         const nextLen = index + 1;
-        if (out.length != nextLen) out.length = nextLen;
+        if (reusableLength != nextLen) out.length = nextLen;
         return srcStart + 2;
       }
       break;
     }
   } while (false);
 
-  throw new Error("Failed to parse JSON!");
+  markProductionParseError();
+  return 0;
 }
 
-
-@inline export function deserializeStringArrayField<T extends string[]>(
+export function deserializeStringArrayField<T extends string[]>(
   srcStart: usize,
   srcEnd: usize,
   fieldPtr: usize,
@@ -111,6 +120,11 @@ export function deserializeStringArray_SWAR<T extends string[]>(
     dst || changetype<usize>(instantiate<T>()),
   );
 
+  // Top-level exact-range entry. Field arrays use the cursor-returning body
+  // above, so trimming here preserves valid document whitespace without
+  // touching the hot generated-struct path.
+  while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
+
   // Worst-case sizing: shortest possible element is `""` followed by `,` =
   // 6 UTF-16 bytes, so `(srcLen + 5) / 6` upper-bounds the count. Clamp to
   // AS's BLOCK_MAXSIZE / sizeof<string ref> = (1<<28) - 4 elements; payloads
@@ -131,11 +145,16 @@ export function deserializeStringArray_SWAR<T extends string[]>(
   // Caller guarantees srcStart is at the opening `[`.
   if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) {
     out.length = 0;
-    return out;
+    markProductionParseError();
+    return changetype<T>(0);
   }
   srcStart += 2;
   srcStart = skipStringArrayWhitespace(srcStart, srcEnd);
   if (srcStart < srcEnd && load<u16>(srcStart) == BRACKET_RIGHT) {
+    if (srcStart + 2 != srcEnd) {
+      markProductionParseError();
+      return changetype<T>(0);
+    }
     out.length = 0;
     return out;
   }
@@ -164,6 +183,10 @@ export function deserializeStringArray_SWAR<T extends string[]>(
       continue;
     }
     if (code == BRACKET_RIGHT) {
+      if (srcStart + 2 != srcEnd) {
+        markProductionParseError();
+        return changetype<T>(0);
+      }
       const finalLen = i32(<usize>(writePtr - dataStart) / elementSize);
       if (out.length != finalLen) out.length = finalLen;
       return out;
@@ -171,5 +194,6 @@ export function deserializeStringArray_SWAR<T extends string[]>(
     break;
   }
 
-  throw new Error("Failed to parse JSON!");
+  markProductionParseError();
+  return changetype<T>(0);
 }

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

@@ -1,12 +1,33 @@
-import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
+import {
+  BRACE_LEFT,
+  BRACKET_LEFT,
+  BRACKET_RIGHT,
+  COMMA,
+} from "../../../custom/chars";
 import { isSpace } from "../../../util";
-import { ensureArrayElementSlot, ensureArrayField } from "./shared";
+import {
+  ensureArrayElementSlot,
+  ensureArrayField,
+  scanValueEnd,
+} from "./shared";
+import { markProductionParseError } from "../../error";
 
 
-@inline function skipStructArrayWhitespace(
-  srcStart: usize,
-  srcEnd: usize,
-): usize {
+@inline
+function skipStructArrayWhitespace(srcStart: usize, srcEnd: usize): usize {
+  // JSON.stringify(..., null, 2) at a root struct-array boundary emits exactly
+  // LF + two spaces + the next object (or LF + closing bracket). Keep that
+  // overwhelmingly common shape to two scalar loads; nested/foreign layouts
+  // retain the fully general fallback below.
+  if (
+    ASC_FEATURE_SIMD &&
+    srcStart + 8 <= srcEnd &&
+    load<u16>(srcStart) == 10 &&
+    load<u32>(srcStart, 2) == 0x0020_0020
+  ) {
+    const next = load<u16>(srcStart, 6);
+    if (next == BRACE_LEFT || next == BRACKET_RIGHT) return srcStart + 6;
+  }
   while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   return srcStart;
 }
@@ -32,11 +53,22 @@ function deserializeStructArrayBody<T extends unknown[]>(
   out: T,
 ): usize {
   let index = 0;
+  const reusableLength = load<i32>(
+    changetype<usize>(out),
+    offsetof<T>("length_"),
+  );
+  const reusableDataStart = out.dataStart;
+  const elementSize = sizeof<valueof<T>>();
+  let pretty = false;
 
   do {
     if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) break;
     srcStart += 2;
-    srcStart = skipStructArrayWhitespace(srcStart, srcEnd);
+    if (srcStart < srcEnd && load<u16>(srcStart) != BRACE_LEFT) {
+      const code = load<u16>(srcStart);
+      pretty = ASC_FEATURE_SIMD && (code == 10 || code == 13);
+      srcStart = skipStructArrayWhitespace(srcStart, srcEnd);
+    }
     if (srcStart >= srcEnd) break;
     if (load<u16>(srcStart) == BRACKET_RIGHT) {
       out.length = 0;
@@ -44,7 +76,10 @@ function deserializeStructArrayBody<T extends unknown[]>(
     }
 
     while (srcStart < srcEnd) {
-      const slot = ensureArrayElementSlot<T>(out, index);
+      const slot =
+        index < reusableLength
+          ? reusableDataStart + <usize>index * elementSize
+          : ensureArrayElementSlot<T>(out, index);
       let value = load<valueof<T>>(slot);
       if (changetype<usize>(value) == 0) {
         value = changetype<valueof<T>>(
@@ -58,31 +93,70 @@ function deserializeStructArrayBody<T extends unknown[]>(
         store<valueof<T>>(slot, value);
       }
 
+      const valueStart = srcStart;
       let next: usize = 0;
       if (
         // @ts-ignore: supplied by transform
         isDefined(changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_FAST)
       ) {
+        // Omit the explicit type arg so AS infers it from `value` — passing
+        // `<valueof<T>>` explicitly collides when the element type is itself
+        // generic (e.g. GenericTest<string>) because AS resolves `T` against
+        // the element class's own generic rather than this function's `T`.
         // @ts-ignore: supplied by transform
-        next = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_FAST<
-          valueof<T>
-        >(srcStart, srcEnd, value);
+        // @ts-ignore: supplied by transform in SIMD builds
+        if (
+          pretty &&
+          isDefined(
+            changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_FAST_PRETTY,
+          )
+        ) {
+          // @ts-ignore: supplied by transform
+          next = changetype<nonnull<valueof<T>>>(
+            value,
+          ).__DESERIALIZE_FAST_PRETTY(srcStart, srcEnd, value);
+        } else {
+          next = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_FAST(
+            srcStart,
+            srcEnd,
+            value,
+          );
+        }
       }
       if (!next) {
+        // __DESERIALIZE_SLOW requires srcEnd to point just past the closing
+        // `}` of *this* element (it asserts srcEnd-2 == `}`). Scan the value
+        // boundary first, then re-initialize the object so any partial state
+        // from the failed FAST attempt is cleared.
+        const valueEnd = scanValueEnd(valueStart, srcEnd);
+        if (!valueEnd) break;
         // @ts-ignore: supplied by transform
-        next = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_SLOW<
-          valueof<T>
-        >(srcStart, srcEnd, value);
+        if (isDefined(changetype<nonnull<valueof<T>>>(value).__INITIALIZE)) {
+          // @ts-ignore: supplied by transform
+          changetype<nonnull<valueof<T>>>(value).__INITIALIZE();
+        }
+        // @ts-ignore: supplied by transform
+        changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_SLOW(
+          valueStart,
+          valueEnd,
+          value,
+        );
+        next = valueEnd;
       }
       if (!next) break;
       srcStart = next;
-      srcStart = skipStructArrayWhitespace(srcStart, srcEnd);
       if (srcStart >= srcEnd) break;
 
-      const code = load<u16>(srcStart);
+      let code = load<u16>(srcStart);
+      if (code != COMMA && code != BRACKET_RIGHT) {
+        srcStart = skipStructArrayWhitespace(srcStart, srcEnd);
+        if (srcStart >= srcEnd) break;
+        code = load<u16>(srcStart);
+      }
       if (code == COMMA) {
         srcStart += 2;
-        srcStart = skipStructArrayWhitespace(srcStart, srcEnd);
+        if (srcStart < srcEnd && load<u16>(srcStart) != BRACE_LEFT)
+          srcStart = skipStructArrayWhitespace(srcStart, srcEnd);
         index++;
         continue;
       }
@@ -91,18 +165,32 @@ function deserializeStructArrayBody<T extends unknown[]>(
         // right length (e.g. canada-style geometry rings whose count
         // matches a previous parse).
         const nextLen = index + 1;
-        if (out.length != nextLen) out.length = nextLen;
+        if (reusableLength != nextLen) out.length = nextLen;
         return srcStart + 2;
       }
       break;
     }
   } while (false);
 
-  throw new Error("Failed to parse JSON!");
+  markProductionParseError();
+  return 0;
+}
+export function deserializeStructArray_SWAR<T extends unknown[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): T {
+  while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
+  const out = changetype<nonnull<T>>(
+    dst || changetype<usize>(instantiate<T>()),
+  );
+  const end = deserializeStructArrayBody<T>(srcStart, srcEnd, out);
+  if (end == srcEnd) return out;
+  markProductionParseError();
+  return changetype<T>(0);
 }
 
-
-@inline export function deserializeStructArrayField<T extends unknown[]>(
+export function deserializeStructArrayField<T extends unknown[]>(
   srcStart: usize,
   srcEnd: usize,
   fieldPtr: usize,

package/assembly/deserialize/swar/array.ts

@@ -13,9 +13,7 @@ import { deserializeStringArrayField } from "./array/string";
 import { deserializeStructArrayField } from "./array/struct";
 
 export { deserializeArrayField as deserializeArrayField_SWAR };
-
-
-@inline export function deserializeArrayField<T extends unknown[]>(
+export function deserializeArrayField<T extends unknown[]>(
   srcStart: usize,
   srcEnd: usize,
   dstObj: usize,