json-as 1.5.0 → 1.6.1

package/assembly/index.ts

@@ -10,8 +10,9 @@ import {
   serializeSet,
   serializeStaticArray,
   serializeBool,
+  serializeBoolUnsafe,
   serializeInteger,
-  serializeFloat,
+  serializeIntegerUnsafe,
   serializeFloat32,
   serializeFloat64,
   serializeStruct,
@@ -24,7 +25,7 @@ import {
   serializeTypedArray,
 } from "./serialize";
 import {
-  deserializeBoolean,
+  deserializeBooleanCode,
   deserializeArray,
   deserializeFloat,
   deserializeMap,
@@ -42,7 +43,21 @@ import {
   deserializeTypedArray,
   setParseSrc,
   getParseSrc,
+  markProductionParseError,
+  takeProductionParseError,
+  failProductionParse as failProductionParseInternal,
 } from "./deserialize";
+import {
+  beginStringFieldTrace,
+  beginObjectFieldTrace,
+  endStringFieldTrace,
+  isPrettyParse,
+  objectFieldTraceMask,
+  objectFieldTraceSeparator,
+  objectFieldTraceTier,
+  recordObjectFieldTrace,
+  setPrettyParse,
+} from "./deserialize/parseMode";
 import {
   BACK_SLASH,
   BRACE_LEFT,
@@ -62,6 +77,11 @@ import { ptrToStr } from "./util/ptrToStr";
 import { atoi, bytes, scanStringEnd } from "./util";
 import { scanValueEnd_SIMD } from "./util/scanValueEndSimd";
 import { scanValueEnd_SWAR } from "./util/scanValueEndSwar";
+import {
+  hasLongPrettyIndent_SIMD,
+  skipPrettyWhitespace_SIMD,
+} from "./util/prettyWhitespaceSimd";
+import { normalizeJSONEncoding, validateJSON } from "./util/validateJson";
 
 const VAL_QNAN: u64 = 0x7ffc000000000000; // boxed signature (quiet NaN)
 const VAL_TAG_SHIFT: u8 = 45;
@@ -97,6 +117,13 @@ const STR_CLASS_UNKNOWN: u32 = 0;
 const STR_CLASS_CLEAN: u32 = 1;
 const STR_CLASS_ESCAPE: u32 = 2;
 
+// One rooted immutable source/type pair is enough to make repeated parsing of
+// an exact generated-default document allocation-only after its first match.
+// The source reference prevents pointer reuse after GC; a different source or
+// target type simply takes the normal matcher and replaces this cache on hit.
+let LAST_DEFAULT_SOURCE: string | null = null;
+let LAST_DEFAULT_TYPE: u32 = 0;
+
 function valBoxed(w: u64): bool {
   return (w & VAL_QNAN) == VAL_QNAN;
 }
@@ -370,14 +397,113 @@ export namespace JSON {
   }
 
   export function parse<T>(data: string, out: T = __zero<T>()): T {
+    if (JSON_STRICT) {
+      data = normalizeJSONEncoding(data);
+      if (!validateJSON(data)) throw new Error("Invalid JSON syntax");
+    }
+    let managePretty = false;
+    let simdPretty = false;
+    if (isReference<T>() || isManaged<T>()) {
+      const type = changetype<nonnull<T>>(0);
+      // @ts-expect-error: marker supplied by the json-as transform
+      if (isDefined(type.__DESERIALIZE_PRETTY_SPECIALIZED)) {
+        managePretty = true;
+        if (
+          ASC_FEATURE_SIMD &&
+          data.length >= 16_384 &&
+          data.length <= 2_000_000
+        ) {
+          const start = changetype<usize>(data);
+          const end = start + ((<usize>data.length) << 1);
+          let valueStart = start;
+          while (valueStart < end && JSON.Util.isSpace(load<u16>(valueStart)))
+            valueStart += 2;
+          if (valueStart + 2 < end) {
+            const open = load<u16>(valueStart);
+            const next = load<u16>(valueStart, 2);
+            simdPretty =
+              (open == BRACE_LEFT || open == BRACKET_LEFT) &&
+              (next == 10 || next == 13) &&
+              hasLongPrettyIndent_SIMD(valueStart, end);
+          }
+        }
+      }
+    }
+    // Resolve an exact generated-default hit directly at the public boundary.
+    // This avoids entering the general parser and avoids polling the cold error
+    // flag for a source that has already been fully compared. Generated matcher
+    // methods do not read `this`, so the compile-time type sentinel is a safe
+    // receiver until a match tells us an object allocation is actually needed.
+    if ((isReference<T>() || isManaged<T>()) && changetype<usize>(out) == 0) {
+      const type = changetype<nonnull<T>>(0);
+      // @ts-expect-error: marker supplied by the json-as transform
+      if (isDefined(type.__DESERIALIZE_DEFAULT)) {
+        const start = changetype<usize>(data);
+        const typeId = idof<nonnull<T>>();
+        const knownMatch =
+          LAST_DEFAULT_TYPE == typeId &&
+          changetype<usize>(LAST_DEFAULT_SOURCE) == start;
+        if (knownMatch) {
+          // @ts-expect-error: paired generated allocation-only factory
+          return changetype<T>(type.__DESERIALIZE_DEFAULT_NEW());
+        }
+        const end = start + ((<usize>data.length) << 1);
+        // @ts-expect-error: generated method is a receiver-independent factory
+        const value = type.__DESERIALIZE_DEFAULT(start, end);
+        if (changetype<usize>(value) != 0) {
+          LAST_DEFAULT_SOURCE = data;
+          LAST_DEFAULT_TYPE = typeId;
+          return changetype<T>(value);
+        }
+      }
+    }
+    // Generated scalar-only schemas cannot create lazy JSON.Obj/Arr/Value
+    // slices. Avoid two global reference writes (and their barriers) for these
+    // very small, latency-sensitive parses.
+    if (isReference<T>() || isManaged<T>()) {
+      const type = changetype<nonnull<T>>(0);
+      // @ts-expect-error: marker supplied by the json-as transform
+      if (isDefined(type.__DESERIALIZE_SOURCE_FREE)) {
+        let result: T;
+        beginStringFieldTrace(data, changetype<usize>(out), idof<nonnull<T>>());
+        if (managePretty) {
+          const prevPretty = isPrettyParse();
+          setPrettyParse(simdPretty);
+          result = parseInternal<T>(data, out);
+          setPrettyParse(prevPretty);
+        } else {
+          result = parseInternal<T>(data, out);
+        }
+        const failed = takeProductionParseError();
+        endStringFieldTrace(!failed);
+        if (failed) throw new Error("Incomplete or malformed JSON value");
+        return result;
+      }
+    }
     // Anchor the source for any lazy JSON.Obj/JSON.Value built while parsing, so
     // their stored slice pointers (into `data`'s buffer) stay valid and resolve
     // against the right string. Save/restore makes nested parses (e.g. a custom
     // deserializer calling JSON.parse, or JSON.Obj.from) re-entrant-safe.
     const prevSrc = getParseSrc();
     setParseSrc(data);
-    const result = parseInternal<T>(data, out);
+    if (isReference<T>() || isManaged<T>()) {
+      beginStringFieldTrace(data, changetype<usize>(out), idof<nonnull<T>>());
+    } else {
+      beginStringFieldTrace(data, 0, 0);
+    }
+    let result: T;
+    if (managePretty) {
+      const prevPretty = isPrettyParse();
+      setPrettyParse(simdPretty);
+      result = parseInternal<T>(data, out);
+      setPrettyParse(prevPretty);
+    } else {
+      result = parseInternal<T>(data, out);
+    }
     setParseSrc(prevSrc);
+    const failed = takeProductionParseError();
+    endStringFieldTrace(!failed);
+    if (failed) throw new Error("Incomplete or unterminated JSON value");
     return result;
   }
 
@@ -393,7 +519,9 @@ export namespace JSON {
       dataPtr += 2;
     const dataSize = dataEnd - dataPtr;
     if (isBoolean<T>()) {
-      return deserializeBoolean(dataPtr, dataPtr + dataSize) as T;
+      const code = deserializeBooleanCode(dataPtr, dataPtr + dataSize);
+      if (code == 0) markProductionParseError();
+      return (code == 2) as T;
     } else if (isInteger<T>()) {
       return isSigned<T>()
         ? deserializeInteger<T>(dataPtr, dataPtr + dataSize)
@@ -407,7 +535,15 @@ export namespace JSON {
     ) {
       return null;
     } else if (isString<T>()) {
-      return deserializeString(dataPtr, dataPtr + dataSize) as T;
+      // Whole-string decoders require quote-inclusive bounds. Trim only the
+      // insignificant suffix here; the normal no-whitespace path pays one
+      // predicted-not-taken branch.
+      let stringEnd = dataEnd;
+      while (stringEnd > dataPtr && JSON.Util.isSpace(load<u16>(stringEnd - 2)))
+        stringEnd -= 2;
+      const value = deserializeString(dataPtr, stringEnd);
+      if (changetype<usize>(value) == 0) markProductionParseError();
+      return value as T;
     } else {
       let type: nonnull<T> = changetype<nonnull<T>>(0);
       // @ts-expect-error: Defined by transform
@@ -427,20 +563,39 @@ export namespace JSON {
           : changetype<nonnull<T>>(
               __new(offsetof<nonnull<T>>(), idof<nonnull<T>>()),
             );
-        // A freshly allocated object holds uninitialized fields (__new does not
-        // zero). The fast path writes fields in place and may leave some
-        // unwritten (@optional / skip-unknown), so it must run against defaults,
-        // not garbage. A reused graph is already initialized - skip it.
+        // A successful generated full-write path assigns every field. Zeroing a
+        // fresh payload is enough to make its reference slots safe while
+        // avoiding redundant default graph construction; a fast miss still
+        // initializes normally before the slow retry below.
         // @ts-expect-error: Defined by transform
-        if (!reuse && isDefined(type.__INITIALIZE)) obj.__INITIALIZE();
+        const fullWrite = isDefined(type.__DESERIALIZE_FULL_WRITE);
+        if (!reuse) {
+          if (fullWrite) {
+            memory.fill(changetype<usize>(obj), 0, offsetof<nonnull<T>>());
+          } else if (isDefined(type.__INITIALIZE)) {
+            // @ts-expect-error: Defined by transform
+            obj.__INITIALIZE();
+          }
+        }
         // @ts-expect-error: Defined by transform
         if (isDefined(type.__DESERIALIZE_FAST)) {
-          // @ts-expect-error: Defined by transform
-          const fastEnd = obj.__DESERIALIZE_FAST(
-            dataPtr,
-            dataPtr + dataSize,
-            obj,
-          );
+          let fastEnd: usize;
+          // @ts-expect-error: Defined by transform in SIMD builds
+          if (
+            ASC_FEATURE_SIMD &&
+            isPrettyParse() &&
+            isDefined(type.__DESERIALIZE_FAST_PRETTY)
+          ) {
+            // @ts-expect-error: Defined by transform
+            fastEnd = obj.__DESERIALIZE_FAST_PRETTY(
+              dataPtr,
+              dataPtr + dataSize,
+              obj,
+            );
+          } else {
+            // @ts-expect-error: Defined by transform
+            fastEnd = obj.__DESERIALIZE_FAST(dataPtr, dataPtr + dataSize, obj);
+          }
           // A non-zero return means the fast path matched; accept it when only
           // trailing whitespace remains (pretty-printed input ends with a
           // newline, so the cursor stops just past `}` rather than at srcEnd).
@@ -459,7 +614,12 @@ export namespace JSON {
         // @ts-expect-error: Defined by transform
         if (isDefined(type.__DESERIALIZE_SLOW)) {
           // @ts-expect-error: Defined by transform
-          obj.__DESERIALIZE_SLOW(dataPtr, dataPtr + dataSize, obj);
+          const slowEnd = obj.__DESERIALIZE_SLOW(
+            dataPtr,
+            dataPtr + dataSize,
+            obj,
+          );
+          if (slowEnd == 0) markProductionParseError();
           // @ts-expect-error: Defined by transform for @lazy-field structs.
           if (isDefined(obj.__SET_SRC)) obj.__SET_SRC(data);
           return obj;
@@ -477,13 +637,15 @@ export namespace JSON {
         // Reuse the caller-supplied array when given (no allocation); the
         // element loop overwrites slots and trims length. Otherwise allocate.
         // @ts-expect-error
-        return deserializeArray<nonnull<T>>(
+        const value = deserializeArray<nonnull<T>>(
           dataPtr,
           dataPtr + dataSize,
           changetype<usize>(out) != 0
             ? changetype<usize>(out)
             : changetype<usize>(instantiate<T>()),
         );
+        if (changetype<usize>(value) == 0) markProductionParseError();
+        return value;
       } else if (
         type instanceof Int8Array ||
         type instanceof Uint8Array ||
@@ -510,11 +672,13 @@ export namespace JSON {
       } else if (type instanceof Map) {
         // Reuse the caller-supplied map when given (keys overwrite in place).
         // @ts-expect-error
-        return deserializeMap<nonnull<T>>(
+        const value = deserializeMap<nonnull<T>>(
           dataPtr,
           dataPtr + dataSize,
           changetype<usize>(out),
         );
+        if (changetype<usize>(value) == 0) markProductionParseError();
+        return value;
       } else if (type instanceof Date) {
         // @ts-expect-error
         return deserializeDate(dataPtr, dataPtr + dataSize);
@@ -525,27 +689,33 @@ export namespace JSON {
         // Reuse the caller-supplied JSON.Value handle when given (`out`); the
         // deserializer writes the parsed bits into it. Otherwise allocate.
         // @ts-expect-error
-        return deserializeArbitrary(
+        const value = deserializeArbitrary(
           dataPtr,
           dataPtr + dataSize,
           changetype<usize>(out),
         );
+        if (changetype<usize>(value) == 0) markProductionParseError();
+        return value;
       } else if (type instanceof JSON.Obj) {
         // Reuse the caller-supplied JSON.Obj (cleared, buffers kept). Otherwise allocate.
         // @ts-expect-error
-        return deserializeObject(
+        const value = deserializeObject(
           dataPtr,
           dataPtr + dataSize,
           changetype<usize>(out),
         );
+        if (changetype<usize>(value) == 0) markProductionParseError();
+        return value;
       } else if (type instanceof JSON.Arr) {
         // Reuse the caller-supplied JSON.Arr (cleared, buffers kept). Otherwise allocate.
         // @ts-expect-error
-        return deserializeJsonArray(
+        const value = deserializeJsonArray(
           dataPtr,
           dataPtr + dataSize,
           changetype<usize>(out),
         );
+        if (changetype<usize>(value) == 0) markProductionParseError();
+        return value;
       } else if (type instanceof JSON.Box) {
         // @ts-expect-error
         return new JSON.Box(parseBox(data, changetype<nonnull<T>>(0).value));
@@ -1257,11 +1427,37 @@ export namespace JSON {
     _vused: i32 = 0;
     /** Source string the lazy slot pointers index into; anchors it for GC. */
     _src: string = "";
+    /** Untouched source range for whole-object serialization passthrough. */
+    _rawStart: usize = 0;
+    _rawEnd: usize = 0;
     private _index: StaticArray<i32> | null = null;
     private _indexMask: i32 = 0;
 
     constructor() {}
 
+    /**
+     * Pre-sizes the three flat parse buffers from the source span. The parser
+     * still grows normally if an unusual key-heavy document exceeds the
+     * estimate; ordinary API-shaped objects avoid the repeated 8→16→32...
+     * allocation/copy ladder.
+     */
+    reserveForParse(sourceUnits: usize): void {
+      let keyNeed = <i32>((sourceUnits + 2) / 3);
+      if (keyNeed < 16) keyNeed = 16;
+      let keyCap = 16;
+      while (keyCap < keyNeed) keyCap <<= 1;
+      if (this._kbuf.length < keyCap) this._kbuf = new StaticArray<u16>(keyCap);
+
+      let slotNeed = <i32>(sourceUnits >> 6);
+      if (slotNeed < 8) slotNeed = 8;
+      let slotCap = 8;
+      while (slotCap < slotNeed) slotCap <<= 1;
+      if (this._kpos.length < slotCap)
+        this._kpos = new StaticArray<i32>(slotCap);
+      if (this._vals.length < slotCap)
+        this._vals = new StaticArray<u64>(slotCap);
+    }
+
     /**
      * Gets the number of key-value pairs in the object.
      */
@@ -1458,6 +1654,11 @@ export namespace JSON {
     private materializeSlot(i: i32): u64 {
       const slot = unchecked(this._vals[i]);
       if (!JSON.Value.slotIsLazy(slot)) return slot;
+      // A materialized nested object can subsequently be mutated through the
+      // returned reference. Stop whole-object passthrough so serialization
+      // observes that mutation and walks the cached slots instead.
+      this._rawStart = 0;
+      this._rawEnd = 0;
       const base = changetype<usize>(this._src);
       const start = JSON.Value.slotPtr(slot, base);
       const end = JSON.Value.slotEnd(slot, base, this.srcEnd());
@@ -1472,12 +1673,49 @@ export namespace JSON {
      * per-key string allocation, no per-value object, no hashing.
      */
     appendRawSlot(keyStart: usize, keyEnd: usize, bits: u64): void {
+      this._rawStart = 0;
+      this._rawEnd = 0;
       const slotIndex = this._vused;
       this.pushKeyBytes(keyStart, keyEnd, slotIndex);
       this.pushValSlot(bits);
       this.insertIndex(slotIndex);
     }
 
+    /**
+     * Parser-only append for slots produced by parseSlotBits. Those bits are
+     * either immediate scalars or source-relative Lazy slices, so they never
+     * require a GC link. The common pre-sized case writes all three buffers
+     * directly; unusual key-heavy documents retain the general growth path.
+     */
+    appendParsedSlot(keyStart: usize, keyEnd: usize, bits: u64): void {
+      this._rawStart = 0;
+      this._rawEnd = 0;
+      const slotIndex = this._vused;
+      const len = <i32>((keyEnd - keyStart) >> 1);
+      const keyPos = this._kused;
+      if (
+        keyPos + 1 + len <= this._kbuf.length &&
+        slotIndex < this._kpos.length &&
+        slotIndex < this._vals.length
+      ) {
+        const keyBuf = changetype<usize>(this._kbuf);
+        store<u16>(keyBuf + ((<usize>keyPos) << 1), <u16>len);
+        if (len)
+          memory.copy(
+            keyBuf + ((<usize>(keyPos + 1)) << 1),
+            keyStart,
+            (<usize>len) << 1,
+          );
+        unchecked((this._kpos[slotIndex] = keyPos));
+        unchecked((this._vals[slotIndex] = bits));
+        this._kused = keyPos + 1 + len;
+        this._vused = slotIndex + 1;
+        return;
+      }
+      this.pushKeyBytes(keyStart, keyEnd, slotIndex);
+      this.pushValSlot(bits);
+    }
+
     /**
      * Appends a key and value (any T) without a duplicate-key check. Eagerly
      * boxes the value into a slot.
@@ -1550,6 +1788,8 @@ export namespace JSON {
      * @param value - The value (will be wrapped in JSON.Value)
      */
     set<T>(key: string, value: T): void {
+      this._rawStart = 0;
+      this._rawEnd = 0;
       const bits = JSON.Value.bitsFrom<T>(value);
       const i = this.indexOf(key);
       if (i >= 0) {
@@ -1620,6 +1860,8 @@ export namespace JSON {
     delete(key: string): bool {
       const removed = this.indexOf(key);
       if (removed < 0) return false;
+      this._rawStart = 0;
+      this._rawEnd = 0;
       const keys = this.keys();
       const oldVals = this._vals;
       const n = this._vused;
@@ -1652,9 +1894,10 @@ export namespace JSON {
      */
     clear(): void {
       this._kused = 0;
-      this._kpos = EMPTY_I32S;
       this._vused = 0;
       this._src = "";
+      this._rawStart = 0;
+      this._rawEnd = 0;
       this._index = null;
       this._indexMask = 0;
     }
@@ -1722,7 +1965,8 @@ export namespace JSON {
 
         const keys = value.keys();
         const values = value.values();
-        for (let i = 0; i < keys.length; i++) {
+        const len = keys.length;
+        for (let i = 0; i < len; i++) {
           out.set(unchecked(keys[i]), unchecked(values[i]));
         }
         return out;
@@ -1922,7 +2166,8 @@ export namespace JSON {
         const out = new JSON.Arr();
         // @ts-expect-error: T is JSON.Value[] here
         const arr = changetype<JSON.Value[]>(value);
-        for (let i = 0; i < arr.length; i++) {
+        const len = arr.length;
+        for (let i = 0; i < len; i++) {
           out.pushRawSlot(JSON.Value.bitsFrom<JSON.Value>(unchecked(arr[i])));
         }
         return out;
@@ -2369,6 +2614,24 @@ export namespace JSON {
     }
   }
 
+  /**
+   * Primitive serializer for generated structs that already reserved the
+   * complete worst-case output size in `__SERIALIZE`. Avoids repeating buffer
+   * capacity and stack-size accounting for every integer/boolean field.
+   * Internal: emitted only for non-nullable primitive fields by the transform.
+   */
+  function __serializePrimitiveUnsafe<T>(data: T): void {
+    if (isBoolean<T>()) {
+      serializeBoolUnsafe(data as bool);
+    } else if (isInteger<T>()) {
+      // @ts-expect-error: transform emits this only for integer T
+      serializeIntegerUnsafe<T>(data);
+    } else {
+      // Defensive fallback for hand-written transformed code.
+      __serialize<T>(data);
+    }
+  }
+
   /**
    * Deserializes JSON data directly from the buffer.
    * Should only be used if you know what you are doing.
@@ -2385,7 +2648,9 @@ export namespace JSON {
       srcStart += 2;
     if (isBoolean<T>()) {
       // @ts-expect-error: type
-      return deserializeBoolean(srcStart, srcEnd);
+      const code = deserializeBooleanCode(srcStart, srcEnd);
+      if (code == 0) throw new Error("Expected 'true' or 'false' in JSON");
+      return code == 2;
     } else if (isInteger<T>()) {
       return isSigned<T>()
         ? deserializeInteger<T>(srcStart, srcEnd)
@@ -2409,7 +2674,12 @@ export namespace JSON {
           "Cannot parse data as string because it was formatted incorrectly!",
         );
 
-      return deserializeString(srcStart, srcEnd) as T;
+      const value = deserializeString(srcStart, srcEnd);
+      if (changetype<usize>(value) == 0) {
+        takeProductionParseError();
+        throw new Error("Invalid JSON string: missing surrounding quotes");
+      }
+      return value as T;
     } else {
       let type: nonnull<T> = changetype<nonnull<T>>(0);
       // @ts-expect-error: Defined by transform
@@ -2422,9 +2692,15 @@ export namespace JSON {
         isDefined(type.__DESERIALIZE_SLOW) ||
         isDefined(type.__DESERIALIZE_FAST)
       ) {
+        const fresh = dst == 0;
         const out = changetype<nonnull<T>>(
           dst || __new(offsetof<nonnull<T>>(), idof<nonnull<T>>()),
         );
+        // Generated fast paths may preserve omitted fields and reuse existing
+        // strings/containers. Initialize only a freshly allocated object here;
+        // callers that pass `dst` intentionally retain that reusable graph.
+        // @ts-expect-error: Defined by transform
+        if (fresh && isDefined(type.__INITIALIZE)) out.__INITIALIZE();
         // @ts-expect-error: Defined by transform
         if (isDefined(type.__DESERIALIZE_FAST)) {
           // @ts-expect-error: Defined by transform
@@ -2441,7 +2717,13 @@ export namespace JSON {
         // @ts-expect-error: Defined by transform
         if (isDefined(type.__DESERIALIZE_SLOW)) {
           // @ts-expect-error: Defined by transform
-          out.__DESERIALIZE_SLOW(srcStart, srcEnd, out);
+          const slowEnd = out.__DESERIALIZE_SLOW(srcStart, srcEnd, out);
+          if (slowEnd == 0) {
+            takeProductionParseError();
+            throw new Error("Malformed JSON object");
+          }
+          if (takeProductionParseError())
+            throw new Error("Malformed nested JSON value");
           return out;
         }
         throw new Error(`No deserialize method defined for type ${type}`);
@@ -2451,7 +2733,12 @@ export namespace JSON {
         return deserializeStaticArray<nonnull<T>>(srcStart, srcEnd, dst) as T;
       } else if (type instanceof Array) {
         // @ts-expect-error: type
-        return deserializeArray<nonnull<T>>(srcStart, srcEnd, dst) as T;
+        const value = deserializeArray<nonnull<T>>(srcStart, srcEnd, dst) as T;
+        if (changetype<usize>(value) == 0) {
+          takeProductionParseError();
+          throw new Error("Unterminated array in JSON");
+        }
+        return value;
       } else if (
         type instanceof Int8Array ||
         type instanceof Uint8Array ||
@@ -2473,7 +2760,12 @@ export namespace JSON {
         return deserializeSet<T>(srcStart, srcEnd, dst);
       } else if (type instanceof Map) {
         // @ts-expect-error: type
-        return deserializeMap<T>(srcStart, srcEnd, dst);
+        const value = deserializeMap<T>(srcStart, srcEnd, dst);
+        if (changetype<usize>(value) == 0) {
+          takeProductionParseError();
+          throw new Error("Malformed JSON map");
+        }
+        return value;
       } else if (type instanceof Date) {
         // @ts-expect-error: type
         return deserializeDate(srcStart, srcEnd);
@@ -2482,13 +2774,28 @@ export namespace JSON {
         return deserializeRaw(srcStart, srcEnd);
       } else if (type instanceof JSON.Value) {
         // @ts-expect-error: type
-        return deserializeArbitrary(srcStart, srcEnd, 0);
+        const value = deserializeArbitrary(srcStart, srcEnd, 0);
+        if (changetype<usize>(value) == 0) {
+          takeProductionParseError();
+          throw new Error("Incomplete JSON value");
+        }
+        return value;
       } else if (type instanceof JSON.Obj) {
         // @ts-expect-error: type
-        return deserializeObject(srcStart, srcEnd, 0);
+        const value = deserializeObject(srcStart, srcEnd, 0);
+        if (changetype<usize>(value) == 0) {
+          takeProductionParseError();
+          throw new Error("Unterminated object in JSON");
+        }
+        return value;
       } else if (type instanceof JSON.Arr) {
         // @ts-expect-error: type
-        return deserializeJsonArray(srcStart, srcEnd, 0);
+        const value = deserializeJsonArray(srcStart, srcEnd, 0);
+        if (changetype<usize>(value) == 0) {
+          takeProductionParseError();
+          throw new Error("Unterminated array in JSON");
+        }
+        return value;
       } else if (type instanceof JSON.Box) {
         // @ts-expect-error: type
         return new JSON.Box(
@@ -2509,14 +2816,85 @@ export namespace JSON {
     );
   }
   export namespace Util {
+    /** Record a cold malformed-input path and return the zero cursor sentinel. */
+    export function failProductionParse(): usize {
+      return failProductionParseInternal();
+    }
     export function isSpace(code: u16): boolean {
       return code == 0x20 || code - 9 <= 4;
     }
+
+
+    @inline
+    export function beginObjectTrace(
+      dst: usize,
+      srcStart: usize,
+      typeTag: string,
+    ): i32 {
+      return beginObjectFieldTrace(dst, srcStart, typeTag);
+    }
+
+
+    @inline
+    export function getObjectTraceMask(slot: i32): u64 {
+      return objectFieldTraceMask(slot);
+    }
+
+
+    @inline
+    export function getObjectTraceTier(slot: i32): u8 {
+      return objectFieldTraceTier(slot);
+    }
+
+
+    @inline
+    export function getObjectTraceSeparator(slot: i32): usize {
+      return objectFieldTraceSeparator(slot);
+    }
+
+
+    @inline
+    export function saveObjectTrace(
+      slot: i32,
+      present: u64,
+      tier: u8,
+      separator: usize = 0,
+    ): void {
+      recordObjectFieldTrace(slot, present, tier, separator);
+    }
     /** Advance past JSON whitespace (space, tab, LF, VT, FF, CR). */
+    @inline
     export function skipWhitespace(srcStart: usize, srcEnd: usize): usize {
       while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
       return srcStart;
     }
+    /** Advance a whitespace run using the SIMD pretty-document scanner. */
+    @inline
+    export function skipPrettyWhitespace(
+      srcStart: usize,
+      srcEnd: usize,
+    ): usize {
+      if (srcStart >= srcEnd) return srcStart;
+      const code = load<u16>(srcStart);
+      if (!isSpace(code)) return srcStart;
+      if (code == 0x20) {
+        srcStart += 2;
+        if (srcStart >= srcEnd || !isSpace(load<u16>(srcStart)))
+          return srcStart;
+      }
+      return skipPrettyWhitespace_SIMD(srcStart, srcEnd);
+    }
+    /** Compare a bounded UTF-16 source slice with a compile-time literal. */
+    @inline
+    export function matchesLiteral(
+      srcStart: usize,
+      srcEnd: usize,
+      expected: string,
+    ): bool {
+      const length = <usize>expected.length;
+      if (srcEnd - srcStart != length << 1) return false;
+      return utf16Equals(srcStart, changetype<usize>(expected), <i32>length);
+    }
     function scanQuotedValueEnd(srcStart: usize, srcEnd: usize): usize {
       const endQuote = scanStringEnd(srcStart, srcEnd);
       return endQuote >= srcEnd ? 0 : endQuote + 2;