json-as 1.4.0 → 1.6.0

package/assembly/custom/chars.ts

@@ -1,85 +1,46 @@
 // Characters
-// @ts-ignore = Decorator is valid here
-@inline export const COMMA = 44;
-// @ts-ignore = Decorator is valid here
-@inline export const QUOTE = 34;
-// @ts-ignore = Decorator is valid here
-@inline export const BACK_SLASH = 92;
-// @ts-ignore: Decorator is valid here
-@inline export const FWD_SLASH = 47;
-// @ts-ignore: Decorator is valid here
-@inline export const BRACE_LEFT = 123;
-// @ts-ignore: Decorator is valid here
-@inline export const BRACE_RIGHT = 125;
-// @ts-ignore: Decorator is valid here
-@inline export const BRACKET_LEFT = 91;
-// @ts-ignore: Decorator is valid here
-@inline export const BRACKET_RIGHT = 93;
-// @ts-ignore: Decorator is valid here
-@inline export const COLON = 58;
-// @ts-ignore: Decorator is valid here
-@inline export const CHAR_T = 116;
-// @ts-ignore: Decorator is valid here
-@inline export const CHAR_R = 114;
-// @ts-ignore: Decorator is valid here
-@inline export const CHAR_U = 117;
-// @ts-ignore: Decorator is valid here
-@inline export const CHAR_E = 101;
-// @ts-ignore: Decorator is valid here
-@inline export const CHAR_F = 102;
-// @ts-ignore: Decorator is valid here
-@inline export const CHAR_A = 97;
-// @ts-ignore: Decorator is valid here
-@inline export const CHAR_L = 108;
-// @ts-ignore: Decorator is valid here
-@inline export const CHAR_S = 115;
-// @ts-ignore = Decorator is valid here
-@inline export const CHAR_N = 110;
-// @ts-ignore = Decorator is valid here
-@inline export const CHAR_B = 98;
+export const COMMA = 44;
+export const QUOTE = 34;
+export const BACK_SLASH = 92;
+export const FWD_SLASH = 47;
+export const BRACE_LEFT = 123;
+export const BRACE_RIGHT = 125;
+export const BRACKET_LEFT = 91;
+export const BRACKET_RIGHT = 93;
+export const COLON = 58;
+export const CHAR_T = 116;
+export const CHAR_R = 114;
+export const CHAR_U = 117;
+export const CHAR_E = 101;
+export const CHAR_F = 102;
+export const CHAR_A = 97;
+export const CHAR_L = 108;
+export const CHAR_S = 115;
+export const CHAR_N = 110;
+export const CHAR_B = 98;
 // Strings
-// @ts-ignore: Decorator is valid here
-@inline export const TRUE_WORD = "true";
-// @ts-ignore: Decorator is valid here
-@inline export const FALSE_WORD = "false";
-// @ts-ignore: Decorator is valid here
-@inline export const NULL_WORD = "null";
-// @ts-ignore: Decorator is valid here
-@inline export const BRACE_LEFT_WORD = "{";
-// @ts-ignore: Decorator is valid here
-@inline export const BRACKET_LEFT_WORD = "[";
-// @ts-ignore: Decorator is valid here
-@inline export const EMPTY_BRACKET_WORD = "[]";
-// @ts-ignore: Decorator is valid here
-@inline export const COLON_WORD = ":";
-// @ts-ignore: Decorator is valid here
-@inline export const COMMA_WORD = ",";
-// @ts-ignore: Decorator is valid here
-@inline export const BRACE_RIGHT_WORD = "}";
-// @ts-ignore: Decorator is valid here
-@inline export const BRACKET_RIGHT_WORD = "]";
-// @ts-ignore: Decorator is valid here
-@inline export const QUOTE_WORD = '"';
-// @ts-ignore: Decorator is valid here
-@inline export const EMPTY_QUOTE_WORD = '""';
+export const TRUE_WORD = "true";
+export const FALSE_WORD = "false";
+export const NULL_WORD = "null";
+export const BRACE_LEFT_WORD = "{";
+export const BRACKET_LEFT_WORD = "[";
+export const EMPTY_BRACKET_WORD = "[]";
+export const COLON_WORD = ":";
+export const COMMA_WORD = ",";
+export const BRACE_RIGHT_WORD = "}";
+export const BRACKET_RIGHT_WORD = "]";
+export const QUOTE_WORD = '"';
+export const EMPTY_QUOTE_WORD = '""';
 
 // Escape Codes
-// @ts-ignore: Decorator is valid here
-@inline export const BACKSPACE = 8; // \b
-// @ts-ignore: Decorator is valid here
-@inline export const TAB = 9; // \t
-// @ts-ignore: Decorator is valid here
-@inline export const NEW_LINE = 10; // \n
-// @ts-ignore: Decorator is valid here
-@inline export const FORM_FEED = 12; // \f
-// @ts-ignore: Decorator is valid here
-@inline export const CARRIAGE_RETURN = 13; // \r
+export const BACKSPACE = 8; // \b
+export const TAB = 9; // \t
+export const NEW_LINE = 10; // \n
+export const FORM_FEED = 12; // \f
+export const CARRIAGE_RETURN = 13; // \r
 
 // Pre-encoded u64 constants for common JSON literals
 // These represent the UTF-16 encoded bytes stored as u64 for fast comparison/storage
