json-as 1.4.0 → 1.6.0

package/assembly/deserialize/naive/object.ts

@@ -14,16 +14,18 @@ import {
 import { isSpace, scanStringEnd } from "../../util";
 import { deserializeFloat } from "../index/float";
 import { deserializeString } from "../index/string";
+import {
+  failProductionParse,
+  markProductionParseError,
+  takeProductionParseError,
+} from "../error";
 
 // "true"  as a u64 of UTF-16 code units (LE).
-// @ts-ignore: inline
-@inline const TRUE_WORD: u64 = 28429475166421108;
-// "alse"  — the tail of "false", read at +2 so the leading 'f' is skipped.
-// @ts-ignore: inline
-@inline const ALSE_WORD: u64 = 28429466576093281;
+const TRUE_WORD: u64 = 28429475166421108;
+// "alse"  - the tail of "false", read at +2 so the leading 'f' is skipped.
+const ALSE_WORD: u64 = 28429466576093281;
 // "null"  as a u64 of UTF-16 code units (LE).
-// @ts-ignore: inline
-@inline const NULL_WORD: u64 = 30399761348886638;
+const NULL_WORD: u64 = 30399761348886638;
 
 // End offset (just past the value) of the most recent parseValue() call. The
 // recursive-descent parser reports each value's end through this single cursor
@@ -32,30 +34,170 @@ import { deserializeString } from "../index/string";
 // parseValue() runs, so recursion never clobbers a still-needed value.
 let parseValueEnd: usize = 0;
 
+// Source string for the parse currently in flight. When non-empty, nested
+// objects/arrays are deferred: instead of being recursively materialized, each
+// is stored as a lazy JSON.Value holding its raw slice + this anchor (see
+// JSON.Value.fromSlice / JSON.Types.Lazy). Set at the top of JSON.parse (and in
+// JSON.Value.materialize), both of which save/restore it for re-entrancy, so any
+// lazy value built during a parse points into that parse's own source buffer.
+let parseSrc: string = "";
+export function setParseSrc(s: string): void {
+  parseSrc = s;
+}
+export function getParseSrc(): string {
+  return parseSrc;
+}
+export { markProductionParseError, takeProductionParseError };
+
 export function deserializeObject(
   srcStart: usize,
   srcEnd: usize,
   dst: usize,
 ): JSON.Obj {
-  const out = changetype<JSON.Obj>(dst || changetype<usize>(new JSON.Obj()));
+  const reuse = dst != 0;
+  const out = changetype<JSON.Obj>(
+    reuse ? dst : changetype<usize>(new JSON.Obj()),
+  );
+  // Reuse path (`JSON.parse<JSON.Obj>(data, out)`): empty the handle first,
+  // keeping its buffer capacity, so we overwrite rather than append stale data.
+  if (reuse) out.clear();
+
+  while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
+
+  if (
+    srcEnd == srcStart ||
+    load<u16>(srcStart) != BRACE_LEFT ||
+    load<u16>(srcEnd - 2) != BRACE_RIGHT
+  ) {
+    failProductionParse();
+    return changetype<JSON.Obj>(0);
+  }
+
+  out.reserveForParse((srcEnd - srcStart) >> 1);
+  return parseObjectBody(out, srcStart + 2, srcEnd) != 0
+    ? out
+    : changetype<JSON.Obj>(0);
+}
+
+export function deserializeJsonArray(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): JSON.Arr {
+  const reuse = dst != 0;
+  const out = changetype<JSON.Arr>(
+    reuse ? dst : changetype<usize>(new JSON.Arr()),
+  );
+  if (reuse) out.clear();
 
   while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
 
-  if (srcEnd == srcStart)
-    throw new Error("Input string had zero length or was all whitespace");
-  if (load<u16>(srcStart) != BRACE_LEFT)
-    throw new Error(
-      "Expected '{' at start of object at position " +
-        (srcEnd - srcStart).toString(),
-    );
-  if (load<u16>(srcEnd - 2) != BRACE_RIGHT)
-    throw new Error(
-      "Expected '}' at end of object at position " +
-        (srcEnd - srcStart).toString(),
-    );
-
-  parseObjectBody(out, srcStart + 2, srcEnd);
-  return out;
+  if (
+    srcEnd == srcStart ||
+    load<u16>(srcStart) != BRACKET_LEFT ||
+    load<u16>(srcEnd - 2) != BRACKET_RIGHT
+  ) {
+    failProductionParse();
+    return changetype<JSON.Arr>(0);
+  }
+
+  return parseArrayBodySlots(out, srcStart + 2, srcEnd) != 0
+    ? out
+    : changetype<JSON.Arr>(0);
+}
+
+/**
+ * Parses array elements starting at `srcStart` (just past the opening `[`) into
+ * a JSON.Arr's NaN-boxed value slots, returning the offset just after the
+ * matching `]`. Mirrors {@link parseObjectBody} without keys.
+ */
+export function parseArrayBodySlots(
+  out: JSON.Arr,
+  srcStart: usize,
+  srcEnd: usize,
+): usize {
+  out._src = parseSrc;
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (isSpace(code) || code == COMMA) {
+      srcStart += 2;
+      continue;
+    }
+    if (code == BRACKET_RIGHT) return srcStart + 2;
+    if (parseSrc.length != 0) {
+      out.pushRawSlot(parseSlotBits(srcStart, srcEnd));
+    } else {
+      const value = parseValue(srcStart, srcEnd);
+      if (parseValueEnd == 0) return 0;
+      out.pushRawSlot(JSON.Value.bitsFrom<JSON.Value>(value));
+    }
+    if (parseValueEnd == 0) return 0;
+    srcStart = parseValueEnd;
+  }
+  return 0;
+}
+
+/**
+ * Parses a single object-member value into a NaN-boxed value slot, setting
+ * {@link parseValueEnd} to the offset just past it. Strings and composites are
+ * deferred (a `valBox(Lazy, startPtr)` slice the object parses on first access);
+ * numbers, booleans and null are parsed eagerly inline. Requires {@link parseSrc}
+ * to be set (the caller guards), since a lazy slot points into it.
+ */
+function parseSlotBits(srcStart: usize, srcEnd: usize): u64 {
+  if (srcStart >= srcEnd) {
+    parseValueEnd = 0;
+    markProductionParseError();
+    return JSON.Value.nullBits();
+  }
+  const code = load<u16>(srcStart);
+  if (code == QUOTE || code == BRACE_LEFT || code == BRACKET_LEFT) {
+    const end = JSON.Util.scanValueEnd<JSON.Value>(srcStart, srcEnd);
+    if (end == 0) {
+      parseValueEnd = 0;
+      markProductionParseError();
+      return JSON.Value.nullBits();
+    }
+    parseValueEnd = end;
+    return JSON.Value.lazyBits(changetype<usize>(parseSrc), srcStart, end);
+  } else if (code - 48 <= 9 || code == 45) {
+    let p = srcStart + 2;
+    while (p < srcEnd) {
+      const c = load<u16>(p);
+      if (c == COMMA || c == BRACKET_RIGHT || c == BRACE_RIGHT || isSpace(c))
+        break;
+      p += 2;
+    }
+    parseValueEnd = p;
+    return JSON.Value.f64Bits(deserializeFloat<f64>(srcStart, p));
+  } else if (code == CHAR_T) {
+    if (srcEnd - srcStart < 8 || load<u64>(srcStart) != TRUE_WORD) {
+      parseValueEnd = 0;
+      markProductionParseError();
+      return JSON.Value.nullBits();
+    }
+    parseValueEnd = srcStart + 8;
+    return JSON.Value.boolBits(true);
+  } else if (code == CHAR_F) {
+    if (srcEnd - srcStart < 10 || load<u64>(srcStart, 2) != ALSE_WORD) {
+      parseValueEnd = 0;
+      markProductionParseError();
+      return JSON.Value.nullBits();
+    }
+    parseValueEnd = srcStart + 10;
+    return JSON.Value.boolBits(false);
+  } else if (code == CHAR_N) {
+    if (srcEnd - srcStart < 8 || load<u64>(srcStart) != NULL_WORD) {
+      parseValueEnd = 0;
+      markProductionParseError();
+      return JSON.Value.nullBits();
+    }
+    parseValueEnd = srcStart + 8;
+    return JSON.Value.nullBits();
+  }
+  parseValueEnd = 0;
+  markProductionParseError();
+  return JSON.Value.nullBits();
 }
 
 /**
@@ -70,19 +212,34 @@ export function lastValueEnd(): usize {
 }
 
 export function parseValue(srcStart: usize, srcEnd: usize): JSON.Value {
+  if (srcStart >= srcEnd) {
+    parseValueEnd = 0;
+    markProductionParseError();
+    return changetype<JSON.Value>(0);
+  }
   const code = load<u16>(srcStart);
   if (code == QUOTE) {
     const end = scanStringEnd(srcStart, srcEnd);
-    if (end >= srcEnd) throw new Error("Unterminated string in JSON");
+    if (end >= srcEnd) {
+      parseValueEnd = 0;
+      markProductionParseError();
+      return changetype<JSON.Value>(0);
+    }
     parseValueEnd = end + 2;
-    return JSON.Value.from(deserializeString(srcStart, end + 2));
+    const value = deserializeString(srcStart, end + 2);
+    if (changetype<usize>(value) == 0) {
+      parseValueEnd = 0;
+      markProductionParseError();
+      return changetype<JSON.Value>(0);
+    }
+    return JSON.Value.from(value);
   } else if (code == BRACE_LEFT) {
     const obj = new JSON.Obj();
     parseValueEnd = parseObjectBody(obj, srcStart + 2, srcEnd);
     return JSON.Value.from(obj);
   } else if (code == BRACKET_LEFT) {
-    const arr = instantiate<JSON.Value[]>();
-    parseValueEnd = parseArrayBody(arr, srcStart + 2, srcEnd);
+    const arr = new JSON.Arr();
+    parseValueEnd = parseArrayBodySlots(arr, srcStart + 2, srcEnd);
     return JSON.Value.from(arr);
   } else if (code - 48 <= 9 || code == 45) {
     let p = srcStart + 2;
@@ -95,24 +252,33 @@ export function parseValue(srcStart: usize, srcEnd: usize): JSON.Value {
     parseValueEnd = p;
     return JSON.Value.from(deserializeFloat<f64>(srcStart, p));
   } else if (code == CHAR_T) {
-    if (load<u64>(srcStart) != TRUE_WORD)
-      throw new Error("Expected 'true' in JSON");
+    if (srcEnd - srcStart < 8 || load<u64>(srcStart) != TRUE_WORD) {
+      parseValueEnd = 0;
+      markProductionParseError();
+      return changetype<JSON.Value>(0);
+    }
     parseValueEnd = srcStart + 8;
     return JSON.Value.from(true);
   } else if (code == CHAR_F) {
-    if (load<u64>(srcStart, 2) != ALSE_WORD)
-      throw new Error("Expected 'false' in JSON");
+    if (srcEnd - srcStart < 10 || load<u64>(srcStart, 2) != ALSE_WORD) {
+      parseValueEnd = 0;
+      markProductionParseError();
+      return changetype<JSON.Value>(0);
+    }
     parseValueEnd = srcStart + 10;
     return JSON.Value.from(false);
   } else if (code == CHAR_N) {
-    if (load<u64>(srcStart) != NULL_WORD)
-      throw new Error("Expected 'null' in JSON");
+    if (srcEnd - srcStart < 8 || load<u64>(srcStart) != NULL_WORD) {
+      parseValueEnd = 0;
+      markProductionParseError();
+      return changetype<JSON.Value>(0);
+    }
     parseValueEnd = srcStart + 8;
     return JSON.Value.from<usize>(0);
   }
-  throw new Error(
-    "Unexpected character in JSON '" + String.fromCharCode(code) + "'",
-  );
+  parseValueEnd = 0;
+  markProductionParseError();
+  return changetype<JSON.Value>(0);
 }
 
 /**
@@ -132,10 +298,27 @@ export function parseArrayBody(
       continue;
     }
     if (code == BRACKET_RIGHT) return srcStart + 2;
-    out.push(parseValue(srcStart, srcEnd));
-    srcStart = parseValueEnd;
+    if (
+      (code == BRACE_LEFT || code == BRACKET_LEFT || code == QUOTE) &&
+      parseSrc.length != 0
+    ) {
+      // Defer strings and composites (the allocating shapes): store the raw
+      // slice, parse on first access. Cheap primitives stay eager below.
+      const end = JSON.Util.scanValueEnd<JSON.Value>(srcStart, srcEnd);
+      if (end == 0) {
+        markProductionParseError();
+        return 0;
+      }
+      out.push(JSON.Value.fromSlice(srcStart, end, parseSrc));
+      srcStart = end;
+    } else {
+      const value = parseValue(srcStart, srcEnd);
+      if (parseValueEnd == 0) return 0;
+      out.push(value);
+      srcStart = parseValueEnd;
+    }
   }
-  return srcEnd;
+  return 0;
 }
 
 /**
@@ -148,6 +331,12 @@ export function parseObjectBody(
   srcStart: usize,
   srcEnd: usize,
 ): usize {
+  const objectStart = srcStart - 2;
+  // Anchor the source for this object's deferred value slots (start pointers
+  // into it). Set here so every caller - deserializeObject, the JSON.Obj[]
+  // array path, parseValue, the map path - gets it. Empty off the parse path,
+  // where no lazy slots are produced.
+  out._src = parseSrc;
   while (srcStart < srcEnd) {
     let code = load<u16>(srcStart);
 
@@ -156,37 +345,43 @@ export function parseObjectBody(
       srcStart += 2;
       continue;
     }
-    if (code == BRACE_RIGHT) return srcStart + 2;
+    if (code == BRACE_RIGHT) {
+      const objectEnd = srcStart + 2;
+      out._rawStart = objectStart;
+      out._rawEnd = objectEnd;
+      return objectEnd;
+    }
 
     // --- key ---
-    if (code != QUOTE)
-      throw new Error(
-        "Unexpected character in JSON object '" +
-          String.fromCharCode(code) +
-          "' at position " +
-          (srcEnd - srcStart).toString(),
-      );
+    if (code != QUOTE) return failProductionParse();
     const keyStart = srcStart + 2;
     srcStart = scanStringEnd(srcStart, srcEnd);
-    if (srcStart >= srcEnd)
-      throw new Error("Unterminated string in JSON object");
+    if (srcStart >= srcEnd) return failProductionParse();
     const keyEnd = srcStart;
     srcStart += 2;
 
     // --- colon ---
     while (srcStart < srcEnd && isSpace((code = load<u16>(srcStart))))
       srcStart += 2;
-    if (srcStart >= srcEnd || code != COLON)
-      throw new Error(
-        "Expected ':' after key at position " + (srcEnd - srcStart).toString(),
-      );
+    if (srcStart >= srcEnd || code != COLON) return failProductionParse();
     srcStart += 2;
 
     // --- value ---
     while (srcStart < srcEnd && isSpace((code = load<u16>(srcStart))))
       srcStart += 2;
-    out.appendRaw(keyStart, keyEnd, parseValue(srcStart, srcEnd));
+    if (srcStart >= srcEnd) return failProductionParse();
+    if (parseSrc.length != 0) {
+      // Parsing: store a NaN-boxed slot directly (strings/composites deferred,
+      // scalars eager) - no per-value JSON.Value object.
+      out.appendParsedSlot(keyStart, keyEnd, parseSlotBits(srcStart, srcEnd));
+      if (parseValueEnd == 0) return 0;
+    } else {
+      // Off the parse path (no source anchor): box eagerly.
+      const value = parseValue(srcStart, srcEnd);
+      if (parseValueEnd == 0) return 0;
+      out.appendRaw(keyStart, keyEnd, value);
+    }
     srcStart = parseValueEnd;
   }
-  return srcEnd;
+  return 0;
 }

package/assembly/deserialize/naive/raw.ts

@@ -1,10 +1,18 @@
 import { JSON } from "../..";
 import { ptrToStr } from "../../util/ptrToStr";
 
-// @ts-ignore: inline
-@inline export function deserializeRaw(
+export function deserializeRaw(
   srcStart: usize,
   srcEnd: usize,
+  dst: usize = 0,
 ): JSON.Raw {
+  const size = srcEnd - srcStart;
+  if (dst) {
+    const out = changetype<JSON.Raw>(dst);
+    const data = changetype<string>(__renew(changetype<usize>(out.data), size));
+    memory.copy(changetype<usize>(data), srcStart, size);
+    out.data = data;
+    return out;
+  }
   return JSON.Raw.from(ptrToStr(srcStart, srcEnd));
 }

package/assembly/deserialize/naive/set.ts

@@ -63,7 +63,6 @@ function deserializeSetDirect<T extends Set<any>>(
   if (load<u16>(srcStart) == BRACKET_RIGHT) return srcStart + 2;
 
   while (srcStart < srcEnd) {
-    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
     const code = load<u16>(srcStart);
 
     // @ts-ignore: type
@@ -156,8 +155,7 @@ export function deserializeSet<T extends Set<any>>(
   return out;
 }
 
-// @ts-expect-error: Decorator valid here
-@inline function deserializeSetBody<T extends Set<any>>(
+function deserializeSetBody<T extends Set<any>>(
   srcStart: usize,
   srcEnd: usize,
   out: T,
@@ -166,8 +164,7 @@ export function deserializeSet<T extends Set<any>>(
   return deserializeSetDirect<T>(srcStart, srcEnd, changetype<nonnull<T>>(out));
 }
 
-// @ts-expect-error: Decorator valid here
-@inline export function deserializeSetField<T extends Set<any>>(
+export function deserializeSetField<T extends Set<any>>(
   srcStart: usize,
   srcEnd: usize,
   dstObj: usize,

package/assembly/deserialize/naive/staticarray.ts

@@ -21,7 +21,8 @@ function materializeStaticArray<T extends StaticArray<any>>(
   src: valueof<T>[],
   dst: usize,
 ): T {
-  const byteLength = <usize>src.length * sizeof<valueof<T>>();
+  const len = src.length;
+  const byteLength = <usize>len * sizeof<valueof<T>>();
   let out = dst;
 
   if (!out) {
@@ -31,7 +32,7 @@ function materializeStaticArray<T extends StaticArray<any>>(
   }
 
   const typed = changetype<T>(out);
-  for (let i = 0; i < src.length; i++) {
+  for (let i = 0; i < len; i++) {
     unchecked((typed[i] = unchecked(src[i])));
   }
   return typed;
@@ -112,8 +113,7 @@ export function deserializeStaticArray<T extends StaticArray<any>>(
   throw new Error("Could not parse static array of type " + nameof<T>() + "!");
 }
 
-
-@inline export function deserializeStaticArrayField<T extends StaticArray<any>>(
+export function deserializeStaticArrayField<T extends StaticArray<any>>(
   srcStart: usize,
   srcEnd: usize,
   dstObj: usize,

package/assembly/deserialize/naive/string.ts

@@ -3,16 +3,16 @@ import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
 import { __heap_base } from "memory";
 import { BACK_SLASH, QUOTE } from "../../custom/chars";
 import { DESERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
+import { markProductionParseError } from "../error";
+import { isValidStringEscape } from "../string-validation";
 
-// @ts-ignore: inline
-@inline function hexDigit(c: u16): u32 {
+function hexDigit(c: u16): u32 {
   if (c <= 0x39) return c - 0x30; // '0'-'9'
   if (c <= 0x46) return c - 0x37; // 'A'-'F'
   return c - 0x57; // 'a'-'f'
 }
 
-// @ts-ignore: inline
-@inline function hex4ToU16(srcStart: usize): u16 {
+function hex4ToU16(srcStart: usize): u16 {
   return <u16>(
     ((hexDigit(load<u16>(srcStart)) << 12) |
       (hexDigit(load<u16>(srcStart, 2)) << 8) |
@@ -21,47 +21,10 @@ import { DESERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
   );
 }
 
-// @ts-ignore: inline
-@inline function isHexDigit(c: u16): bool {
-  return (
-    (c >= 0x30 && c <= 0x39) ||
-    (c >= 0x41 && c <= 0x46) ||
-    (c >= 0x61 && c <= 0x66)
-  );
-}
-
-// Strict RFC 8259 check for the char following a backslash, at [escPtr, srcEnd).
-// Legal escapes: " \ / b f n r t and \uXXXX (4 hex digits). Throws otherwise:
-// unknown escape letter, a trailing backslash, or a short / non-hex \u.
-function validateEscape(escPtr: usize, srcEnd: usize): void {
-  if (escPtr >= srcEnd)
-    throw new Error("Invalid JSON string: incomplete escape");
-  const code = load<u16>(escPtr);
-  if (code == 0x75) {
-    // \uXXXX
-    if (escPtr + 10 > srcEnd)
-      throw new Error("Invalid JSON string: incomplete \\u escape");
-    if (
-      !isHexDigit(load<u16>(escPtr, 2)) ||
-      !isHexDigit(load<u16>(escPtr, 4)) ||
-      !isHexDigit(load<u16>(escPtr, 6)) ||
-      !isHexDigit(load<u16>(escPtr, 8))
-    )
-      throw new Error("Invalid JSON string: \\u escape needs 4 hex digits");
-    return;
-  }
-  // short escapes: " \ / b f n r t
-  if (
-    code != 0x22 &&
-    code != 0x5c &&
-    code != 0x2f &&
-    code != 0x62 &&
-    code != 0x66 &&
-    code != 0x6e &&
-    code != 0x72 &&
-    code != 0x74
-  )
-    throw new Error("Invalid JSON string: illegal escape");
+// RFC 8259 check for the char following a backslash, at [escPtr, srcEnd).
+// Legal escapes: " \ / b f n r t and \uXXXX (4 hex digits).
+function validateEscape(escPtr: usize, srcEnd: usize): bool {
+  return isValidStringEscape(escPtr - 2, srcEnd);
 }
 
 export function deserializeString_NAIVE(
@@ -75,8 +38,10 @@ export function deserializeString_NAIVE(
     srcEnd - srcStart < 4 ||
     load<u16>(srcStart) != QUOTE ||
     load<u16>(srcEnd - 2) != QUOTE
-  )
-    throw new Error("Invalid JSON string: missing surrounding quotes");
+  ) {
+    markProductionParseError();
+    return changetype<string>(0);
+  }
   // Strip quotes
   srcStart += 2;
   srcEnd -= 2;
@@ -91,13 +56,20 @@ export function deserializeString_NAIVE(
     // Early exit
     if (block !== 0x5c) {
       // RFC 8259: literal control chars (U+0000..U+001F) must be escaped.
-      if (block < 0x20)
-        throw new Error("Invalid JSON string: unescaped control character");
+      if (block < 0x20) {
+        bs.offset = bs.buffer + outStart;
+        markProductionParseError();
+        return changetype<string>(0);
+      }
       bs.offset += 2;
       continue;
     }
 
-    validateEscape(srcStart, srcEnd);
+    if (!validateEscape(srcStart, srcEnd)) {
+      bs.offset = bs.buffer + outStart;
+      markProductionParseError();
+      return changetype<string>(0);
+    }
     const code = load<u16>(srcStart);
     if (code !== 0x75) {
       // Short escapes (\n \t \" \\)
@@ -148,7 +120,7 @@ function writeStringToField(
 // Escape-bearing tail of the field parse: the clean prefix [payloadStart,
 // escPos) is bulk-copied into the scratch buffer, then escapes are decoded into
 // it, and the result is written to the field. Only reached when a backslash is
-// actually present — the common escape-free case never touches `bs`.
+// actually present - the common escape-free case never touches `bs`.
 function deserializeEscapedStringField_NAIVE(
   payloadStart: usize,
   escPos: usize,
@@ -194,27 +166,41 @@ function deserializeEscapedStringField_NAIVE(
     bs.offset += 2;
   }
 
-  abort("Expected closing quote");
+  markProductionParseError();
   return 0;
 }
 
 // NOT @inline: this is a loop-bearing scanner called per string field. As an
 // always-inline entry it gets inlined into every field call site inside the
 // @inline __DESERIALIZE_FAST, exploding binaryen's optimize phase on large
-// schemas (~118s on the `large` bench). Kept as a single shared function — one
-// call per field — matching the non-inline SWAR/SIMD field deserializers.
+// schemas (~118s on the `large` bench). Kept as a single shared function - one
+// call per field - matching the non-inline SWAR/SIMD field deserializers.
 export function deserializeStringField_NAIVE<T extends string | null>(
   srcStart: usize,
   srcEnd: usize,
   dstObj: usize,
   dstOffset: usize = 0,
 ): usize {
-  const dstFieldPtr = dstObj + dstOffset;
-  if (srcStart + 2 > srcEnd || load<u16>(srcStart) != QUOTE)
-    abort("Expected leading quote");
+  if (srcStart + 2 > srcEnd || load<u16>(srcStart) != QUOTE) {
+    markProductionParseError();
+    return 0;
+  }
+  return deserializeStringFieldTrusted_NAIVE(
+    srcStart + 2,
+    srcEnd,
+    dstObj,
+    dstOffset,
+  );
+}
 
-  const payloadStart = srcStart + 2;
-  srcStart = payloadStart;
+export function deserializeStringFieldTrusted_NAIVE(
+  payloadStart: usize,
+  srcEnd: usize,
+  dstObj: usize,
+  dstOffset: usize = 0,
+): usize {
+  const dstFieldPtr = dstObj + dstOffset;
+  let srcStart = payloadStart;
 
   // Scan for the closing quote without touching the scratch buffer. For the
   // common escape-free case the bytes are a verbatim slice of the source, so we
@@ -241,6 +227,6 @@ export function deserializeStringField_NAIVE<T extends string | null>(
     srcStart += 2;
   }
 
-  abort("Expected closing quote");
+  markProductionParseError();
   return 0;
 }

package/assembly/deserialize/naive/unsigned.ts

@@ -1,7 +1,6 @@
 import { atoi } from "../../util/atoi";
 
-// @ts-ignore: inline
-@inline export function deserializeUnsigned_NAIVE<T extends number>(
+export function deserializeUnsigned_NAIVE<T extends number>(
   srcStart: usize,
   srcEnd: usize,
 ): T {