json-as 1.5.0 → 1.6.1

package/assembly/deserialize/parseMode.ts

@@ -0,0 +1,216 @@
+let SIMD_PRETTY_PARSE = false;
+const ENABLE_EXACT_SOURCE_TRACES = true;
+
+// Steady-state SIMD string-field trace. JSON source strings and parsed field
+// strings are immutable at the language level, so the tuple
+// (source position, destination slot, current string reference) proves that a
+// field still contains the bytes produced by the prior parse. Any mutation or
+// graph replacement changes at least one tuple component and takes the normal
+// decoder, which refreshes that trace slot.
+let STRING_TRACE_DEPTH = 0;
+let STRING_TRACE_ACTIVE = false;
+let STRING_TRACE_COMPLETE = false;
+let STRING_TRACE_SOURCE: string | null = null;
+let STRING_TRACE_OUT: usize = 0;
+let STRING_TRACE_TYPE: u32 = 0;
+let STRING_TRACE_INDEX = 0;
+let STRING_TRACE_COUNT = 0;
+let STRING_TRACE_SLOT = 0;
+const STRING_TRACE_FIELDS = new Array<usize>();
+const STRING_TRACE_STARTS = new Array<usize>();
+const STRING_TRACE_ENDS = new Array<usize>();
+const STRING_TRACE_VALUES = new Array<string>();
+let OBJECT_TRACE_INDEX = 0;
+let OBJECT_TRACE_COUNT = 0;
+const OBJECT_TRACE_FIELDS = new Array<usize>();
+const OBJECT_TRACE_STARTS = new Array<usize>();
+const OBJECT_TRACE_TYPES = new Array<string>();
+const OBJECT_TRACE_MASKS = new Array<u64>();
+const OBJECT_TRACE_TIERS = new Array<u8>();
+const OBJECT_TRACE_SEPARATORS = new Array<usize>();
+
+
+@inline
+export function isPrettyParse(): bool {
+  return SIMD_PRETTY_PARSE;
+}
+
+
+@inline
+export function setPrettyParse(value: bool): void {
+  SIMD_PRETTY_PARSE = value;
+}
+
+/** Enter one public parse call, suspending trace use in nested parses. */
+@inline
+export function beginStringFieldTrace(
+  source: string,
+  out: usize,
+  typeId: u32,
+): void {
+  if (!ENABLE_EXACT_SOURCE_TRACES) return;
+  STRING_TRACE_DEPTH++;
+  if (!ASC_FEATURE_SIMD || STRING_TRACE_DEPTH != 1 || out == 0) return;
+
+  const sourcePtr = changetype<usize>(source);
+  const sameRoot =
+    STRING_TRACE_COMPLETE &&
+    STRING_TRACE_OUT == out &&
+    STRING_TRACE_TYPE == typeId &&
+    changetype<usize>(STRING_TRACE_SOURCE) == sourcePtr;
+  if (!sameRoot) {
+    STRING_TRACE_SOURCE = source;
+    STRING_TRACE_OUT = out;
+    STRING_TRACE_TYPE = typeId;
+    STRING_TRACE_COUNT = 0;
+    STRING_TRACE_FIELDS.length = 0;
+    STRING_TRACE_STARTS.length = 0;
+    STRING_TRACE_ENDS.length = 0;
+    STRING_TRACE_VALUES.length = 0;
+    OBJECT_TRACE_COUNT = 0;
+    OBJECT_TRACE_FIELDS.length = 0;
+    OBJECT_TRACE_STARTS.length = 0;
+    OBJECT_TRACE_TYPES.length = 0;
+    OBJECT_TRACE_MASKS.length = 0;
+    OBJECT_TRACE_TIERS.length = 0;
+    OBJECT_TRACE_SEPARATORS.length = 0;
+  }
+  STRING_TRACE_INDEX = 0;
+  OBJECT_TRACE_INDEX = 0;
+  STRING_TRACE_COMPLETE = false;
+  STRING_TRACE_ACTIVE = true;
+}
+
+/** Leave the matching public parse call. */
+@inline
+export function endStringFieldTrace(success: bool): void {
+  if (!ENABLE_EXACT_SOURCE_TRACES) return;
+  if (STRING_TRACE_DEPTH == 1) {
+    STRING_TRACE_ACTIVE = false;
+    STRING_TRACE_COMPLETE = success;
+  }
+  STRING_TRACE_DEPTH--;
+}
+
+/** Return the cached cursor, or zero when this field must be decoded. */
+@inline
+export function probeStringFieldTrace(
+  dstFieldPtr: usize,
+  payloadStart: usize,
+): usize {
+  if (!ENABLE_EXACT_SOURCE_TRACES) return 0;
+  if (!STRING_TRACE_ACTIVE || STRING_TRACE_DEPTH != 1) return 0;
+  const slot = STRING_TRACE_INDEX++;
+  STRING_TRACE_SLOT = slot;
+  if (
+    slot < STRING_TRACE_COUNT &&
+    unchecked(STRING_TRACE_FIELDS[slot]) == dstFieldPtr &&
+    unchecked(STRING_TRACE_STARTS[slot]) == payloadStart &&
+    load<usize>(dstFieldPtr) ==
+      changetype<usize>(unchecked(STRING_TRACE_VALUES[slot]))
+  )
+    return unchecked(STRING_TRACE_ENDS[slot]);
+  return 0;
+}
+
+/** Record the successful decode corresponding to the most recent probe. */
+@inline
+export function recordStringFieldTrace(
+  dstFieldPtr: usize,
+  payloadStart: usize,
+  next: usize,
+): void {
+  if (!ENABLE_EXACT_SOURCE_TRACES) return;
+  if (!STRING_TRACE_ACTIVE || STRING_TRACE_DEPTH != 1) return;
+  const slot = STRING_TRACE_SLOT;
+  const value = load<string>(dstFieldPtr);
+  if (slot < STRING_TRACE_COUNT) {
+    unchecked((STRING_TRACE_FIELDS[slot] = dstFieldPtr));
+    unchecked((STRING_TRACE_STARTS[slot] = payloadStart));
+    unchecked((STRING_TRACE_ENDS[slot] = next));
+    unchecked((STRING_TRACE_VALUES[slot] = value));
+  } else {
+    STRING_TRACE_FIELDS.push(dstFieldPtr);
+    STRING_TRACE_STARTS.push(payloadStart);
+    STRING_TRACE_ENDS.push(next);
+    STRING_TRACE_VALUES.push(value);
+    STRING_TRACE_COUNT = slot + 1;
+  }
+}
+
+/**
+ * Reserve or find one optional-struct trace slot.
+ *
+ * Returns i32.MIN_VALUE when tracing is inactive, a non-negative slot on a
+ * miss, or `~slot` (negative) on a hit. Reserving at begin keeps nested object
+ * records well-ordered even though a parent only commits after its children.
+ */
+@inline
+export function beginObjectFieldTrace(
+  dst: usize,
+  srcStart: usize,
+  typeTag: string,
+): i32 {
+  if (!ENABLE_EXACT_SOURCE_TRACES) return i32.MIN_VALUE;
+  if (!STRING_TRACE_ACTIVE || STRING_TRACE_DEPTH != 1) return i32.MIN_VALUE;
+  const slot = OBJECT_TRACE_INDEX++;
+  if (
+    slot < OBJECT_TRACE_COUNT &&
+    unchecked(OBJECT_TRACE_FIELDS[slot]) == dst &&
+    unchecked(OBJECT_TRACE_STARTS[slot]) == srcStart &&
+    unchecked(OBJECT_TRACE_TIERS[slot]) != 0 &&
+    changetype<usize>(unchecked(OBJECT_TRACE_TYPES[slot])) ==
+      changetype<usize>(typeTag)
+  )
+    return ~slot;
+
+  if (slot < OBJECT_TRACE_COUNT) {
+    unchecked((OBJECT_TRACE_FIELDS[slot] = dst));
+    unchecked((OBJECT_TRACE_STARTS[slot] = srcStart));
+    unchecked((OBJECT_TRACE_TYPES[slot] = typeTag));
+    unchecked((OBJECT_TRACE_MASKS[slot] = 0));
+    unchecked((OBJECT_TRACE_TIERS[slot] = 0));
+    unchecked((OBJECT_TRACE_SEPARATORS[slot] = 0));
+  } else {
+    OBJECT_TRACE_FIELDS.push(dst);
+    OBJECT_TRACE_STARTS.push(srcStart);
+    OBJECT_TRACE_TYPES.push(typeTag);
+    OBJECT_TRACE_MASKS.push(0);
+    OBJECT_TRACE_TIERS.push(0);
+    OBJECT_TRACE_SEPARATORS.push(0);
+    OBJECT_TRACE_COUNT = slot + 1;
+  }
+  return slot;
+}
+
+
+@inline
+export function objectFieldTraceMask(slot: i32): u64 {
+  return unchecked(OBJECT_TRACE_MASKS[slot]);
+}
+
+
+@inline
+export function objectFieldTraceTier(slot: i32): u8 {
+  return unchecked(OBJECT_TRACE_TIERS[slot]);
+}
+
+
+@inline
+export function objectFieldTraceSeparator(slot: i32): usize {
+  return unchecked(OBJECT_TRACE_SEPARATORS[slot]);
+}
+
+
+@inline
+export function recordObjectFieldTrace(
+  slot: i32,
+  present: u64,
+  tier: u8,
+  separator: usize = 0,
+): void {
+  if (slot < 0 || slot >= OBJECT_TRACE_COUNT) return;
+  unchecked((OBJECT_TRACE_MASKS[slot] = present));
+  unchecked((OBJECT_TRACE_TIERS[slot] = tier));
+  unchecked((OBJECT_TRACE_SEPARATORS[slot] = separator));
+}

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