-// @ts-ignore: Decorator is valid here
-@inline export const NULL_WORD_U64: u64 = 30399761348886638; // "null" as u64 (n=110, u=117, l=108, l=108)
-// @ts-ignore: Decorator is valid here
-@inline export const TRUE_WORD_U64: u64 = 28429475166421108; // "true" as u64 (t=116, r=114, u=117, e=101)
-// @ts-ignore: Decorator is valid here
-@inline export const FALSE_WORD_U64: u64 = 32370086184550502; // "fals" as u64 (f=102, a=97, l=108, s=115) - first 4 chars of "false"
+export const NULL_WORD_U64: u64 = 30399761348886638; // "null" as u64 (n=110, u=117, l=108, l=108)
+export const TRUE_WORD_U64: u64 = 28429475166421108; // "true" as u64 (t=116, r=114, u=117, e=101)
+export const FALSE_WORD_U64: u64 = 32370086184550502; // "fals" as u64 (f=102, a=97, l=108, s=115) - first 4 chars of "false"

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,29 +1,68 @@
 import { JSON } from "../..";
-import { deserializeArray } from "./array";
-import { deserializeBoolean } from "./bool";
+import { deserializeBooleanCode } from "./bool";
 import { deserializeFloat } from "./float";
-import { deserializeObject } from "./object";
+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) {
-    return JSON.Value.from(deserializeString(srcStart, srcEnd));
-  } else if (firstChar == BRACE_LEFT) {
-    return JSON.Value.from(deserializeObject(srcStart, srcEnd, 0));
+  if (
+    firstChar == QUOTE ||
+    firstChar == BRACE_LEFT ||
+    firstChar == BRACKET_LEFT
+  ) {
+    // Lazy by default: when a parse is in flight (source anchor present), defer
+    // strings and composites (the allocating shapes) - store the exact raw slice
+    // and materialize on first access. Cheap primitives stay eager below.
+    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) {
+      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 == BRACKET_LEFT) {
-    return JSON.Value.from(deserializeArray<JSON.Value[]>(srcStart, srcEnd, 0));
   } 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/float.ts

@@ -12,8 +12,7 @@ import {
   deserializeFloatField_SIMD,
 } from "../simd/float";
 
-// @ts-ignore: inline
-@inline export function deserializeFloat<T>(srcStart: usize, srcEnd: usize): T {
+export function deserializeFloat<T>(srcStart: usize, srcEnd: usize): T {
   if (JSON_MODE == JSONMode.SIMD) {
     return deserializeFloat_SIMD<T>(srcStart, srcEnd);
   } else if (JSON_MODE == JSONMode.NAIVE) {
@@ -23,8 +22,7 @@ import {
   }
 }
 
-// @ts-ignore: inline
-@inline export function deserializeFloatField<T extends number>(
+export function deserializeFloatField<T extends number>(
   srcStart: usize,
   srcEnd: usize,
   dstObj: usize,

package/assembly/deserialize/index/integer.ts

@@ -21,8 +21,7 @@ import {
  * @param srcEnd   Pointer just past the last code unit.
  * @returns The parsed value, truncated to `T`.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function deserializeInteger<T extends number>(
+export function deserializeInteger<T extends number>(
   srcStart: usize,
   srcEnd: usize,
 ): T {
@@ -46,8 +45,7 @@ import {
  * @param dstOffset Byte offset of the field within `dstObj`.
  * @returns The source position immediately after the last digit consumed.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function deserializeIntegerField<T extends number>(
+export function deserializeIntegerField<T extends number>(
   srcStart: usize,
   srcEnd: usize,
   dstObj: usize,

package/assembly/deserialize/index/object.ts

@@ -1 +1,9 @@
-export { deserializeObject } from "../naive/object";
+export {
+  deserializeObject,
+  deserializeJsonArray,
+  setParseSrc,
+  getParseSrc,
+  markProductionParseError,
+  takeProductionParseError,
+} from "../naive/object";
+export { failProductionParse } from "../error";

package/assembly/deserialize/index/string.ts

@@ -2,21 +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";
 
-
-@inline export function deserializeString(
-  srcStart: usize,
-  srcEnd: usize,
-): 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) {
@@ -26,8 +29,7 @@ import {
   }
 }
 
-
-@inline export function deserializeStringField<T extends string | null>(
+export function deserializeStringField<T extends string | null>(
   srcStart: usize,
   srcEnd: usize,
   dstObj: usize,
@@ -41,3 +43,33 @@ import {
     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/unsigned.ts

@@ -21,8 +21,7 @@ import {
  * @param srcEnd   Pointer just past the last code unit.
  * @returns The parsed value, truncated to `T`.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function deserializeUnsigned<T extends number>(
+export function deserializeUnsigned<T extends number>(
   srcStart: usize,
   srcEnd: usize,
 ): T {
@@ -46,8 +45,7 @@ import {
  * @param dstOffset Byte offset of the field within `dstObj`.
  * @returns The source position immediately after the last digit consumed.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function deserializeUnsignedField<T extends number>(
+export function deserializeUnsignedField<T extends number>(
   srcStart: usize,
   srcEnd: usize,
   dstObj: usize,

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;