json-as 1.5.0 → 1.6.0

package/CHANGELOG.md

@@ -1,6 +1,10 @@
 # Changelog
 
-## Unreleased
+## 2026-08-03 - v1.6.0
+
+- perf: much faster deserialization by using default values as a cache.
+- fix(transform): resolve imported nested custom types across source-file dependencies and invoke their custom deserializers, including for nullable and reordered fields ([#215](https://github.com/JairusSW/json-as/pull/215)).
+- chore: add Guillermo Diez to the contributor list.
 
 ## 2026-06-10 - v1.5.0
 

package/README.md

@@ -604,6 +604,48 @@ How `json-as` stacks up against other JSON libraries on a ~5 KiB GitHub-repo pay
 
 <img src="https://raw.githubusercontent.com/JairusSW/json-as/refs/heads/docs/charts/v1.5.0/library-serialize.svg" alt="Library comparison - serialize throughput">
 
+### Runtime Comparison
+
+How fast the **same** `json-as` classic bench deserializes the minified payloads across six WebAssembly runtimes — including [WARP](https://github.com/wasm-ecosystem/wasm-compiler), a single-pass compiler built for embedded targets, alongside the optimizing JITs (Wasmtime, WAVM), the pure-Go wazero, and JS engines (V8, Bun).
+
+Each runtime runs the real `bench()` lib (warm up, time the loop, report MB/s itself) on a `NAIVE`-mode build with a shared feature set (no SIMD / bulk-memory / non-trapping float-to-int) so the executed code is equivalent. The WASI runtimes read the payload over WASI; V8/Bun via an `env`-ABI host. WARP has no WASI and — by design ("no recursions") — can't re-enter the module from a host import, so it runs through a small custom C++ host that links `performance.now`/`console.log`/`writeFile` with the payload embedded. The timed run is split into small frames with a full GC between them (the bench lib's `BENCH_FRAMES`, applied to every runtime so the measurement is identical); this excludes stop-the-world GC pauses and keeps WARP — an embedded, single-shot-oriented compiler — inside its stable envelope. Even so, WARP's single-pass codegen lands within a few percent of the optimizing JITs.
+
+<img src="https://raw.githubusercontent.com/JairusSW/json-as/refs/heads/docs/charts/v1.5.0/runtimes-deserialize.svg" alt="Deserialization throughput across WebAssembly runtimes">
+
+<details>
+<summary>Serialization throughput (click to expand)</summary>
+
+<img src="https://raw.githubusercontent.com/JairusSW/json-as/refs/heads/docs/charts/v1.5.0/runtimes-serialize.svg" alt="Serialization throughput across WebAssembly runtimes">
+</details>
+
+Reproduce locally (the JS engines and standalone runtimes are auto-detected; point `WARP_SRC` at a [wasm-ecosystem/wasm-compiler](https://github.com/wasm-ecosystem/wasm-compiler) checkout with its libs built — see the script header for the cmake flags):
+
+```bash
+WARP_SRC=/path/to/wasm-compiler npm run bench:runtimes
+npm run charts:runtimes
+```
+
+### Compiler Comparison
+
+A different axis: same source, same runtime (V8), different **compiler**. [warpo](https://github.com/wasm-ecosystem/warpo) is a next-generation AssemblyScript compiler; this compares `json-as` when built with stock `asc` vs `warpo`, each before and after a `wasm-opt -O4` pass.
+
+warpo produces consistently faster code on both directions, and the gap widens with number/structure density (Canada). `wasm-opt -O4` barely moves either (both already run binaryen optimizations), so the difference is the compilers' own codegen, not a missing post-pass.
+
+<img src="https://raw.githubusercontent.com/JairusSW/json-as/refs/heads/docs/charts/v1.5.0/warpo-vs-asc-deserialize.svg" alt="json-as deserialization: asc vs warpo compiler on V8">
+
+<details>
+<summary>Serialization (click to expand)</summary>
+
+<img src="https://raw.githubusercontent.com/JairusSW/json-as/refs/heads/docs/charts/v1.5.0/warpo-vs-asc-serialize.svg" alt="json-as serialization: asc vs warpo compiler on V8">
+</details>
+
+warpo can't run asc transform plugins, so the bench compiles the post-transform `.tmp.ts` (emitted via `JSON_WRITE`); see `scripts/run-bench.warpo.sh`. Reproduce:
+
+```bash
+npm run bench:warpo   # builds with asc + warpo, wasm-opt -O4 each, runs on v8
+npm run charts:warpo
+```
+
 ### Lazy Fields
 
 Mark a field `@lazy` (or `JSON.Lazy<T>`, or a whole class with `@json({ lazy: "auto" })`) to defer it: its raw JSON slice is stored at parse time and parsed only on first access. Fields you skip are never parsed, and untouched fields pass through their original bytes on serialize. See the [Lazy Fields guide](https://docs.jairus.dev/json-as/guide/lazy-fields) for the full API and trade-offs.

package/assembly/deserialize/error.ts

@@ -0,0 +1,21 @@
+// Malformed-range failures are recorded only on the cold error path and
+// consumed at a public JSON.parse boundary. Keeping the final throw there
+// makes it catchable by try-as without adding a success-path store or a
+// second validation scan.
+let productionParseError = false;
+
+export function markProductionParseError(): void {
+  productionParseError = true;
+}
+
+export function takeProductionParseError(): bool {
+  if (!productionParseError) return false;
+  productionParseError = false;
+  return true;
+}
+
+/** Mark a malformed cold path and return the shared zero cursor sentinel. */
+export function failProductionParse(): usize {
+  productionParseError = true;
+  return 0;
+}

package/assembly/deserialize/index/arbitrary.ts

@@ -1,22 +1,26 @@
 import { JSON } from "../..";
-import { deserializeBoolean } from "./bool";
+import { deserializeBooleanCode } from "./bool";
 import { deserializeFloat } from "./float";
 import { deserializeObject, deserializeJsonArray, getParseSrc } from "./object";
 import { deserializeString } from "./string";
 import { BRACE_LEFT, BRACKET_LEFT, CHAR_N, QUOTE } from "../../custom/chars";
 
+const NULL_WORD: u64 = 30399761348886638;
+
 export function deserializeArbitrary(
   srcStart: usize,
   srcEnd: usize,
   dst: usize,
 ): JSON.Value {
   const v = parseArbitraryValue(srcStart, srcEnd);
+  if (changetype<usize>(v) == 0) return v;
   // Reuse path (`JSON.parse<JSON.Value>(data, out)`): write the parsed bits into
   // the caller's handle (with the GC barrier for any managed payload).
   return dst != 0 ? JSON.Value.__adoptInto(dst, v) : v;
 }
 
 function parseArbitraryValue(srcStart: usize, srcEnd: usize): JSON.Value {
+  if (srcStart >= srcEnd) return changetype<JSON.Value>(0);
   const firstChar = load<u16>(srcStart);
   if (
     firstChar == QUOTE ||
@@ -29,19 +33,36 @@ function parseArbitraryValue(srcStart: usize, srcEnd: usize): JSON.Value {
     const src = getParseSrc();
     if (src.length != 0) {
       const end = JSON.Util.scanValueEnd<JSON.Value>(srcStart, srcEnd);
+      // A zero end is the scanner's failure sentinel. Never retain it in a
+      // lazy slice: subtracting the source base from zero would underflow and
+      // later materialization could read outside the source value.
+      if (end == 0) return changetype<JSON.Value>(0);
       return JSON.Value.fromSlice(srcStart, end, src);
     }
-    if (firstChar == QUOTE)
-      return JSON.Value.from(deserializeString(srcStart, srcEnd));
-    return firstChar == BRACE_LEFT
-      ? JSON.Value.from(deserializeObject(srcStart, srcEnd, 0))
-      : JSON.Value.from(deserializeJsonArray(srcStart, srcEnd, 0));
+    if (firstChar == QUOTE) {
+      const value = deserializeString(srcStart, srcEnd);
+      return changetype<usize>(value) != 0
+        ? JSON.Value.from(value)
+        : changetype<JSON.Value>(0);
+    }
+    const composite =
+      firstChar == BRACE_LEFT
+        ? changetype<usize>(deserializeObject(srcStart, srcEnd, 0))
+        : changetype<usize>(deserializeJsonArray(srcStart, srcEnd, 0));
+    return composite != 0
+      ? firstChar == BRACE_LEFT
+        ? JSON.Value.from(changetype<JSON.Obj>(composite))
+        : JSON.Value.from(changetype<JSON.Arr>(composite))
+      : changetype<JSON.Value>(0);
   } else if (firstChar - 48 <= 9 || firstChar == 45) {
     return JSON.Value.from(deserializeFloat<f64>(srcStart, srcEnd));
   } else if (firstChar == 116 || firstChar == 102) {
-    return JSON.Value.from(deserializeBoolean(srcStart, srcEnd));
+    const code = deserializeBooleanCode(srcStart, srcEnd);
+    return code != 0 ? JSON.Value.from(code == 2) : changetype<JSON.Value>(0);
   } else if (firstChar == CHAR_N) {
+    if (srcEnd - srcStart < 8 || load<u64>(srcStart) != NULL_WORD)
+      return changetype<JSON.Value>(0);
     return JSON.Value.from<usize>(0);
   }
-  return unreachable();
+  return changetype<JSON.Value>(0);
 }

package/assembly/deserialize/index/array.ts

@@ -11,6 +11,7 @@ import { deserializeObjectArray } from "../naive/array/object";
 import { deserializeRawArray } from "../naive/array/raw";
 import { deserializeStringArray_NAIVE } from "../naive/array/string";
 import { deserializeStructArray } from "../naive/array/struct";
+import { deserializeStructArray_SWAR } from "../swar/array/struct";
 import { deserializeIntegerArray_SIMD } from "../simd/array/integer";
 import { deserializeIntegerArray_SWAR } from "../swar/array/integer";
 import { deserializeFloatArray_SWAR } from "../swar/array/float";
@@ -82,7 +83,7 @@ export function deserializeArray<T extends unknown[]>(
       isDefined(type.__DESERIALIZE_SLOW) ||
       isDefined(type.__DESERIALIZE_FAST)
     ) {
-      return deserializeStructArray<T>(srcStart, srcEnd, dst);
+      return deserializeStructArray_SWAR<T>(srcStart, srcEnd, dst);
     }
     throw new Error("Could not parse array of type " + nameof<T>() + "!");
   } else {

package/assembly/deserialize/index/bool.ts

@@ -1 +1 @@
-export { deserializeBoolean } from "../naive/bool";
+export { deserializeBoolean, deserializeBooleanCode } from "../naive/bool";

package/assembly/deserialize/index/object.ts

@@ -3,4 +3,7 @@ export {
   deserializeJsonArray,
   setParseSrc,
   getParseSrc,
+  markProductionParseError,
+  takeProductionParseError,
 } from "../naive/object";
+export { failProductionParse } from "../error";

package/assembly/deserialize/index/string.ts

@@ -2,17 +2,24 @@ import { JSONMode } from "../..";
 import {
   deserializeString_NAIVE,
   deserializeStringField_NAIVE,
+  deserializeStringFieldTrusted_NAIVE,
 } from "../naive/string";
 import {
   deserializeString_SIMD,
   deserializeStringField_SIMD,
+  deserializeStringFieldTrusted_SIMD,
 } from "../simd/string";
 import {
   deserializeString_SWAR,
   deserializeStringField_SWAR,
+  deserializeStringFieldTrusted_SWAR,
 } from "../swar/string";
 
 export function deserializeString(srcStart: usize, srcEnd: usize): string {
+  // Whole-value decoders strip two UTF-16 code units before entering their
+  // optimized loops. Guard the actual memory-safety invariant here; complete
+  // RFC quote framing remains the strict-mode validator's job.
+  if (srcEnd - srcStart < 4) return changetype<string>(0);
   if (JSON_MODE == JSONMode.SIMD) {
     return deserializeString_SIMD(srcStart, srcEnd);
   } else if (JSON_MODE == JSONMode.NAIVE) {
@@ -36,3 +43,33 @@ export function deserializeStringField<T extends string | null>(
     return deserializeStringField_SWAR<T>(srcStart, srcEnd, dstObj, dstOffset);
   }
 }
+
+export function deserializeStringFieldTrusted(
+  payloadStart: usize,
+  srcEnd: usize,
+  dstObj: usize,
+  dstOffset: usize = 0,
+): usize {
+  if (JSON_MODE == JSONMode.SIMD) {
+    return deserializeStringFieldTrusted_SIMD(
+      payloadStart,
+      srcEnd,
+      dstObj,
+      dstOffset,
+    );
+  } else if (JSON_MODE == JSONMode.NAIVE) {
+    return deserializeStringFieldTrusted_NAIVE(
+      payloadStart,
+      srcEnd,
+      dstObj,
+      dstOffset,
+    );
+  } else {
+    return deserializeStringFieldTrusted_SWAR(
+      payloadStart,
+      srcEnd,
+      dstObj,
+      dstOffset,
+    );
+  }
+}

package/assembly/deserialize/index.ts

@@ -10,6 +10,5 @@ export * from "./index/raw";
 export * from "./index/set";
 export * from "./index/staticarray";
 export * from "./index/string";
-export * from "./index/struct";
 export * from "./index/typedarray";
 export * from "./index/unsigned";

package/assembly/deserialize/naive/array/arbitrary.ts

@@ -10,6 +10,7 @@ export function deserializeArbitraryArray(
     dst || changetype<usize>(instantiate<JSON.Value[]>()),
   );
   // Skip the opening '[' and parse elements single-pass until the matching ']'.
-  parseArrayBody(out, srcStart + 2, srcEnd);
-  return out;
+  return parseArrayBody(out, srcStart + 2, srcEnd) != 0
+    ? out
+    : changetype<JSON.Value[]>(0);
 }

package/assembly/deserialize/naive/array/array.ts

@@ -28,6 +28,7 @@ export function deserializeArrayArray<T extends unknown[][]>(
       if (load<u16>(srcStart) == BRACKET_LEFT) {
         const inner = instantiate<JSON.Value[]>();
         srcStart = parseArrayBody(inner, srcStart + 2, srcEnd);
+        if (srcStart == 0) return changetype<T>(0);
         // @ts-ignore: valueof<T> is JSON.Value[] in this branch
         out.push(changetype<valueof<T>>(changetype<usize>(inner)));
       } else {

package/assembly/deserialize/naive/array/bool.ts

@@ -6,13 +6,15 @@ import {
   FALSE_WORD_U64,
   TRUE_WORD_U64,
 } from "../../../custom/chars";
+import { markProductionParseError } from "../../error";
 
 /**
  * Strict boolean-array deserializer (`bool[]`, every JSON_MODE).
  *
  * Enforces RFC 8259 array structure: `[`-framed, single-comma separated, no
  * leading / trailing / doubled commas, and each element must be exactly the
- * literal `true` or `false`. Throws on any deviation.
+ * literal `true` or `false`. Returns the shared failure sentinel on any
+ * deviation.
  *
  * The token check is SWAR-shaped: one `u64` load matches all four chars of
  * `true`; `false` adds one `u16` load to confirm the trailing `e`.
@@ -27,12 +29,15 @@ export function deserializeBooleanArray<T extends boolean[]>(
   );
   out.length = 0; // dst may arrive pre-sized; re-parse from empty via push
 
-  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
-  if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT)
-    throw new Error("Invalid JSON array: expected '['");
-  if (load<u16>(srcEnd - 2) != BRACKET_RIGHT)
-    throw new Error("Invalid JSON array: expected ']'");
+  if (
+    srcStart >= srcEnd ||
+    load<u16>(srcStart) != BRACKET_LEFT ||
+    load<u16>(srcEnd - 2) != BRACKET_RIGHT
+  ) {
+    markProductionParseError();
+    return changetype<T>(0);
+  }
   srcStart += 2; // past '['
   srcEnd -= 2; // before ']'
 
@@ -51,17 +56,22 @@ export function deserializeBooleanArray<T extends boolean[]>(
       out.push(false);
       srcStart += 10;
     } else {
-      throw new Error("Invalid JSON array: expected 'true' or 'false'");
+      markProductionParseError();
+      return changetype<T>(0);
     }
 
     while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
     if (srcStart >= srcEnd) break;
-    if (load<u16>(srcStart) != COMMA)
-      throw new Error("Invalid JSON array: expected ',' or ']'");
+    if (load<u16>(srcStart) != COMMA) {
+      markProductionParseError();
+      return changetype<T>(0);
+    }
     srcStart += 2;
     while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
-    if (srcStart >= srcEnd)
-      throw new Error("Invalid JSON array: trailing comma");
+    if (srcStart >= srcEnd) {
+      markProductionParseError();
+      return changetype<T>(0);
+    }
   }
 
   return out;

package/assembly/deserialize/naive/array/box.ts

@@ -10,42 +10,22 @@ export function deserializeBoxArray<T extends JSON.Box<any>[]>(
   const out = changetype<nonnull<T>>(
     dst || changetype<usize>(instantiate<T>()),
   );
-  if (isBoolean<valueof<T>>()) {
-    srcStart += 2; // skip [
-    while (srcStart < srcEnd) {
-      const block = load<u64>(srcStart);
-      if (block == 28429475166421108) {
-        out.push(JSON.Box.from(true));
-        srcStart += 10;
-      } else if (block == 32370086184550502 && load<u16>(srcStart, 8) == 101) {
-        out.push(JSON.Box.from(false));
-        srcStart += 12;
-      } else {
-        srcStart += 2;
-      }
-    }
-    return out;
-  } else {
-    let lastIndex: usize = 0;
-    while (srcStart < srcEnd) {
-      const code = load<u16>(srcStart);
-      if (code - 48 <= 9 || code == 45) {
-        lastIndex = srcStart;
-        srcStart += 2;
-        while (srcStart < srcEnd) {
-          const code = load<u16>(srcStart);
-          if (code == COMMA || code == BRACKET_RIGHT || isSpace(code)) {
-            out.push(JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
-            // while (isSpace(load<u16>((srcStart += 2)))) {
-            //   /* empty */
-            // }
-            break;
-          }
-          srcStart += 2;
+  let lastIndex: usize = 0;
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (code - 48 <= 9 || code == 45) {
+      lastIndex = srcStart;
+      srcStart += 2;
+      while (srcStart < srcEnd) {
+        const code = load<u16>(srcStart);
+        if (code == COMMA || code == BRACKET_RIGHT || isSpace(code)) {
+          out.push(JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
+          break;
         }
+        srcStart += 2;
       }
-      srcStart += 2;
     }
+    srcStart += 2;
   }
   return out;
 }

package/assembly/deserialize/naive/array/float.ts

@@ -1,6 +1,7 @@
 import { isSpace } from "../../../util";
 import { COMMA, BRACKET_LEFT, BRACKET_RIGHT } from "../../../custom/chars";
 import { JSON } from "../../..";
+import { markProductionParseError } from "../../error";
 
 /**
  * Strict float-array deserializer (`f64[]` / `f32[]`).
@@ -8,8 +9,8 @@ import { JSON } from "../../..";
  * Enforces RFC 8259 array structure: `[`-framed, single-comma separated, no
  * leading / trailing / doubled commas, and no garbage between values. Each
  * element token is validated by `deserializeFloat_NAIVE` (via `JSON.__deserialize`),
- * so malformed numbers like `0e` / `-01` / `1.` are rejected here too. Throws on
- * any deviation.
+ * so malformed numbers like `0e` / `-01` / `1.` are rejected here too. Returns
+ * the shared failure sentinel on any deviation.
  */
 export function deserializeFloatArray_NAIVE<T extends number[]>(
   srcStart: usize,
@@ -24,12 +25,15 @@ export function deserializeFloatArray_NAIVE<T extends number[]>(
   out.length = 0;
 
   // Trim surrounding whitespace and require the enclosing brackets.
-  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
-  if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT)
-    throw new Error("Invalid JSON array: expected '['");
-  if (load<u16>(srcEnd - 2) != BRACKET_RIGHT)
-    throw new Error("Invalid JSON array: expected ']'");
+  if (
+    srcStart >= srcEnd ||
+    load<u16>(srcStart) != BRACKET_LEFT ||
+    load<u16>(srcEnd - 2) != BRACKET_RIGHT
+  ) {
+    markProductionParseError();
+    return changetype<T>(0);
+  }
   srcStart += 2; // past '['
   srcEnd -= 2; // before ']'
 
@@ -45,18 +49,24 @@ export function deserializeFloatArray_NAIVE<T extends number[]>(
       if (c == COMMA || isSpace(c)) break;
       srcStart += 2;
     }
-    if (srcStart == tokenStart)
-      throw new Error("Invalid JSON array: missing value");
+    if (srcStart == tokenStart) {
+      markProductionParseError();
+      return changetype<T>(0);
+    }
     out.push(JSON.__deserialize<valueof<T>>(tokenStart, srcStart));
 
     while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
     if (srcStart >= srcEnd) break; // end of array body
-    if (load<u16>(srcStart) != COMMA)
-      throw new Error("Invalid JSON array: expected ',' or ']'");
+    if (load<u16>(srcStart) != COMMA) {
+      markProductionParseError();
+      return changetype<T>(0);
+    }
     srcStart += 2; // past ','
     while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
-    if (srcStart >= srcEnd)
-      throw new Error("Invalid JSON array: trailing comma");
+    if (srcStart >= srcEnd) {
+      markProductionParseError();
+      return changetype<T>(0);
+    }
   }
 
   return out;

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

@@ -1,28 +1,28 @@
 import { atoi, isSpace } from "../../../util";
 import { COMMA, BRACKET_LEFT, BRACKET_RIGHT } from "../../../custom/chars";
+import { markProductionParseError } from "../../error";
 
 // Strict RFC 8259 integer-token check over [start, end): optional minus (signed
 // types only), then a lone `0` or [1-9] digits - no leading zeros, fraction,
-// exponent, or trailing garbage. Throws otherwise.
-function validateJSONInteger(start: usize, end: usize, signed: bool): void {
+// exponent, or trailing garbage. Returns false otherwise.
+function validateJSONInteger(start: usize, end: usize, signed: bool): bool {
   let ptr = start;
   if (ptr < end && load<u16>(ptr) == 45) {
-    if (!signed) throw new Error("Invalid JSON number: minus on unsigned");
+    if (!signed) return false;
     ptr += 2;
   }
-  if (ptr >= end) throw new Error("Invalid JSON number: expected digit");
+  if (ptr >= end) return false;
   const first = load<u16>(ptr);
   if (first == 48) {
     ptr += 2;
-    if (ptr < end && <u32>(load<u16>(ptr) - 48) <= 9)
-      throw new Error("Invalid JSON number: leading zero");
+    if (ptr < end && <u32>(load<u16>(ptr) - 48) <= 9) return false;
   } else if (<u32>(first - 48) <= 9) {
     ptr += 2;
     while (ptr < end && <u32>(load<u16>(ptr) - 48) <= 9) ptr += 2;
   } else {
-    throw new Error("Invalid JSON number: expected digit");
+    return false;
   }
-  if (ptr != end) throw new Error("Invalid JSON number: not an integer");
+  return ptr == end;
 }
 
 /**
@@ -30,7 +30,8 @@ function validateJSONInteger(start: usize, end: usize, signed: bool): void {
  *
  * Enforces RFC 8259 array structure: `[`-framed, single-comma separated, no
  * leading / trailing / doubled commas, and each element must be a valid JSON
- * integer (no leading zeros, fraction, or exponent). Throws on any deviation.
+ * integer (no leading zeros, fraction, or exponent). Returns the shared failure
+ * sentinel on any deviation.
  */
 export function deserializeIntegerArray_NAIVE<T extends number[]>(
   srcStart: usize,
@@ -42,12 +43,15 @@ export function deserializeIntegerArray_NAIVE<T extends number[]>(
   );
   out.length = 0; // dst may arrive pre-sized; re-parse from empty via push
 
-  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
-  if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT)
-    throw new Error("Invalid JSON array: expected '['");
-  if (load<u16>(srcEnd - 2) != BRACKET_RIGHT)
-    throw new Error("Invalid JSON array: expected ']'");
+  if (
+    srcStart >= srcEnd ||
+    load<u16>(srcStart) != BRACKET_LEFT ||
+    load<u16>(srcEnd - 2) != BRACKET_RIGHT
+  ) {
+    markProductionParseError();
+    return changetype<T>(0);
+  }
   srcStart += 2; // past '['
   srcEnd -= 2; // before ']'
 
@@ -62,19 +66,27 @@ export function deserializeIntegerArray_NAIVE<T extends number[]>(
       if (c == COMMA || isSpace(c)) break;
       srcStart += 2;
     }
-    if (srcStart == tokenStart)
-      throw new Error("Invalid JSON array: missing value");
-    validateJSONInteger(tokenStart, srcStart, signed);
+    if (
+      srcStart == tokenStart ||
+      !validateJSONInteger(tokenStart, srcStart, signed)
+    ) {
+      markProductionParseError();
+      return changetype<T>(0);
+    }
     out.push(atoi<valueof<T>>(tokenStart, srcStart));
 
     while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
     if (srcStart >= srcEnd) break;
-    if (load<u16>(srcStart) != COMMA)
-      throw new Error("Invalid JSON array: expected ',' or ']'");
+    if (load<u16>(srcStart) != COMMA) {
+      markProductionParseError();
+      return changetype<T>(0);
+    }
     srcStart += 2;
     while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
-    if (srcStart >= srcEnd)
-      throw new Error("Invalid JSON array: trailing comma");
+    if (srcStart >= srcEnd) {
+      markProductionParseError();
+      return changetype<T>(0);
+    }
   }
 
   return out;

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

@@ -34,6 +34,7 @@ export function deserializeObjectArray<T extends unknown[]>(
     if (load<u16>(srcStart) == BRACE_LEFT) {
       const obj = new JSON.Obj();
       srcStart = parseObjectBody(obj, srcStart + 2, srcEnd);
+      if (srcStart == 0) return changetype<T>(0);
       out.push(changetype<valueof<T>>(changetype<usize>(obj)));
     } else {
       srcStart += 2;