@@ -397,7 +397,10 @@ export function deserializeIntegerArray_SIMD<T extends number[]>(
     dst || changetype<usize>(instantiate<T>()),
   );
   const originalSrcStart = srcStart;
-  const reusableLength = out.length;
+  const reusableLength = load<i32>(
+    changetype<usize>(out),
+    offsetof<T>("length_"),
+  );
 
   if (reusableLength != 0) {
     const dataStart = out.dataStart;
@@ -455,7 +458,7 @@ export function deserializeIntegerArray_SIMD<T extends number[]>(
             continue;
           }
           if (code == BRACKET_RIGHT) {
-            out.length = index;
+            if (index != reusableLength) out.length = index;
             return out;
           }
           break;
@@ -494,7 +497,7 @@ export function deserializeIntegerArray_SIMD<T extends number[]>(
             continue;
           }
           if (code == BRACKET_RIGHT) {
-            out.length = index;
+            if (index != reusableLength) out.length = index;
             return out;
           }
           break;

package/assembly/deserialize/simd/float.ts

@@ -1,7 +1,7 @@
-// SIMD float deserializers. Same Lemire-style fast path / `scientific()` /
-// `f*.parse` cascade as `swar/float.ts`, but the fractional digit loop uses
-// `parse8Digits_SIMD` (16 bytes / 8 digits) before falling through to
-// `parse4Digits_PairMul` (8 bytes / 4 digits) and finally the scalar tail.
+// SIMD float deserializers. Same Eisel-Lemire / `scientific()` / `f*.parse`
+// cascade as `swar/float.ts`, but the fractional digit loop starts with a
+// `parse16Digits_SIMD` stride before falling through to `parse4Digits_PairMul`
+// and finally the scalar tail.
 //
 // Output is bit-identical to `f64.parse` / `f32.parse` for every input - the
 // SIMD strides only change how the u64 mantissa is accumulated, not what it
@@ -14,6 +14,7 @@ import { ptrToStr } from "../../util/ptrToStr";
 import { parse4Digits_PairMul } from "../../util/swar-int";
 import { parse16Digits_SIMD } from "../../util/simd-int";
 import { scientific } from "../../util/scientific";
+import { eiselLemire22 } from "../../util/eisel-lemire";
 import { loadPow10, MAX_EXACT_MANTISSA, MAX_EXACT_POW10 } from "../swar/float";
 
 const ASCII_PLUS: u16 = 43;
@@ -56,48 +57,47 @@ export function deserializeFloat_SIMD<T>(srcStart: usize, srcEnd: usize): T {
   }
 
   let mantissa: u64 = 0;
-  let intDigits: i32 = 0;
+  const intStart = p;
   while (p < srcEnd) {
     const d = <u32>load<u16>(p) - ASCII_ZERO;
     if (d > 9) break;
     mantissa = mantissa * 10 + <u64>d;
-    intDigits++;
     p += 2;
   }
+  const intDigits = <i32>((p - intStart) >> 1);
 
-  // Fractional part: parse8 SIMD stride → parse4 SWAR stride → scalar tail.
-  // `intDigits + fracDigits <= 11` gate keeps `mantissa * 10^8 + parsed8`
-  // under u64 max even when the integer part is large.
-  let fracDigits: i32 = 0;
+  // Fractional part: one parse16 SIMD stride → parse4 SWAR stride →
+  // scalar tail. The parse16 gate keeps the combined mantissa within u64.
+  let fracStart = p;
   if (p < srcEnd && load<u16>(p) == ASCII_DOT) {
     p += 2;
+    fracStart = p;
     // parse16 SIMD only fires on long fractions (>=16 digits ahead, with
     // <=3 integer digits to keep mantissa * 1e16 under u64 max). Rare in
     // typical JSON but a big win when it does fire (8 digits per stride in
     // SWAR's parse8 was benched even/worse than parse4, so we skip parse8
     // entirely and let parse4 handle the 4-15 char tail).
-    while (p + 30 < srcEnd && intDigits + fracDigits <= 3) {
+    if (p + 30 < srcEnd && intDigits <= 3) {
       const parsed = parse16Digits_SIMD(p);
-      if (parsed == U64.MAX_VALUE) break;
-      mantissa = mantissa * 10_000_000_000_000_000 + parsed;
-      fracDigits += 16;
-      p += 32;
+      if (parsed != U64.MAX_VALUE) {
+        mantissa = mantissa * 10_000_000_000_000_000 + parsed;
+        p += 32;
+      }
     }
     while (p + 6 < srcEnd) {
       const parsed = parse4Digits_PairMul(load<u64>(p));
       if (parsed == U32.MAX_VALUE) break;
       mantissa = mantissa * 10_000 + <u64>parsed;
-      fracDigits += 4;
       p += 8;
     }
     while (p < srcEnd) {
       const d = <u32>load<u16>(p) - ASCII_ZERO;
       if (d > 9) break;
       mantissa = mantissa * 10 + <u64>d;
-      fracDigits++;
       p += 2;
     }
   }
+  const fracDigits = <i32>((p - fracStart) >> 1);
 
   const mantDigits = intDigits + fracDigits;
   if (mantDigits == 0) return fallback<T>(origStart, srcEnd);
@@ -148,7 +148,10 @@ export function deserializeFloat_SIMD<T>(srcStart: usize, srcEnd: usize): T {
       result /= loadPow10(<u32>-exponent);
     }
   } else if (mantDigits <= 19) {
-    result = scientific(mantissa, exponent);
+    result =
+      exponent >= -22 && exponent <= 22
+        ? eiselLemire22(mantissa, exponent)
+        : scientific(mantissa, exponent);
   } else {
     return fallback<T>(origStart, srcEnd);
   }
@@ -178,45 +181,45 @@ export function deserializeFloatField_SIMD<T extends number>(
   }
 
   let mantissa: u64 = 0;
-  let intDigits: i32 = 0;
+  const intStart = p;
   while (p < srcEnd) {
     const d = <u32>load<u16>(p) - ASCII_ZERO;
     if (d > 9) break;
     mantissa = mantissa * 10 + <u64>d;
-    intDigits++;
     p += 2;
   }
+  const intDigits = <i32>((p - intStart) >> 1);
 
-  let fracDigits: i32 = 0;
+  let fracStart = p;
   if (p < srcEnd && load<u16>(p) == ASCII_DOT) {
     p += 2;
+    fracStart = p;
     // parse16 SIMD only fires on long fractions (>=16 digits ahead, with
     // <=3 integer digits to keep mantissa * 1e16 under u64 max). Rare in
     // typical JSON but a big win when it does fire (8 digits per stride in
     // SWAR's parse8 was benched even/worse than parse4, so we skip parse8
     // entirely and let parse4 handle the 4-15 char tail).
-    while (p + 30 < srcEnd && intDigits + fracDigits <= 3) {
+    if (p + 30 < srcEnd && intDigits <= 3) {
       const parsed = parse16Digits_SIMD(p);
-      if (parsed == U64.MAX_VALUE) break;
-      mantissa = mantissa * 10_000_000_000_000_000 + parsed;
-      fracDigits += 16;
-      p += 32;
+      if (parsed != U64.MAX_VALUE) {
+        mantissa = mantissa * 10_000_000_000_000_000 + parsed;
+        p += 32;
+      }
     }
     while (p + 6 < srcEnd) {
       const parsed = parse4Digits_PairMul(load<u64>(p));
       if (parsed == U32.MAX_VALUE) break;
       mantissa = mantissa * 10_000 + <u64>parsed;
-      fracDigits += 4;
       p += 8;
     }
     while (p < srcEnd) {
       const d = <u32>load<u16>(p) - ASCII_ZERO;
       if (d > 9) break;
       mantissa = mantissa * 10 + <u64>d;
-      fracDigits++;
       p += 2;
     }
   }
+  const fracDigits = <i32>((p - fracStart) >> 1);
 
   const mantDigits = intDigits + fracDigits;
   if (mantDigits == 0) unreachable();
@@ -279,7 +282,10 @@ export function deserializeFloatField_SIMD<T extends number>(
       result /= loadPow10(<u32>-exponent);
     }
   } else if (mantDigits <= 19) {
-    result = scientific(mantissa, exponent);
+    result =
+      exponent >= -22 && exponent <= 22
+        ? eiselLemire22(mantissa, exponent)
+        : scientific(mantissa, exponent);
   } else {
     fallbackField<T>(origStart, p, fieldPtr);
     return p;

package/assembly/deserialize/simd/string.ts

@@ -5,6 +5,9 @@ import { QUOTE } from "../../custom/chars";
 import { BACK_SLASH } from "../../custom/chars";
 import { DESERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
 import { hex4_to_u16_swar } from "../../util/swar";
+import { markProductionParseError } from "../error";
+import { isValidStringEscape } from "../string-validation";
+import { probeStringFieldTrace, recordStringFieldTrace } from "../parseMode";
 
 // @ts-expect-error: @lazy is a valid decorator
 @lazy const SPLAT_5C = i16x8.splat(0x5c); // \
@@ -116,7 +119,7 @@ function deserializeEscapedString_SIMD(
   }
 
   let srcStart = escapeStart;
-  const srcEnd16 = srcEnd >= 16 ? srcEnd - 16 : 0;
+  const srcEnd16 = srcEnd - 16;
 
   while (srcStart <= srcEnd16) {
     const block = load<v128>(srcStart);
@@ -150,6 +153,11 @@ function deserializeEscapedString_SIMD(
     const laneIdx = usize(ctz(mask) << 1);
     bs.offset += laneIdx;
     const srcIdx = srcStart + laneIdx;
+    if (!isValidStringEscape(srcIdx, srcEnd)) {
+      bs.offset = bs.buffer + outStart;
+      markProductionParseError();
+      return changetype<string>(0);
+    }
     const code = load<u16>(srcIdx, 2);
     if (code !== 0x75) {
       store<u16>(bs.offset, load<u16>(DESERIALIZE_ESCAPE_TABLE + code));
@@ -171,6 +179,11 @@ function deserializeEscapedString_SIMD(
       srcStart += 2;
       continue;
     }
+    if (!isValidStringEscape(srcStart, srcEnd)) {
+      bs.offset = bs.buffer + outStart;
+      markProductionParseError();
+      return changetype<string>(0);
+    }
     const code = load<u16>(srcStart, 2);
     if (code !== 0x75) {
       store<u16>(bs.offset, load<u16>(DESERIALIZE_ESCAPE_TABLE + code));
@@ -262,16 +275,23 @@ function deserializeEscapedStringField_SIMD(
 ): usize {
   const prefixLen = <u32>(escapeStart - payloadStart);
   bs.offset = bs.buffer;
-  bs.ensureSize(<u32>(srcEnd - payloadStart) + 16); // +16 slack for overcopy
+  // The containing parser may pass document-end bounds. Reserve according to
+  // decoded output rather than retaining the entire remaining document.
+  bs.ensureSize(prefixLen + 1024);
   if (prefixLen != 0) {
     memory.copy(bs.buffer, payloadStart, prefixLen);
     bs.offset += prefixLen;
   }
 
   let srcStart = escapeStart;
-  const srcEnd16 = srcEnd >= 16 ? srcEnd - 16 : 0;
+  const srcEnd16 = srcEnd - 16;
+  let scratchEnd = bs.buffer + bs.bufferSize - 16;
 
   while (srcStart <= srcEnd16) {
+    if (bs.offset > scratchEnd) {
+      bs.ensureSize(1024);
+      scratchEnd = bs.buffer + bs.bufferSize - 16;
+    }
     const block = load<v128>(srcStart);
     const mask = i16x8.bitmask(
       v128.or(i16x8.eq(block, SPLAT_5C), i16x8.eq(block, SPLAT_22)),
@@ -302,6 +322,10 @@ function deserializeEscapedStringField_SIMD(
             srcStart += 16;
           }
           const runLen = <u32>(srcStart - runStart);
+          if (bs.offset + runLen > scratchEnd) {
+            bs.ensureSize(runLen + 1024);
+            scratchEnd = bs.buffer + bs.bufferSize - 16;
+          }
           memory.copy(bs.offset, runStart, runLen);
           bs.offset += runLen;
         }
@@ -325,6 +349,11 @@ function deserializeEscapedStringField_SIMD(
       return srcIdx + 2;
     }
 
+    if (!isValidStringEscape(srcIdx, srcEnd)) {
+      bs.offset = bs.buffer;
+      markProductionParseError();
+      return 0;
+    }
     const code = load<u16>(srcIdx, 2);
     if (code !== 0x75) {
       store<u16>(bs.offset, load<u16>(DESERIALIZE_ESCAPE_TABLE + code));
@@ -338,6 +367,7 @@ function deserializeEscapedStringField_SIMD(
   }
 
   // scalar tail (< 16 bytes remaining): emit chars directly.
+  bs.ensureSize(<u32>(srcEnd - srcStart) + 2);
   while (srcStart < srcEnd) {
     const char = load<u16>(srcStart);
     if (char == QUOTE) {
@@ -356,6 +386,11 @@ function deserializeEscapedStringField_SIMD(
       continue;
     }
 
+    if (!isValidStringEscape(srcStart, srcEnd)) {
+      bs.offset = bs.buffer;
+      markProductionParseError();
+      return 0;
+    }
     const code = load<u16>(srcStart, 2);
     if (code !== 0x75) {
       store<u16>(bs.offset, load<u16>(DESERIALIZE_ESCAPE_TABLE + code));
@@ -369,8 +404,8 @@ function deserializeEscapedStringField_SIMD(
   }
 
   bs.offset = bs.buffer;
-  abort("Unterminated string literal");
-  return srcStart;
+  markProductionParseError();
+  return 0;
 }
 
 export function deserializeStringField_SIMD<T extends string | null>(
@@ -379,13 +414,32 @@ export function deserializeStringField_SIMD<T extends string | null>(
   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_SIMD(
+    srcStart + 2,
+    srcEnd,
+    dstObj,
+    dstOffset,
+  );
+}
 
-  const payloadStart = srcStart + 2;
-  const srcEnd16 = srcEnd >= 16 ? srcEnd - 16 : 0;
-  srcStart = payloadStart;
+// Generated compact-object paths have already matched the key and validated
+// the opening quote. Enter at the payload so that proof replaces (rather than
+// duplicates) the public field decoder's framing load.
+export function deserializeStringFieldTrusted_SIMD(
+  payloadStart: usize,
+  srcEnd: usize,
+  dstObj: usize,
+  dstOffset: usize = 0,
+): usize {
+  const dstFieldPtr = dstObj + dstOffset;
+  const cachedEnd = probeStringFieldTrace(dstFieldPtr, payloadStart);
+  if (cachedEnd != 0) return cachedEnd;
+  const srcEnd16 = srcEnd - 16;
+  let srcStart = payloadStart;
 
   while (srcStart <= srcEnd16) {
     const block = load<v128>(srcStart);
@@ -406,15 +460,19 @@ export function deserializeStringField_SIMD<T extends string | null>(
         payloadStart,
         <u32>(srcIdx - payloadStart),
       );
-      return srcIdx + 2;
+      const next = srcIdx + 2;
+      recordStringFieldTrace(dstFieldPtr, payloadStart, next);
+      return next;
     }
     // backslash → vectorized escaped scan (no more SWAR fallback)
-    return deserializeEscapedStringField_SIMD(
+    const next = deserializeEscapedStringField_SIMD(
       payloadStart,
       srcIdx,
       srcEnd,
       dstFieldPtr,
     );
+    if (next != 0) recordStringFieldTrace(dstFieldPtr, payloadStart, next);
+    return next;
   }
 
   while (srcStart < srcEnd) {
@@ -425,19 +483,23 @@ export function deserializeStringField_SIMD<T extends string | null>(
         payloadStart,
         <u32>(srcStart - payloadStart),
       );
-      return srcStart + 2;
+      const next = srcStart + 2;
+      recordStringFieldTrace(dstFieldPtr, payloadStart, next);
+      return next;
     }
     if (char == BACK_SLASH) {
-      return deserializeEscapedStringField_SIMD(
+      const next = deserializeEscapedStringField_SIMD(
         payloadStart,
         srcStart,
         srcEnd,
         dstFieldPtr,
       );
+      if (next != 0) recordStringFieldTrace(dstFieldPtr, payloadStart, next);
+      return next;
     }
     srcStart += 2;
   }
 
-  abort("Unterminated string literal");
-  return srcStart;
+  markProductionParseError();
+  return 0;
 }

package/assembly/deserialize/string-validation.ts

@@ -0,0 +1,34 @@
+
+@inline
+function isHexDigit(c: u16): bool {
+  return (
+    (c >= 0x30 && c <= 0x39) ||
+    (c >= 0x41 && c <= 0x46) ||
+    (c >= 0x61 && c <= 0x66)
+  );
+}
+
+/** Validate one escape beginning at its backslash without scanning plain text. */
+export function isValidStringEscape(srcStart: usize, srcEnd: usize): bool {
+  if (srcStart + 4 > srcEnd) return false;
+  const code = load<u16>(srcStart, 2);
+  if (code == 0x75) {
+    return (
+      srcStart + 12 <= srcEnd &&
+      isHexDigit(load<u16>(srcStart, 4)) &&
+      isHexDigit(load<u16>(srcStart, 6)) &&
+      isHexDigit(load<u16>(srcStart, 8)) &&
+      isHexDigit(load<u16>(srcStart, 10))
+    );
+  }
+  return (
+    code == 0x22 ||
+    code == 0x5c ||
+    code == 0x2f ||
+    code == 0x62 ||
+    code == 0x66 ||
+    code == 0x6e ||
+    code == 0x72 ||
+    code == 0x74
+  );
+}