json-as 1.4.0 → 1.6.0

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); // \
@@ -63,13 +66,8 @@ import { hex4_to_u16_swar } from "../../util/swar";
  * @param dst buffer to write to
  * @returns number of bytes written
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline function copyStringFromSource_SIMD(
-  srcStart: usize,
-  byteLength: usize,
-): string {
+function copyStringFromSource_SIMD(srcStart: usize, byteLength: usize): string {
   if (byteLength == 0) return changetype<string>("");
-  // @ts-expect-error: __new is a runtime builtin
   const out = __new(byteLength, idof<string>());
   memory.copy(out, srcStart, byteLength);
   return changetype<string>(out);
@@ -106,11 +104,7 @@ function writeStringToField_SIMD(
 // handling (no closing-quote search). Same HYBRID strategy as the field path
 // (see deserializeEscapedStringField_SIMD): escape blocks use a free
 // whole-block v128 store for the plain prefix; clean runs stream the first
-// block then bulk-memcpy the remainder. Output is sliced out of `bs` scratch.
-//
-// Deliberately NOT @inline: cold escape path. Inlining the nested-loop v128
-// body at every call site explodes `--converge` compile time on large schemas
-// for no runtime gain (one call per escaped string).
+
 function deserializeEscapedString_SIMD(
   payloadStart: usize,
   escapeStart: usize,
@@ -125,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);
@@ -159,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));
@@ -180,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));
@@ -254,18 +258,14 @@ export function deserializeString_SIMD(srcStart: usize, srcEnd: usize): string {
 // reused `bs` scratch buffer, then written once via writeStringToField_SIMD.
 //
 // Strategy (validated against run-copy and pure-stream variants across escape
-// densities — see __benches__/custom/simd-string-deser-variants-h2h):
+// densities - see __benches__/custom/simd-string-deser-variants-h2h):
 //   * Escape-bearing block: a single whole-block v128 store copies the plain
 //     prefix for free; then the escape is decoded scalar.
 //   * Clean block: stream the first one cheaply, but if the clean run keeps
-//     going, switch to one bulk memory.copy for the remainder — bandwidth-
+//     going, switch to one bulk memory.copy for the remainder - bandwidth-
 //     optimal on long sparse runs, avoiding a per-block-store cliff on large
 //     inputs. This dominates both alternatives: stream-cheap on dense escapes,
-//     memcpy-fast on long runs.
-//
-// Deliberately NOT @inline: cold escape path. As an @inline it was inlined into
-// deserializeStringField_SIMD at every struct string-field site, exploding
-// `--converge` compile time ~24x on large schemas (4s → 99s) for no runtime
+
 // gain. The hot no-escape scan + writeStringToField stay inline in the caller.
 function deserializeEscapedStringField_SIMD(
   payloadStart: usize,
@@ -275,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)),
@@ -315,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;
         }
@@ -338,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));
@@ -351,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) {
@@ -369,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));
@@ -382,27 +404,42 @@ function deserializeEscapedStringField_SIMD(
   }
 
   bs.offset = bs.buffer;
-  abort("Unterminated string literal");
-  return srcStart;
+  markProductionParseError();
+  return 0;
 }
 
-// NOT @inline: as an @inline entry, binaryen inlined the (loop-bearing) escaped
-// scanner into every per-field copy, exploding `large` SIMD compile ~24x
-// (4s→99s, 221KB→555KB wasm). Kept as a single shared function — matches
-// deserializeStringField_SWAR (also non-inline) and costs only one call/field.
 export function deserializeStringField_SIMD<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_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);
@@ -423,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) {
@@ -442,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
+  );
+}

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

@@ -2,8 +2,7 @@ import { JSON } from "../../..";
 import { deserializeGenericArrayBody } from "./generic";
 import { ensureArrayField } from "./shared";
 
