json-as 1.4.0 → 1.6.0

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

@@ -40,11 +40,7 @@ const ASCII_ZERO_4: u64 = 0x0030003000300030;
 // @ts-expect-error: decorators valid here
 @lazy const PAIR_WEIGHTS_100_1 = i16x8(100, 1, 100, 1, 0, 0, 0, 0);
 
-// @ts-expect-error: decorators valid here
-@inline function storeSignedInteger<T extends number[]>(
-  slot: usize,
-  value: i64,
-): void {
+function storeSignedInteger<T extends number[]>(slot: usize, value: i64): void {
   if (sizeof<valueof<T>>() == sizeof<i8>()) {
     store<i8>(slot, <i8>value);
   } else if (sizeof<valueof<T>>() == sizeof<i16>()) {
@@ -58,8 +54,7 @@ const ASCII_ZERO_4: u64 = 0x0030003000300030;
   }
 }
 
-// @ts-expect-error: decorators valid here
-@inline function storeUnsignedInteger<T extends number[]>(
+function storeUnsignedInteger<T extends number[]>(
   slot: usize,
   value: u64,
 ): void {
@@ -402,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;
@@ -460,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;
@@ -499,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,9 +1,9 @@
-// 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
+// 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
 // becomes.
 //
@@ -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;
@@ -23,8 +24,7 @@ const ASCII_ZERO: u16 = 48;
 const ASCII_E_UP: u16 = 69;
 const ASCII_E_LO: u16 = 101;
 
-// @ts-ignore: inline
-@inline function fallback<T>(srcStart: usize, srcEnd: usize): T {
+function fallback<T>(srcStart: usize, srcEnd: usize): T {
   const s = ptrToStr(srcStart, srcEnd);
   // @ts-ignore
   const type: T = 0;
@@ -34,8 +34,7 @@ const ASCII_E_LO: u16 = 101;
   return <T>(<f32>f32.parse(s));
 }
 
-// @ts-ignore: inline
-@inline function fallbackField<T extends number>(
+function fallbackField<T extends number>(
   origStart: usize,
   end: usize,
   fieldPtr: usize,
@@ -58,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);
@@ -150,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);
   }
@@ -180,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();
@@ -281,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/integer.ts

@@ -38,11 +38,7 @@ const ASCII_ZERO: u16 = 48;
  * @param value  The `u64` accumulator, interpreted as a two's-complement
  *               signed integer for narrower types.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline function storeSignedToField<T extends number>(
-  dstPtr: usize,
-  value: u64,
-): void {
+function storeSignedToField<T extends number>(dstPtr: usize, value: u64): void {
   if (sizeof<T>() == 1) {
     store<i8>(dstPtr, <i8>value);
   } else if (sizeof<T>() == 2) {
@@ -61,8 +57,7 @@ const ASCII_ZERO: u16 = 48;
  * @param dstPtr Destination pointer (already includes any field offset).
  * @param value  The `u64` accumulator.
  */
-// @ts-expect-error: decorator valid here
-@inline function storeUnsignedToField<T extends number>(
+function storeUnsignedToField<T extends number>(
   dstPtr: usize,
   value: u64,
 ): void {