json-as 1.4.0 → 1.6.0

package/assembly/serialize/naive/string.ts

@@ -15,8 +15,7 @@ import { serializeStruct } from "./struct";
  * @param src string
  * @returns void
  */
-// @ts-ignore: inline
-@inline export function serializeString_NAIVE(src: string): void {
+export function serializeString_NAIVE(src: string): void {
   serializeStringRange(changetype<usize>(src), bytes(src));
 }
 
@@ -86,11 +85,3 @@ export function serializeStringRange(srcPtr: usize, srcSize: usize): void {
   store<u16>(bs.offset, QUOTE);
   bs.offset += 2;
 }
-
-// @ts-ignore: inline
-@inline function write_u_escape(code: u16): void {
-  bs.growSize(10);
-  store<u32>(bs.offset, U_MARKER); // "\u"
-  store<u64>(bs.offset, u16_to_hex4_swar(code), 4);
-  bs.offset += 12;
-}

package/assembly/serialize/naive/typedarray.ts

@@ -3,8 +3,6 @@ import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../custom/chars";
 import { serializeFloat32Unsafe, serializeFloat64Unsafe } from "./float";
 import { serializeIntegerUnsafe } from "./integer";
 
-
-@inline
 function maxIntegerBytes<T extends number>(): u32 {
   if (sizeof<T>() == 1) return isSigned<T>() ? 8 : 6;
   if (sizeof<T>() == 2) return isSigned<T>() ? 12 : 10;
@@ -12,10 +10,7 @@ function maxIntegerBytes<T extends number>(): u32 {
   return isSigned<T>() ? 42 : 40;
 }
 
-
-@inline
 function reserveTypedArray<T extends ArrayLike<number>>(len: i32): void {
-  if (len <= 0) return;
   if (isFloat<valueof<T>>()) {
     bs.proposeSize(4 + <u32>len * (sizeof<valueof<T>>() == 4 ? 34 : 66));
   } else {
@@ -23,8 +18,6 @@ function reserveTypedArray<T extends ArrayLike<number>>(len: i32): void {
   }
 }
 
-
-@inline
 function serializeTypedArrayElement<T extends ArrayLike<number>>(
   src: T,
   index: i32,

package/assembly/serialize/simd/string.ts

@@ -207,9 +207,7 @@ export function serializeString_SIMD(src: string): void {
   store<u16>(bs.offset, 34); // "
   bs.offset += 2;
 }
-
-// @ts-expect-error: @inline is a valid decorator
-@inline function write_u_escape(code: u16): void {
+function write_u_escape(code: u16): void {
   bs.growSize(10);
   store<u32>(bs.offset, U_MARKER); // "\u"
   store<u64>(bs.offset, u16_to_hex4_swar(code), 4);

package/assembly/serialize/swar/string.ts

@@ -174,8 +174,7 @@ export function serializeString_SWAR(src: string): void {
   bs.offset += 2;
 }
 
-// @ts-expect-error: @inline is a valid decorator
-@inline function write_u_escape(code: u16): void {
+function write_u_escape(code: u16): void {
   bs.growSize(10);
   store<u32>(bs.offset, U_MARKER); // "\u"
   store<u64>(bs.offset, u16_to_hex4_swar(code), 4);

package/assembly/util/atoi-fast.ts

@@ -18,11 +18,7 @@ import {
  * @param srcEnd   Pointer just past the last code unit.
  * @returns The parsed value, truncated to `T`.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function atou<T extends number>(
-  srcStart: usize,
-  srcEnd: usize,
-): T {
+export function atou<T extends number>(srcStart: usize, srcEnd: usize): T {
   return deserializeUnsigned_SWAR<T>(srcStart, srcEnd);
 }
 
@@ -34,11 +30,7 @@ import {
  * @param srcEnd   Pointer just past the last code unit.
  * @returns The parsed value, truncated to `T`.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function atoi<T extends number>(
-  srcStart: usize,
-  srcEnd: usize,
-): T {
+export function atoi<T extends number>(srcStart: usize, srcEnd: usize): T {
   return deserializeInteger_SWAR<T>(srcStart, srcEnd);
 }
 
@@ -52,8 +44,7 @@ import {
  * @param dstPtr   Destination pointer for the parsed value.
  * @returns The source position immediately after the last digit consumed.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function atouScan<T extends number>(
+export function atouScan<T extends number>(
   srcStart: usize,
   srcEnd: usize,
   dstPtr: usize,
@@ -71,8 +62,7 @@ import {
  * @param dstPtr   Destination pointer for the parsed value.
  * @returns The source position immediately after the last digit consumed.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function atoiScan<T extends number>(
+export function atoiScan<T extends number>(
   srcStart: usize,
   srcEnd: usize,
   dstPtr: usize,

package/assembly/util/bytes.ts

@@ -1,7 +1,6 @@
 import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
 
-// @ts-ignore: Decorator valid here
-@inline export function bytes<T>(o: T): i32 {
+export function bytes<T>(o: T): i32 {
   if (isInteger<T>() || isFloat<T>()) {
     return sizeof<T>();
   } else if (isManaged<T>() || isReference<T>()) {

package/assembly/util/eisel-lemire.ts

@@ -0,0 +1,179 @@
+// Fast, correctly-rounded conversion of `mantissa * 10^power` for the common
+// decimal-exponent range [-22, 22]. This is the Eisel-Lemire conversion used by
+// simdjson's number parser, specialized to the range where json-as previously
+// fell into `scientific()` after the exact-Clinger path rejected mantissas above
+// 2^53. Keeping only 45 cached powers costs 720 bytes instead of simdjson's
+// general 10 KiB table; callers retain `scientific()` as the wide-range fallback.
+
+// Consecutive {primary, secondary} truncated 128-bit powers of five for decimal
+// exponents -22 through 22. Sourced from simdjson's power_of_five_128 table.
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const POWERS_OF_FIVE_128: usize = memory.data<u64>([
+  0xf1c90080baf72cb1, 0x5324c68b12dd6800, 0x971da05074da7bee,
+  0xd3f6fc16ebca8000, 0xbce5086492111aea, 0x88f4bb1ca6bd0000,
+  0xec1e4a7db69561a5, 0x2b31e9e3d0700000, 0x9392ee8e921d5d07,
+  0x3aff322e62600000, 0xb877aa3236a4b449, 0x09befeb9fad487c3,
+  0xe69594bec44de15b, 0x4c2ebe687989a9b4, 0x901d7cf73ab0acd9,
+  0x0f9d37014bf60a11, 0xb424dc35095cd80f, 0x538484c19ef38c95,
+  0xe12e13424bb40e13, 0x2865a5f206b06fba, 0x8cbccc096f5088cb,
+  0xf93f87b7442e45d4, 0xafebff0bcb24aafe, 0xf78f69a51539d749,
+  0xdbe6fecebdedd5be, 0xb573440e5a884d1c, 0x89705f4136b4a597,
+  0x31680a88f8953031, 0xabcc77118461cefc, 0xfdc20d2b36ba7c3e,
+  0xd6bf94d5e57a42bc, 0x3d32907604691b4d, 0x8637bd05af6c69b5,
+  0xa63f9a49c2c1b110, 0xa7c5ac471b478423, 0x0fcf80dc33721d54,
+  0xd1b71758e219652b, 0xd3c36113404ea4a9, 0x83126e978d4fdf3b,
+  0x645a1cac083126ea, 0xa3d70a3d70a3d70a, 0x3d70a3d70a3d70a4,
+  0xcccccccccccccccc, 0xcccccccccccccccd, 0x8000000000000000,
+  0x0000000000000000, 0xa000000000000000, 0x0000000000000000,
+  0xc800000000000000, 0x0000000000000000, 0xfa00000000000000,
+  0x0000000000000000, 0x9c40000000000000, 0x0000000000000000,
+  0xc350000000000000, 0x0000000000000000, 0xf424000000000000,
+  0x0000000000000000, 0x9896800000000000, 0x0000000000000000,
+  0xbebc200000000000, 0x0000000000000000, 0xee6b280000000000,
+  0x0000000000000000, 0x9502f90000000000, 0x0000000000000000,
+  0xba43b74000000000, 0x0000000000000000, 0xe8d4a51000000000,
+  0x0000000000000000, 0x9184e72a00000000, 0x0000000000000000,
+  0xb5e620f480000000, 0x0000000000000000, 0xe35fa931a0000000,
+  0x0000000000000000, 0x8e1bc9bf04000000, 0x0000000000000000,
+  0xb1a2bc2ec5000000, 0x0000000000000000, 0xde0b6b3a76400000,
+  0x0000000000000000, 0x8ac7230489e80000, 0x0000000000000000,
+  0xad78ebc5ac620000, 0x0000000000000000, 0xd8d726b7177a8000,
+  0x0000000000000000, 0x878678326eac9000, 0x0000000000000000,
+]);
+
+// High half of a full 64x64 -> 128 multiplication, using four 32-bit partial
+// products. WebAssembly MVP has no i128 or mul-high instruction.
+function mul64High(a: u64, b: u64): u64 {
+  const aLo = <u64>(<u32>a);
+  const aHi = a >> 32;
+  const bLo = <u64>(<u32>b);
+  const bHi = b >> 32;
+  const lowLow = aLo * bLo;
+  const highLow = aHi * bLo;
+  const middle = highLow + aLo * bHi;
+  const middleCarry = <u64>(middle < highLow);
+  const low = lowLow + (middle << 32);
+  return aHi * bHi + (middle >> 32) + (middleCarry << 32) + <u64>(low < lowLow);
+}
+
+/**
+ * Fixed-power Eisel-Lemire conversion for GeoJSON-style coordinates with 14
+ * fractional digits. This is the `power == -14` specialization of
+ * {@link eiselLemire22}: the cached-power address and binary-exponent base are
+ * constants, and the exact-halfway correction is unreachable for this power.
+ */
+export function eiselLemireMinus14(significand: u64): f64 {
+  let i = significand;
+  let leading = <i32>clz(i);
+  i <<= leading;
+
+  let lower = i * 0xb424dc35095cd80f;
+  let upper = mul64High(i, 0xb424dc35095cd80f);
+
+  if ((upper & 0x1ff) == 0x1ff) {
+    const secondUpper = mul64High(i, 0x538484c19ef38c95);
+    const oldLower = lower;
+    lower += secondUpper;
+    if (lower < oldLower) upper++;
+  }
+
+  const upperBit = upper >> 63;
+  let mantissa = upper >> (<i32>(upperBit + 9));
+  leading += <i32>(1 ^ upperBit);
+  let realExponent = 1040 - leading;
+
+  mantissa += mantissa & 1;
+  mantissa >>= 1;
+
+  if (mantissa >= (<u64>1) << 53) {
+    mantissa = (<u64>1) << 52;
+    realExponent++;
+  }
+
+  const bits = (mantissa & ~((<u64>1) << 52)) | ((<u64>realExponent) << 52);
+  return reinterpret<f64>(bits);
+}
+
+/** Fixed -14 conversion for significands in [2^53, 2^54). */
+export function eiselLemireMinus14_54Bit(significand: u64): f64 {
+  const i = significand << 10;
+
+  let lower = i * 0xb424dc35095cd80f;
+  let upper = mul64High(i, 0xb424dc35095cd80f);
+
+  if ((upper & 0x1ff) == 0x1ff) {
+    const secondUpper = mul64High(i, 0x538484c19ef38c95);
+    const oldLower = lower;
+    lower += secondUpper;
+    if (lower < oldLower) upper++;
+  }
+
+  const upperBit = upper >> 63;
+  let mantissa = upper >> (<i32>(upperBit + 9));
+  let realExponent = 1030 - <i32>(1 ^ upperBit);
+
+  mantissa += mantissa & 1;
+  mantissa >>= 1;
+
+  if (mantissa >= (<u64>1) << 53) {
+    mantissa = (<u64>1) << 52;
+    realExponent++;
+  }
+
+  const bits = (mantissa & ~((<u64>1) << 52)) | ((<u64>realExponent) << 52);
+  return reinterpret<f64>(bits);
+}
+
+/**
+ * Convert a non-zero u64 significand at a decimal exponent in [-22, 22].
+ * The result is correctly rounded to IEEE-754 binary64.
+ */
+export function eiselLemire22(significand: u64, power: i32): f64 {
+  let i = significand;
+  let leading = <i32>clz(i);
+  i <<= leading;
+
+  const tableIndex = (<usize>(power + 22)) << 4;
+  const factor = load<u64>(POWERS_OF_FIVE_128 + tableIndex);
+  let lower = i * factor;
+  let upper = mul64High(i, factor);
+
+  // A primary product ending in nine uncertain bits needs the second table
+  // limb. This is rare, but removes Eisel-Lemire's historical fallback.
+  if ((upper & 0x1ff) == 0x1ff) {
+    const secondUpper = mul64High(
+      i,
+      load<u64>(POWERS_OF_FIVE_128 + tableIndex, 8),
+    );
+    const oldLower = lower;
+    lower += secondUpper;
+    if (lower < oldLower) upper++;
+  }
+
+  const upperBit = upper >> 63;
+  let mantissa = upper >> (<i32>(upperBit + 9));
+  leading += <i32>(1 ^ upperBit);
+  let realExponent = <i32>(((<i64>217706 * power) >> 16) + 1087) - leading;
+  const halfwayShift = <i32>(upperBit + 9);
+
+  // Round exact halfway cases to even.
+  if (
+    lower <= 1 &&
+    power >= -4 &&
+    power <= 22 &&
+    (mantissa & 3) == 1 &&
+    mantissa << halfwayShift == upper
+  ) {
+    mantissa &= ~(<u64>1);
+  }
+  mantissa += mantissa & 1;
+  mantissa >>= 1;
+
+  if (mantissa >= (<u64>1) << 53) {
+    mantissa = (<u64>1) << 52;
+    realExponent++;
+  }
+
+  const bits = (mantissa & ~((<u64>1) << 52)) | ((<u64>realExponent) << 52);
+  return reinterpret<f64>(bits);
+}

package/assembly/util/idofd.ts

@@ -1,6 +1,5 @@
 import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
 
-// @ts-ignore: decorator
-@inline export function idofD<T>(value: T): usize {
+export function idofD<T>(value: T): usize {
   return changetype<OBJECT>(changetype<usize>(value) - TOTAL_OVERHEAD).rtId;
 }

package/assembly/util/isSpace.ts

@@ -1,4 +1,3 @@
-// @ts-ignore
-@inline export function isSpace(code: u16): boolean {
+export function isSpace(code: u16): boolean {
   return code == 0x20 || code - 9 <= 4;
 }

package/assembly/util/itoa-fast.ts

@@ -6,8 +6,8 @@
 // below. Two reasons:
 //
 //   1. V8/wasm lowers `v / 100` (and other `/ <const>`s) to a single
-//      multiply-shift, so jeaiii's main selling point — avoiding division
-//      hardware — gives no win on this target. The op counts come out
+//      multiply-shift, so jeaiii's main selling point - avoiding division
+//      hardware - gives no win on this target. The op counts come out
 //      roughly equal.
 //
 //   2. The div-by-const variant computes each digit pair independently
@@ -24,7 +24,7 @@
 //   - A 100-entry digit-pair LUT keyed on `value % 100`. One `store<u32>`
 //     emits a UTF-16 pair.
 //
-//   - Forward write in one pass — no `decimalCount32` precomputation, no
+//   - Forward write in one pass - no `decimalCount32` precomputation, no
 //     backward write.
 //
 // Reference H2H bench: `__benches__/custom/itoa-h2h.bench.ts`.
@@ -43,13 +43,11 @@ function initPairs(): void {
   _pairsInited = true;
 }
 
-
-@inline export function ensureItoaPairs(): void {
+export function ensureItoaPairs(): void {
   if (!_pairsInited) initPairs();
 }
 
-// @ts-expect-error: @inline is a valid decorator
-@inline function pair(i: u32): u32 {
+function pair(i: u32): u32 {
   return load<u32>(DIGIT_PAIRS_UTF16 + ((<usize>i) << 2));
 }
 
@@ -213,8 +211,7 @@ export function itoaU64(buf: usize, v: u64): u32 {
  *
  * Returns the number of UTF-16 chars written.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function itoaFast<T extends number>(buf: usize, value: T): u32 {
+export function itoaFast<T extends number>(buf: usize, value: T): u32 {
   if (sizeof<T>() <= 4) {
     if (isSigned<T>()) {
       let v = <i32>value;

package/assembly/util/nextPowerOf2.ts

@@ -1,4 +1,3 @@
-// @ts-ignore: Decorator valid here
-@inline export function nextPowerOf2(n: u32): u32 {
+export function nextPowerOf2(n: u32): u32 {
   return 1 << (32 - clz(n - 1));
 }

package/assembly/util/parsefloat-fast.ts

@@ -3,7 +3,7 @@ import { ptrToStr } from "./ptrToStr";
 // Lemire-style fast float parser.
 //
 // Reference: Daniel Lemire, "Number parsing at a gigabyte per second"
-// (2021). https://arxiv.org/abs/2101.11408 — implemented in
+// (2021). https://arxiv.org/abs/2101.11408 - implemented in
 // https://github.com/fastfloat/fast_float.
 //
 // The "fast path" applies when:
@@ -35,13 +35,11 @@ const MAX_EXACT_POW10: i32 = 22;
 // 2^53 = 9_007_199_254_740_992. Any u64 <= this is exact in f64.
 const MAX_EXACT_MANTISSA: u64 = 1 << 53;
 
-
-@inline function loadPow10(exp: u32): f64 {
+function loadPow10(exp: u32): f64 {
   return load<f64>(POW10_F64_POS + ((<usize>exp) << 3));
 }
 
-
-@inline function fallback<T>(srcStart: usize, srcEnd: usize): T {
+function fallback<T>(srcStart: usize, srcEnd: usize): T {
   const s = ptrToStr(srcStart, srcEnd);
   // @ts-ignore: type
   const type: T = 0;

package/assembly/util/prettyWhitespaceSimd.ts

@@ -0,0 +1,69 @@
+// Whitespace-run scanner selected once for large pretty JSON documents.
+
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_SPACE = i16x8.splat(0x20);
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_WS_LO = i16x8.splat(9);
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_WS_SPAN = i16x8.splat(4);
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_LF = i16x8.splat(10);
+
+
+@inline
+function whitespaceMask(block: v128): i32 {
+  return i16x8.bitmask(
+    v128.or(
+      i16x8.eq(block, SPLAT_SPACE),
+      i16x8.le_u(i16x8.sub(block, SPLAT_WS_LO), SPLAT_WS_SPAN),
+    ),
+  );
+}
+
+/** Detect an eight-space indentation run near the document head. */
+export function hasLongPrettyIndent_SIMD(srcStart: usize, srcEnd: usize): bool {
+  const sampleEnd = min(srcEnd, srcStart + 4096);
+  const vectorEnd = sampleEnd >= 16 ? sampleEnd - 16 : 0;
+  while (srcStart <= vectorEnd) {
+    let mask = i16x8.bitmask(i16x8.eq(load<v128>(srcStart), SPLAT_LF));
+    while (mask != 0) {
+      const newline = srcStart + ((<usize>ctz(mask)) << 1);
+      if (
+        newline + 18 <= srcEnd &&
+        !v128.any_true(v128.xor(load<v128>(newline, 2), i16x8.splat(0x20)))
+      )
+        return true;
+      mask &= mask - 1;
+    }
+    srcStart += 16;
+  }
+  return false;
+}
+
+/** `srcStart` is known to point at JSON whitespace. */
+export function skipPrettyWhitespace_SIMD(
+  srcStart: usize,
+  srcEnd: usize,
+): usize {
+  srcStart += 2;
+  if (srcStart >= srcEnd) return srcStart;
+  let code = load<u16>(srcStart);
+  if (code != 0x20 && code - 9 > 4) return srcStart;
+
+  const vectorEnd = srcEnd >= 16 ? srcEnd - 16 : 0;
+  while (srcStart <= vectorEnd) {
+    const mask = whitespaceMask(load<v128>(srcStart));
+    if (mask == 0xff) {
+      srcStart += 16;
+      continue;
+    }
+    srcStart += (<usize>ctz(~mask & 0xff)) << 1;
+    return srcStart;
+  }
+  do {
+    srcStart += 2;
+    if (srcStart >= srcEnd) return srcStart;
+    code = load<u16>(srcStart);
+  } while (code == 0x20 || code - 9 <= 4);
+  return srcStart;
+}

package/assembly/util/ptrToStr.ts

@@ -1,5 +1,4 @@
-// @ts-ignore: decorator
-@inline export function ptrToStr(start: usize, end: usize): string {
+export function ptrToStr(start: usize, end: usize): string {
   const size = end - start;
   const out = __new(size, idof<string>());
   memory.copy(out, start, size);

package/assembly/util/scanValueEndSimd.ts

@@ -22,23 +22,40 @@ import { isSpace } from "./isSpace";
 // @ts-expect-error: @lazy is a valid decorator
 @lazy const SPLAT_SPACE = i16x8.splat(0x20);
 // JSON whitespace besides space is the contiguous range 0x09..0x0d
-// (tab/LF/VT/FF/CR), matched as `(c - 9) u<= 4` — one sub + one unsigned
+// (tab/LF/VT/FF/CR), matched as `(c - 9) u<= 4` - one sub + one unsigned
 // compare instead of five equality tests. Exact: matches `isSpace` with no
 // false positives.
 // @ts-expect-error: @lazy is a valid decorator
 @lazy const SPLAT_WS_LO = i16x8.splat(0x09);
 // @ts-expect-error: @lazy is a valid decorator
 @lazy const SPLAT_WS_SPAN = i16x8.splat(0x04);
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_BRACKET_LEFT = i16x8.splat(<i16>BRACKET_LEFT);
+// Clears bit 5 (0x20), folding `{`/`}` onto `[`/`]` so one pair of compares
+// matches either bracket flavor. No ASCII char besides `[{`/`]}` folds onto
+// `[`/`]`, so the structural mask stays exact.
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_BRACKET_FOLD = i16x8.splat(<i16>0xffdf);
 
-// @ts-expect-error: @inline is a valid decorator
-@inline function quoteOrBackslashMask(block: v128): i32 {
+function quoteOrBackslashMask(block: v128): i32 {
   return i16x8.bitmask(
     v128.or(i16x8.eq(block, SPLAT_QUOTE), i16x8.eq(block, SPLAT_BACK_SLASH)),
   );
 }
 
-// @ts-expect-error: @inline is a valid decorator
-@inline function scalarTerminatorMask(block: v128): i32 {
+// Lanes equal to `"`, `{`, `}`, `[`, or `]` - the only bytes that, outside a
+// string, change depth or open a string. Everything else (digits, `:`, `,`,
+// whitespace, true/false/null) can be bulk-skipped between them.
+function structuralOrQuoteMask(block: v128): i32 {
+  const folded = v128.and(block, SPLAT_BRACKET_FOLD);
+  const brackets = v128.or(
+    i16x8.eq(folded, SPLAT_BRACKET_LEFT),
+    i16x8.eq(folded, SPLAT_BRACKET_RIGHT),
+  );
+  return i16x8.bitmask(v128.or(brackets, i16x8.eq(block, SPLAT_QUOTE)));
+}
+
+function scalarTerminatorMask(block: v128): i32 {
   const structural = v128.or(
     v128.or(i16x8.eq(block, SPLAT_COMMA), i16x8.eq(block, SPLAT_BRACE_RIGHT)),
     i16x8.eq(block, SPLAT_BRACKET_RIGHT),
@@ -86,23 +103,71 @@ function scanQuotedValueEnd_SIMD(srcStart: usize, srcEnd: usize): usize {
 }
 
 function scanCompositeValueEnd_SIMD(srcStart: usize, srcEnd: usize): usize {
-  // Track object/array depth scalar-side (structural tokens are sparse and a
-  // bulk token-mask scan loses to a tight loop on token-dense objects), but
-  // skip nested string VALUES with the vectorized quoted scan — that's where
-  // the long runs (URLs, base64, prose) actually are.
+  // Walk every structural event in a loaded block before advancing. This is
+  // substantially cheaper for object-heavy values than restarting a SIMD hunt
+  // after every short key: one v128 load now covers all quotes and brackets in
+  // its eight UTF-16 lanes. Brackets inside strings are ignored, and a closing
+  // quote is active only when preceded by an even-length backslash run.
   let depth: i32 = 1;
   let ptr = srcStart + 2;
+  const srcEnd16 = srcEnd >= 16 ? srcEnd - 16 : 0;
+  let inString = false;
+
+  while (ptr <= srcEnd16) {
+    let mask = structuralOrQuoteMask(load<v128>(ptr));
+    while (mask != 0) {
+      const lane = usize(ctz(mask) << 1);
+      mask &= mask - 1;
+      const eventPtr = ptr + lane;
+      const code = load<u16>(eventPtr);
+
+      if (code == QUOTE) {
+        if (!inString) {
+          inString = true;
+        } else {
+          let slash = eventPtr - 2;
+          let escaped = false;
+          while (slash > srcStart && load<u16>(slash) == BACK_SLASH) {
+            escaped = !escaped;
+            slash -= 2;
+          }
+          if (!escaped) inString = false;
+        }
+        continue;
+      }
+      if (inString) continue;
+
+      const folded = code & 0xffdf;
+      if (folded == BRACKET_LEFT) {
+        depth++;
+      } else if (folded == BRACKET_RIGHT && --depth == 0) {
+        return eventPtr + 2;
+      }
+    }
+    ptr += 16;
+  }
+
   while (ptr < srcEnd) {
     const code = load<u16>(ptr);
     if (code == QUOTE) {
-      ptr = scanQuotedValueEnd_SIMD(ptr, srcEnd);
-      if (!ptr) return 0;
-      continue;
-    }
-    if (code == BRACE_LEFT || code == BRACKET_LEFT) {
-      depth++;
-    } else if (code == BRACE_RIGHT || code == BRACKET_RIGHT) {
-      if (--depth == 0) return ptr + 2;
+      if (!inString) {
+        inString = true;
+      } else {
+        let slash = ptr - 2;
+        let escaped = false;
+        while (slash > srcStart && load<u16>(slash) == BACK_SLASH) {
+          escaped = !escaped;
+          slash -= 2;
+        }
+        if (!escaped) inString = false;
+      }
+    } else if (!inString) {
+      const folded = code & 0xffdf;
+      if (folded == BRACKET_LEFT) {
+        depth++;
+      } else if (folded == BRACKET_RIGHT && --depth == 0) {
+        return ptr + 2;
+      }
     }
     ptr += 2;
   }
@@ -135,11 +200,7 @@ function scanScalarValueEnd_SIMD(srcStart: usize, srcEnd: usize): usize {
   return srcStart;
 }
 
-// @ts-expect-error: @inline is a valid decorator
-@inline export function scanValueEnd_SIMD<T>(
-  srcStart: usize,
-  srcEnd: usize,
-): usize {
+export function scanValueEnd_SIMD<T>(srcStart: usize, srcEnd: usize): usize {
   if (srcStart >= srcEnd) return 0;
   const first = load<u16>(srcStart);