-
-@inline export function deserializeArbitraryArrayField(
+export function deserializeArbitraryArrayField(
   srcStart: usize,
   srcEnd: usize,
   fieldPtr: usize,

package/assembly/deserialize/swar/array/array.ts

@@ -2,6 +2,27 @@ import { JSON } from "../../..";
 import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
 import { deserializeFloatArrayBody } from "./float";
 import { ensureArrayField, scanValueEnd, skipWhitespace } from "./shared";
+import { skipPrettyWhitespace_SIMD } from "../../../util/prettyWhitespaceSimd";
+
+
+@inline
+function skipNestedArrayWhitespace(srcStart: usize, srcEnd: usize): usize {
+  const code = load<u16>(srcStart);
+  if (ASC_FEATURE_SIMD && code == 10) {
+    // Common JSON.stringify(..., null, 2) shape at Canada's coordinate depth:
+    // LF + twelve spaces + the next nested array. Two fixed compares avoid a
+    // general whitespace mask, bitmask, and ctz on every coordinate pair.
+    if (
+      srcStart + 28 <= srcEnd &&
+      !v128.any_true(v128.xor(load<v128>(srcStart, 2), i16x8.splat(0x20))) &&
+      load<u64>(srcStart, 18) == 0x0020_0020_0020_0020 &&
+      load<u16>(srcStart, 26) == BRACKET_LEFT
+    )
+      return srcStart + 26;
+    return skipPrettyWhitespace_SIMD(srcStart, srcEnd);
+  }
+  return skipWhitespace(srcStart, srcEnd);
+}
 
 export function deserializeArrayArrayBody<T extends unknown[][]>(
   srcStart: usize,
@@ -9,11 +30,21 @@ export function deserializeArrayArrayBody<T extends unknown[][]>(
   out: T,
 ): usize {
   let index = 0;
+  const reusableLength = load<i32>(
+    changetype<usize>(out),
+    offsetof<T>("length_"),
+  );
+  const reusableDataStart = out.dataStart;
+  const elementSize = sizeof<valueof<T>>();
 
   do {
     if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) break;
     srcStart += 2;
-    srcStart = skipWhitespace(srcStart, srcEnd);
+    if (srcStart < srcEnd) {
+      const code = load<u16>(srcStart);
+      if (code != BRACKET_LEFT)
+        srcStart = skipNestedArrayWhitespace(srcStart, srcEnd);
+    }
     if (srcStart >= srcEnd) break;
     if (load<u16>(srcStart) == BRACKET_RIGHT) {
       out.length = 0;
@@ -23,8 +54,10 @@ export function deserializeArrayArrayBody<T extends unknown[][]>(
     while (srcStart < srcEnd) {
       if (isFloat<valueof<valueof<T>>>()) {
         let value: valueof<T>;
-        if (index < out.length) {
-          value = unchecked(out[index]);
+        if (index < reusableLength) {
+          value = load<valueof<T>>(
+            reusableDataStart + <usize>index * elementSize,
+          );
         } else {
           value = changetype<valueof<T>>(instantiate<valueof<T>>());
           out.push(value);
@@ -37,8 +70,10 @@ export function deserializeArrayArrayBody<T extends unknown[][]>(
         if (!srcStart || srcStart >= srcEnd) break;
       } else if (isArray<valueof<valueof<T>>>()) {
         let value: valueof<T>;
-        if (index < out.length) {
-          value = unchecked(out[index]);
+        if (index < reusableLength) {
+          value = load<valueof<T>>(
+            reusableDataStart + <usize>index * elementSize,
+          );
         } else {
           value = changetype<valueof<T>>(instantiate<valueof<T>>());
           out.push(value);
@@ -54,24 +89,39 @@ export function deserializeArrayArrayBody<T extends unknown[][]>(
         if (!valueEnd || valueEnd <= srcStart) break;
 
         let valuePtr: usize = 0;
-        if (index < out.length) {
-          valuePtr = changetype<usize>(unchecked(out[index]));
+        if (index < reusableLength) {
+          valuePtr = changetype<usize>(
+            load<valueof<T>>(reusableDataStart + <usize>index * elementSize),
+          );
         }
         const value = JSON.__deserialize<valueof<T>>(
           srcStart,
           valueEnd,
           valuePtr,
         );
-        if (index < out.length) unchecked((out[index] = value));
-        else out.push(value);
+        if (index < reusableLength) {
+          store<valueof<T>>(
+            reusableDataStart + <usize>index * elementSize,
+            value,
+          );
+        } else {
+          out.push(value);
+        }
         srcStart = valueEnd;
       }
 
-      srcStart = skipWhitespace(srcStart, srcEnd);
-      const code = load<u16>(srcStart);
+      let code = load<u16>(srcStart);
+      if (code != COMMA && code != BRACKET_RIGHT) {
+        srcStart = skipWhitespace(srcStart, srcEnd);
+        code = load<u16>(srcStart);
+      }
       if (code == COMMA) {
         srcStart += 2;
-        srcStart = skipWhitespace(srcStart, srcEnd);
+        if (srcStart < srcEnd) {
+          code = load<u16>(srcStart);
+          if (code != BRACKET_LEFT)
+            srcStart = skipNestedArrayWhitespace(srcStart, srcEnd);
+        }
         index++;
         continue;
       }
@@ -80,7 +130,7 @@ export function deserializeArrayArrayBody<T extends unknown[][]>(
         // correct (the array is being reused with the same shape, e.g.
         // canada's geometry rings across repeated parses).
         const nextLen = index + 1;
-        if (out.length != nextLen) out.length = nextLen;
+        if (reusableLength != nextLen) out.length = nextLen;
         return srcStart + 2;
       }
       break;
@@ -90,8 +140,7 @@ export function deserializeArrayArrayBody<T extends unknown[][]>(
   throw new Error("Failed to parse JSON!");
 }
 
-
-@inline export function deserializeArrayArrayField<T extends unknown[][]>(
+export function deserializeArrayArrayField<T extends unknown[][]>(
   srcStart: usize,
   srcEnd: usize,
   fieldPtr: usize,

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

@@ -7,6 +7,7 @@ import {
 } from "../../../custom/chars";
 import { isSpace } from "../../../util";
 import { ensureArrayElementSlot, ensureArrayField } from "./shared";
+import { markProductionParseError } from "../../error";
 
 function deserializeBooleanArrayBody<T extends boolean[]>(
   srcStart: usize,
@@ -14,6 +15,12 @@ function deserializeBooleanArrayBody<T extends boolean[]>(
   out: T,
 ): usize {
   let index = 0;
+  const reusableLength = load<i32>(
+    changetype<usize>(out),
+    offsetof<T>("length_"),
+  );
+  const reusableDataStart = out.dataStart;
+  const elementSize = sizeof<valueof<T>>();
 
   do {
     if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) break;
@@ -26,7 +33,10 @@ function deserializeBooleanArrayBody<T extends boolean[]>(
     }
 
     while (srcStart < srcEnd) {
-      const slot = ensureArrayElementSlot<T>(out, index);
+      const slot =
+        index < reusableLength
+          ? reusableDataStart + <usize>index * elementSize
+          : ensureArrayElementSlot<T>(out, index);
       const block = load<u64>(srcStart);
       if (block == TRUE_WORD_U64) {
         store<valueof<T>>(slot, true);
@@ -49,18 +59,18 @@ function deserializeBooleanArrayBody<T extends boolean[]>(
       }
       if (code == BRACKET_RIGHT) {
         const nextLen = index + 1;
-        if (out.length != nextLen) out.length = nextLen;
+        if (reusableLength != nextLen) out.length = nextLen;
         return srcStart + 2;
       }
       break;
     }
   } while (false);
 
-  throw new Error("Failed to parse JSON!");
+  markProductionParseError();
+  return 0;
 }
 
-
-@inline export function deserializeBooleanArrayField<T extends boolean[]>(
+export function deserializeBooleanArrayField<T extends boolean[]>(
   srcStart: usize,
   srcEnd: usize,
   fieldPtr: usize,

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

@@ -2,8 +2,7 @@ import { JSON } from "../../..";
 import { deserializeGenericArrayBody } from "./generic";
 import { ensureArrayField } from "./shared";
 
-
-@inline export function deserializeBoxArrayField<T extends JSON.Box<any>[]>(
+export function deserializeBoxArrayField<T extends JSON.Box<any>[]>(
   srcStart: usize,
   srcEnd: usize,
   fieldPtr: usize,