json-as 1.3.6 → 1.3.8

package/assembly/util/dragonbox.ts

@@ -1,5 +1,6 @@
 import { DRAGONBOX_F32_CACHE, DRAGONBOX_F64_CACHE } from "./dragonbox-cache";
-import { decimalCount32, itoa_buffered, utoa32_dec_core } from "util/number";
+import { decimalCount32, utoa32_dec_core } from "util/number";
+import { ensureItoaPairs, itoaU32, itoaU64 } from "./itoa-fast";
 
 const CHAR_MINUS: u16 = 45;
 const CHAR_DOT: u16 = 46;
@@ -188,7 +189,12 @@ function computeMul64(u: u64, cacheHigh: u64, cacheLow: u64): void {
 
 
 @inline
-function computeMulParity64(twoF: u64, cacheHigh: u64, cacheLow: u64, beta: i32): void {
+function computeMulParity64(
+  twoF: u64,
+  cacheHigh: u64,
+  cacheLow: u64,
+  beta: i32,
+): void {
   const high = twoF * cacheHigh;
 
   const a = <u32>(twoF >>> 32);
@@ -205,7 +211,8 @@ function computeMulParity64(twoF: u64, cacheHigh: u64, cacheLow: u64, beta: i32)
 
   const rHigh = high + lowHigh;
   _dbParity = ((rHigh >>> (64 - beta)) & 1) != 0;
-  _dbMulIsInteger = (((rHigh << beta) & 0xffffffffffffffff) | (lowLow >>> (64 - beta))) == 0;
+  _dbMulIsInteger =
+    (((rHigh << beta) & 0xffffffffffffffff) | (lowLow >>> (64 - beta))) == 0;
 }
 
 
@@ -298,7 +305,8 @@ function prettify(buffer: usize, length: i32, k: i32): i32 {
 
   const kk = length + k;
   if (length <= kk && kk <= 21) {
-    for (let i = length; i < kk; ++i) store<u16>(buffer + ((<usize>i) << 1), CHAR_0);
+    for (let i = length; i < kk; ++i)
+      store<u16>(buffer + ((<usize>i) << 1), CHAR_0);
     const tail = buffer + ((<usize>kk) << 1);
     store<u16>(tail, CHAR_DOT);
     store<u16>(tail, CHAR_0, 2);
@@ -313,7 +321,8 @@ function prettify(buffer: usize, length: i32, k: i32): i32 {
     memory.copy(buffer + ((<usize>offset) << 1), buffer, (<usize>length) << 1);
     store<u16>(buffer, CHAR_0);
     store<u16>(buffer, CHAR_DOT, 2);
-    for (let i = 2; i < offset; ++i) store<u16>(buffer + ((<usize>i) << 1), CHAR_0);
+    for (let i = 2; i < offset; ++i)
+      store<u16>(buffer + ((<usize>i) << 1), CHAR_0);
     return length + offset;
   } else if (length == 1) {
     store<u16>(buffer, CHAR_E, 2);
@@ -365,7 +374,10 @@ function prettifyFast(buffer: usize, length: i32, k: i32): i32 {
   return -1;
 }
 
-function dragonboxToDecimalF32(binarySignificand: u32, binaryExponent: i32): u32 {
+function dragonboxToDecimalF32(
+  binarySignificand: u32,
+  binaryExponent: i32,
+): u32 {
   const isEven = (binarySignificand & 1) == 0;
   let twoFc = binarySignificand << 1;
 
@@ -374,7 +386,9 @@ function dragonboxToDecimalF32(binarySignificand: u32, binaryExponent: i32): u32
     if (twoFc == 0) {
       const minusK = floor_log10_pow2_minus_log10_4_over_3(binaryExponent);
       const beta = binaryExponent + floor_log2_pow10(-minusK);
-      const cache = load<u64>(DRAGONBOX_F32_CACHE + ((<usize>(31 - minusK)) << 3));
+      const cache = load<u64>(
+        DRAGONBOX_F32_CACHE + ((<usize>(31 - minusK)) << 3),
+      );
       let xi = computeLeftEndpointShorter32(cache, beta);
       const zi = computeRightEndpointShorter32(cache, beta);
       if (!(binaryExponent >= 2 && binaryExponent <= 3)) ++xi;
@@ -387,7 +401,8 @@ function dragonboxToDecimalF32(binarySignificand: u32, binaryExponent: i32): u32
         return decimalSignificand;
       }
       decimalSignificand = computeRoundUpShorter32(cache, beta);
-      if ((decimalSignificand & 1) != 0 && binaryExponent == -35) --decimalSignificand;
+      if ((decimalSignificand & 1) != 0 && binaryExponent == -35)
+        --decimalSignificand;
       else if (decimalSignificand < xi) ++decimalSignificand;
       _dbK = minusK;
       return decimalSignificand;
@@ -444,14 +459,18 @@ function dragonboxToDecimalF32(binarySignificand: u32, binaryExponent: i32): u32
   if ((packedDiv & 1) != 0) {
     computeMulParity32(twoFc, cache, beta);
     if (_dbParity != approxYParity) --decimalSignificand;
-    else if ((decimalSignificand & 1) != 0 && _dbMulIsInteger) --decimalSignificand;
+    else if ((decimalSignificand & 1) != 0 && _dbMulIsInteger)
+      --decimalSignificand;
   }
 
   _dbK = minusK + 1;
   return decimalSignificand;
 }
 
-function dragonboxToDecimalF64(binarySignificand: u64, binaryExponent: i32): u64 {
+function dragonboxToDecimalF64(
+  binarySignificand: u64,
+  binaryExponent: i32,
+): u64 {
   const isEven = (binarySignificand & 1) == 0;
   let twoFc = binarySignificand << 1;
 
@@ -475,7 +494,8 @@ function dragonboxToDecimalF64(binarySignificand: u64, binaryExponent: i32): u64
         return decimalSignificand;
       }
       decimalSignificand = computeRoundUpShorter64(cacheHigh, beta);
-      if ((decimalSignificand & 1) != 0 && binaryExponent == -77) --decimalSignificand;
+      if ((decimalSignificand & 1) != 0 && binaryExponent == -77)
+        --decimalSignificand;
       else if (decimalSignificand < xi) ++decimalSignificand;
       _dbK = minusK;
       return decimalSignificand;
@@ -534,7 +554,8 @@ function dragonboxToDecimalF64(binarySignificand: u64, binaryExponent: i32): u64
   if ((packedDiv & 1) != 0) {
     computeMulParity64(twoFc, cacheHigh, cacheLow, beta);
     if (_dbParity != approxYParity) --decimalSignificand;
-    else if ((decimalSignificand & 1) != 0 && _dbMulIsInteger) --decimalSignificand;
+    else if ((decimalSignificand & 1) != 0 && _dbMulIsInteger)
+      --decimalSignificand;
   }
 
   _dbK = minusK + 2;
@@ -548,8 +569,15 @@ function dragonboxCoreF32(buffer: usize, value: f32): u32 {
     value = -value;
     store<u16>(buffer, CHAR_MINUS);
   }
-  const digits = dragonboxToDecimalF32(reinterpret<u32>(value) & 0x7fffff, (reinterpret<u32>(value) >>> 23) & 0xff);
-  let len = itoa_buffered<u32>(buffer + ((<usize>sign) << 1), digits);
+  const digits = dragonboxToDecimalF32(
+    reinterpret<u32>(value) & 0x7fffff,
+    (reinterpret<u32>(value) >>> 23) & 0xff,
+  );
+  // Use the jeaiii-style itoa (forward write + 2-digit-pair LUT) instead
+  // of AS stdlib's `itoa_buffered`, which runs a separate width classifier
+  // + backward div-by-10000 loop. Saves a function call and ~half the
+  // per-digit work for the typical 7-17 digit dragonbox output.
+  let len = itoaU32(buffer + ((<usize>sign) << 1), digits);
   return <u32>(prettify(buffer + ((<usize>sign) << 1), len, _dbK) + sign);
 }
 
@@ -561,8 +589,11 @@ function dragonboxCoreF64(buffer: usize, value: f64): u32 {
     store<u16>(buffer, CHAR_MINUS);
   }
   const bits = reinterpret<u64>(value);
-  const digits = dragonboxToDecimalF64(bits & 0x000fffffffffffff, <i32>((bits >>> 52) & 0x7ff));
-  let len = itoa_buffered<u64>(buffer + ((<usize>sign) << 1), digits);
+  const digits = dragonboxToDecimalF64(
+    bits & 0x000fffffffffffff,
+    <i32>((bits >>> 52) & 0x7ff),
+  );
+  let len = itoaU64(buffer + ((<usize>sign) << 1), digits);
   return <u32>(prettify(buffer + ((<usize>sign) << 1), len, _dbK) + sign);
 }
 
@@ -589,6 +620,7 @@ export function dragonbox_f32_buffered(buffer: usize, value: f32): u32 {
     store<u64>(buffer + 8, 0x7900740069006e);
     return 8 + (sign ? 1 : 0);
   }
+  ensureItoaPairs();
   return dragonboxCoreF32(buffer, value);
 }
 
@@ -615,10 +647,14 @@ export function dragonbox_f64_buffered(buffer: usize, value: f64): u32 {
     store<u64>(buffer + 8, 0x7900740069006e);
     return 8 + (sign ? 1 : 0);
   }
+  ensureItoaPairs();
   return dragonboxCoreF64(buffer, value);
 }
 
-export function dragonbox_buffered<T extends number>(buffer: usize, value: T): u32 {
+export function dragonbox_buffered<T extends number>(
+  buffer: usize,
+  value: T,
+): u32 {
   if (sizeof<T>() == 4) return dragonbox_f32_buffered(buffer, <f32>value);
   return dragonbox_f64_buffered(buffer, <f64>value);
 }

package/assembly/util/itoa-fast.ts

@@ -0,0 +1,241 @@
+// Fast integer -> UTF-16 stringification.
+//
+// We tried the "real" jeaiii algorithm (fixed-point magic-multiplication
+// per bucket; `f0 -> f2 -> f4 -> f6` chained fractional-part extractions)
+// and it ran ~5-7% slower on V8/wasm than the div-by-constant variant
+// 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
+//      roughly equal.
+//
+//   2. The div-by-const variant computes each digit pair independently
+//      from `v` (`h = v / 100`, `l = v - h*100`, etc), so V8 schedules
+//      the LUT loads + stores for all pairs in parallel. The jeaiii
+//      chain forces them serial.
+//
+// What we keep from jeaiii here:
+//
+//   - Width-ladder dispatch (`if v < 100 / 10_000 / 1_000_000 / ...`) so
+//     the same comparisons that would drive a separate `decimalCount`
+//     pass become the bucket pick.
+//
+//   - 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
+//     backward write.
+//
+// Reference H2H bench: `__benches__/custom/itoa-h2h.bench.ts`.
+
+// 100-entry pair LUT: index `i` -> u32 holding UTF-16 chars for the
+// zero-padded two-digit string "DD". One `store<u32>` writes the pair.
+const DIGIT_PAIRS_UTF16: usize = memory.data(100 * 4);
+let _pairsInited: bool = false;
+
+function initPairs(): void {
+  for (let i: i32 = 0; i < 100; i++) {
+    const tens = u32(0x30 + i / 10);
+    const units = u32(0x30 + (i % 10));
+    store<u32>(DIGIT_PAIRS_UTF16 + ((<usize>i) << 2), tens | (units << 16));
+  }
+  _pairsInited = true;
+}
+
+
+@inline export function ensureItoaPairs(): void {
+  if (!_pairsInited) initPairs();
+}
+
+// @ts-expect-error: @inline is a valid decorator
+@inline function pair(i: u32): u32 {
+  return load<u32>(DIGIT_PAIRS_UTF16 + ((<usize>i) << 2));
+}
+
+/**
+ * u32 -> UTF-16 stringification, forward write.
+ * Returns the number of UTF-16 chars written (caller multiplies by 2 for
+ * a byte offset). Caller must ensure the buffer has at least 20 bytes
+ * available (max 10 chars).
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function itoaU32(buf: usize, v: u32): u32 {
+  if (v < 10) {
+    store<u16>(buf, <u16>(v + 0x30));
+    return 1;
+  }
+  if (v < 100) {
+    store<u32>(buf, pair(v));
+    return 2;
+  }
+  if (v < 1_000_000) {
+    if (v < 10_000) {
+      if (v < 1_000) {
+        const h = v / 100;
+        const l = v - h * 100;
+        store<u16>(buf, <u16>(h + 0x30));
+        store<u32>(buf, pair(l), 2);
+        return 3;
+      }
+      const h = v / 100;
+      const l = v - h * 100;
+      store<u32>(buf, pair(h));
+      store<u32>(buf, pair(l), 4);
+      return 4;
+    }
+    if (v < 100_000) {
+      const hi = v / 10_000;
+      const rest = v - hi * 10_000;
+      const m = rest / 100;
+      const l = rest - m * 100;
+      store<u16>(buf, <u16>(hi + 0x30));
+      store<u32>(buf, pair(m), 2);
+      store<u32>(buf, pair(l), 6);
+      return 5;
+    }
+    const hi = v / 10_000;
+    const rest = v - hi * 10_000;
+    const m = rest / 100;
+    const l = rest - m * 100;
+    store<u32>(buf, pair(hi));
+    store<u32>(buf, pair(m), 4);
+    store<u32>(buf, pair(l), 8);
+    return 6;
+  }
+  if (v < 100_000_000) {
+    if (v < 10_000_000) {
+      const top = v / 1_000_000;
+      let rest = v - top * 1_000_000;
+      const m = rest / 10_000;
+      rest = rest - m * 10_000;
+      const n = rest / 100;
+      const l = rest - n * 100;
+      store<u16>(buf, <u16>(top + 0x30));
+      store<u32>(buf, pair(m), 2);
+      store<u32>(buf, pair(n), 6);
+      store<u32>(buf, pair(l), 10);
+      return 7;
+    }
+    const top = v / 1_000_000;
+    let rest = v - top * 1_000_000;
+    const m = rest / 10_000;
+    rest = rest - m * 10_000;
+    const n = rest / 100;
+    const l = rest - n * 100;
+    store<u32>(buf, pair(top));
+    store<u32>(buf, pair(m), 4);
+    store<u32>(buf, pair(n), 8);
+    store<u32>(buf, pair(l), 12);
+    return 8;
+  }
+  if (v < 1_000_000_000) {
+    const top = v / 100_000_000;
+    let rest = v - top * 100_000_000;
+    const a = rest / 1_000_000;
+    rest = rest - a * 1_000_000;
+    const b = rest / 10_000;
+    rest = rest - b * 10_000;
+    const c = rest / 100;
+    const d = rest - c * 100;
+    store<u16>(buf, <u16>(top + 0x30));
+    store<u32>(buf, pair(a), 2);
+    store<u32>(buf, pair(b), 6);
+    store<u32>(buf, pair(c), 10);
+    store<u32>(buf, pair(d), 14);
+    return 9;
+  }
+  const top = v / 100_000_000;
+  let rest = v - top * 100_000_000;
+  const a = rest / 1_000_000;
+  rest = rest - a * 1_000_000;
+  const b = rest / 10_000;
+  rest = rest - b * 10_000;
+  const c = rest / 100;
+  const d = rest - c * 100;
+  store<u32>(buf, pair(top));
+  store<u32>(buf, pair(a), 4);
+  store<u32>(buf, pair(b), 8);
+  store<u32>(buf, pair(c), 12);
+  store<u32>(buf, pair(d), 16);
+  return 10;
+}
+
+/**
+ * Writes a u32 in the range 0..99_999_999 as exactly 8 UTF-16 chars with
+ * leading zeros. Used by the u64 path to emit trailing groups of 8 digits.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline function writeU32Padded8(buf: usize, v: u32): void {
+  const a = v / 1_000_000;
+  let rest = v - a * 1_000_000;
+  const b = rest / 10_000;
+  rest = rest - b * 10_000;
+  const c = rest / 100;
+  const d = rest - c * 100;
+  store<u32>(buf, pair(a));
+  store<u32>(buf, pair(b), 4);
+  store<u32>(buf, pair(c), 8);
+  store<u32>(buf, pair(d), 12);
+}
+
+/**
+ * u64 -> UTF-16 stringification.
+ * Small values delegate to `itoaU32`. For 11+ digit values, peel 8 digits
+ * from the bottom (always fits in u32), emit the remaining top via the
+ * u32 path, then emit the 8 trailing digits with leading-zero padding.
+ * For 17+ digit values (which still fit in u64 < 1.8e19), repeat.
+ * Caller must ensure the buffer has at least 40 bytes available.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function itoaU64(buf: usize, v: u64): u32 {
+  if (v <= <u64>u32.MAX_VALUE) {
+    return itoaU32(buf, <u32>v);
+  }
+  const lo8 = <u32>(v % 100_000_000);
+  const hi = v / 100_000_000;
+  if (hi <= <u64>u32.MAX_VALUE) {
+    const written = itoaU32(buf, <u32>hi);
+    writeU32Padded8(buf + ((<usize>written) << 1), lo8);
+    return written + 8;
+  }
+  // 17-20 digit case: peel a second group of 8.
+  const mid8 = <u32>(hi % 100_000_000);
+  const top = <u32>(hi / 100_000_000);
+  const written = itoaU32(buf, top);
+  writeU32Padded8(buf + ((<usize>written) << 1), mid8);
+  writeU32Padded8(buf + ((<usize>written) << 1) + 16, lo8);
+  return written + 16;
+}
+
+/**
+ * Generic integer -> UTF-16 entry point. Signed types peel `-` and pass
+ * the absolute value (via two's complement negation, which works for the
+ * minimum-value edge case because `u32(-i32.MIN_VALUE) == 2147483648`
+ * and likewise for i64).
+ *
+ * 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 {
+  if (sizeof<T>() <= 4) {
+    if (isSigned<T>()) {
+      let v = <i32>value;
+      if (v < 0) {
+        store<u16>(buf, 0x2d); // '-'
+        return 1 + itoaU32(buf + 2, <u32>-v);
+      }
+      return itoaU32(buf, <u32>v);
+    }
+    return itoaU32(buf, <u32>value);
+  }
+  if (isSigned<T>()) {
+    let v = <i64>value;
+    if (v < 0) {
+      store<u16>(buf, 0x2d); // '-'
+      return 1 + itoaU64(buf + 2, <u64>-v);
+    }
+    return itoaU64(buf, <u64>value);
+  }
+  return itoaU64(buf, <u64>value);
+}

package/assembly/util/masks.ts

@@ -25,7 +25,24 @@ export function block_to_string(block: u64): string {
 export function mask_to_string_v128(vec: v128): string {
   let result = "0x";
 
-  const lanes: i8[] = [i8x16.extract_lane_s(vec, 0), i8x16.extract_lane_s(vec, 1), i8x16.extract_lane_s(vec, 2), i8x16.extract_lane_s(vec, 3), i8x16.extract_lane_s(vec, 4), i8x16.extract_lane_s(vec, 5), i8x16.extract_lane_s(vec, 6), i8x16.extract_lane_s(vec, 7), i8x16.extract_lane_s(vec, 8), i8x16.extract_lane_s(vec, 9), i8x16.extract_lane_s(vec, 10), i8x16.extract_lane_s(vec, 11), i8x16.extract_lane_s(vec, 12), i8x16.extract_lane_s(vec, 13), i8x16.extract_lane_s(vec, 14), i8x16.extract_lane_s(vec, 15)];
+  const lanes: i8[] = [
+    i8x16.extract_lane_s(vec, 0),
+    i8x16.extract_lane_s(vec, 1),
+    i8x16.extract_lane_s(vec, 2),
+    i8x16.extract_lane_s(vec, 3),
+    i8x16.extract_lane_s(vec, 4),
+    i8x16.extract_lane_s(vec, 5),
+    i8x16.extract_lane_s(vec, 6),
+    i8x16.extract_lane_s(vec, 7),
+    i8x16.extract_lane_s(vec, 8),
+    i8x16.extract_lane_s(vec, 9),
+    i8x16.extract_lane_s(vec, 10),
+    i8x16.extract_lane_s(vec, 11),
+    i8x16.extract_lane_s(vec, 12),
+    i8x16.extract_lane_s(vec, 13),
+    i8x16.extract_lane_s(vec, 14),
+    i8x16.extract_lane_s(vec, 15),
+  ];
 
   for (let i = 15; i >= 0; i--) {
     const byte = lanes[i];

package/assembly/util/parsefloat-fast.ts

@@ -0,0 +1,167 @@
+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
+// https://github.com/fastfloat/fast_float.
+//
+// The "fast path" applies when:
+//   - the mantissa fits in a u64 (<=19 decimal digits), and
+//   - the total decimal exponent is in [-22, 22], so the matching
+//     `1e<exp>` power-of-ten is representable exactly in f64.
+//
+// In that regime `value = mantissa * 10^exp` rounds correctly under
+// IEEE-754: both operands are exact in f64 and the single fmul is
+// correctly rounded, so the result is the same as the strictly-rounded
+// reference. This covers the overwhelming majority of JSON float
+// payloads (most fields are <20 significant digits and modest
+// exponents). Out-of-range inputs delegate to AS std's `f64.parse`
+// (Grisu-based; correctly rounded for all f64).
+//
+// Compared to the original digit-by-digit accumulator (`value = value *
+// 10.0 + digit`) this saves both wall-time (fewer fmul/fdiv) and
+// precision (one rounding instead of N).
+
+// 23-entry table: 10^0 .. 10^22, all exact in f64. f32 fast-paths can
+// reuse the same table (since 10^k for k <= 22 fits in f32 only up to
+// 10^7, but the multiplication is done in f64 and narrowed at the end).
+const POW10_F64_POS: usize = memory.data<f64>([
+  1, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13, 1e14,
+  1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22,
+]);
+
+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 {
+  return load<f64>(POW10_F64_POS + ((<usize>exp) << 3));
+}
+
+
+@inline function fallback<T>(srcStart: usize, srcEnd: usize): T {
+  const s = ptrToStr(srcStart, srcEnd);
+  // @ts-ignore: type
+  const type: T = 0;
+  // @ts-ignore: type
+  if (type instanceof f64) return <T>f64.parse(s);
+  // @ts-ignore: cast
+  return <T>(<f32>f32.parse(s));
+}
+
+/**
+ * Fast path for `deserializeFloat`. `srcStart..srcEnd` must contain only
+ * the float content (no surrounding whitespace, no `null`). Returns the
+ * parsed value; on the slow path falls back to `f64.parse` /
+ * `f32.parse` over the same range so behavior is preserved for every
+ * input the previous parser accepted.
+ *
+ * Structure mirrors the existing parser's split integer/fraction loops
+ * (TurboFan schedules these tighter than a single fused loop) but uses
+ * u64 accumulators throughout so a 17-digit "3.141592653589793" stays
+ * exact through accumulation and only loses precision at the final
+ * `<f64>` cast.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function parseFloatFast<T>(srcStart: usize, srcEnd: usize): T {
+  const origStart = srcStart;
+  let p = srcStart;
+  let negative = false;
+  if (p < srcEnd && load<u16>(p) == 45) {
+    negative = true;
+    p += 2;
+  }
+
+  // Integer part.
+  let mantissa: u64 = 0;
+  let intDigits: i32 = 0;
+  while (p < srcEnd) {
+    const d = <u32>load<u16>(p) - 48;
+    if (d > 9) break;
+    mantissa = mantissa * 10 + <u64>d;
+    intDigits++;
+    p += 2;
+  }
+
+  // Optional fractional part.
+  let fracDigits: i32 = 0;
+  if (p < srcEnd && load<u16>(p) == 46) {
+    p += 2;
+    while (p < srcEnd) {
+      const d = <u32>load<u16>(p) - 48;
+      if (d > 9) break;
+      mantissa = mantissa * 10 + <u64>d;
+      fracDigits++;
+      p += 2;
+    }
+  }
+
+  const mantDigits = intDigits + fracDigits;
+  if (mantDigits == 0) {
+    // No digits seen (e.g. `.5`, `NaN`, `Infinity`) - defer to AS std.
+    return fallback<T>(origStart, srcEnd);
+  }
+
+  let exponent: i32 = -fracDigits;
+
+  // Optional `e[+-]NNN` suffix.
+  if (p < srcEnd) {
+    const c = load<u16>(p);
+    if (c == 101 || c == 69) {
+      p += 2;
+      if (p >= srcEnd) return fallback<T>(origStart, srcEnd);
+      let expNeg = false;
+      const sc = load<u16>(p);
+      if (sc == 45) {
+        expNeg = true;
+        p += 2;
+      } else if (sc == 43) {
+        p += 2;
+      }
+      if (p >= srcEnd) return fallback<T>(origStart, srcEnd);
+      let exp: i32 = 0;
+      let expDigits: i32 = 0;
+      while (p < srcEnd) {
+        const d = <u32>load<u16>(p) - 48;
+        if (d > 9) break;
+        exp = exp * 10 + <i32>d;
+        expDigits++;
+        if (expDigits > 4) {
+          // Pathological exponent - fall back for safety.
+          return fallback<T>(origStart, srcEnd);
+        }
+        p += 2;
+      }
+      if (expDigits == 0) return fallback<T>(origStart, srcEnd);
+      exponent += expNeg ? -exp : exp;
+    }
+  }
+
+  // Fast path eligibility: mantissa fits exactly in an f64 and exponent
+  // is in the exactly-representable pow10 range. Both halves are needed
+  // for the result to be correctly rounded. Capping `mantDigits` at 19
+  // is a cheaper proxy for "didn't overflow u64".
+  if (mantDigits > 19 || mantissa > MAX_EXACT_MANTISSA) {
+    return fallback<T>(origStart, srcEnd);
+  }
+  if (exponent > MAX_EXACT_POW10 || exponent < -MAX_EXACT_POW10) {
+    return fallback<T>(origStart, srcEnd);
+  }
+
+  let result = <f64>mantissa;
+  if (exponent > 0) {
+    result *= loadPow10(<u32>exponent);
+  } else if (exponent < 0) {
+    result /= loadPow10(<u32>-exponent);
+  }
+  if (negative) result = -result;
+
+  // @ts-ignore: type
+  const type: T = 0;
+  // @ts-ignore: type
+  if (type instanceof f64) return <T>result;
+  // @ts-ignore: cast
+  return <T>(<f32>result);
+}

package/assembly/util/scanValueEnd.ts

@@ -0,0 +1,78 @@
+import {
+  BRACE_LEFT,
+  BRACE_RIGHT,
+  BRACKET_LEFT,
+  BRACKET_RIGHT,
+  COMMA,
+  QUOTE,
+} from "../custom/chars";
+import { isSpace } from "./isSpace";
+import { scanStringEnd } from "./stringScan";
+
+/**
+ * Pure-scalar value-end scanner used by the NAIVE container deserializers.
+ *
+ * Returns the position immediately after the value that begins at `srcStart`:
+ *
+ * - For a quoted string: position past the closing `"` (uses scalar
+ *   {@link scanStringEnd}).
+ * - For an object/array: position past the matching `}`/`]`, tracking depth
+ *   and skipping nested quoted strings.
+ * - For anything else: position of the first `,`, `]`, or `}` (the value's
+ *   structural terminator).
+ *
+ * Returns `0` when the input is empty or no terminator is found.
+ *
+ * Mirrors the semantics of `deserialize/swar/array/shared.ts:scanValueEnd`
+ * but stays scalar so `naive/` callers don't pull SWAR into the correctness
+ * baseline.
+ */
+// @ts-ignore: inline
+@inline export function scanValueEnd(srcStart: usize, srcEnd: usize): usize {
+  if (srcStart >= srcEnd) return 0;
+  const first = load<u16>(srcStart);
+
+  if (first == QUOTE) {
+    const end = scanStringEnd(srcStart, srcEnd);
+    return end >= srcEnd ? 0 : end + 2;
+  }
+
+  if (first == BRACE_LEFT || first == BRACKET_LEFT) {
+    let depth: i32 = 1;
+    let ptr = srcStart + 2;
+    while (ptr < srcEnd) {
+      const code = load<u16>(ptr);
+      if (code == QUOTE) {
+        const end = scanStringEnd(ptr, srcEnd);
+        if (end >= srcEnd) return 0;
+        ptr = end + 2;
+        continue;
+      }
+      if (code == BRACE_LEFT || code == BRACKET_LEFT) {
+        depth++;
+      } else if (code == BRACE_RIGHT || code == BRACKET_RIGHT) {
+        if (--depth == 0) return ptr + 2;
+      }
+      ptr += 2;
+    }
+    return 0;
+  }
+
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    // Stop at the structural terminator OR trailing whitespace, so the returned
+    // range is the exact value (scalar parsers assume [srcStart,srcEnd) is the
+    // value with no trailing whitespace). Callers skip whitespace to reach the
+    // following `,`/`]`/`}`.
+    if (
+      code == COMMA ||
+      code == BRACKET_RIGHT ||
+      code == BRACE_RIGHT ||
+      isSpace(code)
+    )
+      return srcStart;
+    srcStart += 2;
+  }
+
+  return 0;
+}