json-as 1.3.6 → 1.3.8

package/assembly/util/scientific.ts

@@ -0,0 +1,132 @@
+// Direct decimal-to-f64 conversion from a `(u64 mantissa, i32 decimal exp)`
+// pair. Bit-identical to `f64.parse` / `f32.parse` for any input the SWAR
+// float deserializer can produce.
+//
+// Ported from AssemblyScript std's `util/string.ts` (which itself is adapted
+// from the "metallic" library). The reason we duplicate it: AS std exposes
+// `strtod(str)` but the underlying `scientific(mantissa, exp)` helper is
+// module-private. Going through `strtod` requires a string allocation and a
+// re-parse of digits we've already accumulated in the SWAR loop. Calling
+// `scientific` directly skips both costs.
+//
+// scientific() is correctly rounded for all u64 mantissas and decimal
+// exponents that fit in IEEE-754 f64's range — including the [2^53, 2^64)
+// mantissa range that breaks Lemire's single-fmul fast path.
+
+const POWERS10: 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,
+]);
+
+// 5^i for i in [0, 13]. ipow32(5, e) for the exponent ranges scaledown
+// and scaleup actually call it with.
+const POWERS5: usize = memory.data<i32>([
+  1, 5, 25, 125, 625, 3125, 15625, 78125, 390625, 1953125, 9765625, 48828125,
+  244140625, 1220703125,
+]);
+
+// @ts-ignore: inline
+@inline function pow10(n: i32): f64 {
+  return load<f64>(POWERS10 + ((<usize>n) << alignof<f64>()));
+}
+
+// @ts-ignore: inline
+@inline function pow5_32(n: i32): i32 {
+  return load<i32>(POWERS5 + ((<usize>n) << alignof<i32>()));
+}
+
+// __fixmulShift is mutated by `fixmul` and read by `scaleup`. AS std uses a
+// module-level @lazy variable for the same reason; matching that.
+// @ts-ignore: lazy decorator
+@lazy let __fixmulShift: u64 = 0;
+
+// @ts-ignore: inline
+@inline function fixmul(a: u64, b: u32): u64 {
+  const low = (a & 0xffffffff) * b;
+  const high = (a >> 32) * b + (low >> 32);
+  const overflow = <u32>(high >> 32);
+  const space = clz(overflow);
+  const revspace: u64 = 32 - space;
+  __fixmulShift += revspace;
+  return (
+    ((high << space) | ((low & 0xffffffff) >> revspace)) +
+    (((low << space) >> 31) & 1)
+  );
+}
+
+// @ts-ignore: inline
+@inline function scaledown(significand: u64, exp: i32): f64 {
+  const denom: u64 = 6103515625; // 1e14 * 0x1p-14
+  const scale = reinterpret<f64>(0x3f06849b86a12b9b); // 1e-14 * 0x1p32
+
+  let shift = clz(significand);
+  significand <<= shift;
+  shift = exp - shift;
+
+  for (; exp <= -14; exp += 14) {
+    const q = significand / denom;
+    const r = significand % denom;
+    const s = clz(q);
+    significand = (q << s) + <u64>nearest(scale * <f64>(r << (s - 18)));
+    shift -= s;
+  }
+  const b = <u64>pow5_32(-exp);
+  const q = significand / b;
+  const r = significand % b;
+  const s = clz(q);
+  significand =
+    (q << s) +
+    <u64>(reinterpret<f64>(reinterpret<u64>(<f64>r) + (s << 52)) / <f64>b);
+  shift -= s;
+
+  return NativeMath.scalbn(<f64>significand, <i32>shift);
+}
+
+// @ts-ignore: inline
+@inline function scaleup(significand: u64, exp: i32): f64 {
+  const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;
+  let shift = ctz(significand);
+  significand >>= shift;
+  shift += exp;
+
+  __fixmulShift = shift;
+  for (; exp >= 13; exp -= 13) {
+    significand = fixmul(significand, coeff);
+  }
+  significand = fixmul(significand, <u32>pow5_32(exp));
+  shift = __fixmulShift;
+  return NativeMath.scalbn(<f64>significand, <i32>shift);
+}
+
+/**
+ * Construct an f64 from a u64 mantissa and decimal exponent. Result is
+ * correctly rounded — bit-identical to `f64.parse` for any input the SWAR
+ * float deserializer can pre-parse into this form.
+ *
+ * Caller guarantees the digit run that produced `significand` was already
+ * scanned and validated; this function only handles the value computation,
+ * not the lexing.
+ *
+ * @param significand u64 mantissa (any value from 0 to U64.MAX_VALUE)
+ * @param exp Decimal exponent (e.g. for "12.34" pass 1234 and -2)
+ * @returns The correctly rounded f64, or 0 / Infinity at the extremes.
+ */
+// @ts-ignore: inline
+@inline export function scientific(significand: u64, exp: i32): f64 {
+  if (!significand || exp < -342) return 0;
+  if (exp > 308) return Infinity;
+  let significandf = <f64>significand;
+  if (!exp) return significandf;
+  if (exp > 22 && exp <= 22 + 15) {
+    significandf *= pow10(exp - 22);
+    exp = 22;
+  }
+  if (significand <= 9007199254740991 && abs(exp) <= 22) {
+    if (exp > 0) return significandf * pow10(exp);
+    return significandf / pow10(-exp);
+  } else if (exp < 0) {
+    return scaledown(significand, exp);
+  } else {
+    return scaleup(significand, exp);
+  }
+}

package/assembly/util/simd-int.ts

@@ -0,0 +1,191 @@
+// SIMD (v128) integer-digit parsing kernels over UTF-16 sources.
+//
+// Requires `--enable simd` at compile time. Imported only by the SIMD-mode
+// dispatch paths and dead-code-eliminated when JSON_MODE != SIMD.
+//
+// Algorithm is the Lemire-style narrow-extmul-dot pipeline used by simdjson:
+//
+// 1. `i16x8.sub` subtracts `'0'` from each UTF-16 lane.
+// 2. `i8x16.narrow_i16x8_u` packs two 8-lane u16 vectors into one 16-lane u8
+//    vector. This pack is free in SIMD and is the move that makes the SWAR
+//    packing problem disappear.
+// 3. `i16x8.extmul_low/high_i8x16_u(packed, (10, 1, ...))` multiplies
+//    adjacent bytes by 10 and 1, encoding the first pair-fold step in a
+//    vector op.
+// 4. `i32x4.extadd_pairwise_i16x8_u` pairwise-sums adjacent u16 lanes into
+//    u32 lanes, completing the first pair-fold.
+// 5. `i16x8.narrow_i32x4_u + i32x4.dot_i16x8_s(_, (100, 1, 100, 1, ...))`
+//    folds 4 u32 pair-values into 2 u32 group-values per lane via dot
+//    product.
+
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_30 = i16x8.splat(0x30);
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_09 = i16x8.splat(9);
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const ZERO_I16X8 = i16x8.splat(0);
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const ZERO_I32X4 = i32x4.splat(0);
+
+// Weights for the first pair-fold step (`digit_lo * 10 + digit_hi`).
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const PACK_WEIGHTS_10_1 = i8x16(
+  10,
+  1,
+  10,
+  1,
+  10,
+  1,
+  10,
+  1,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+);
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const PACK_WEIGHTS_10_1_FULL = i8x16(
+  10,
+  1,
+  10,
+  1,
+  10,
+  1,
+  10,
+  1,
+  10,
+  1,
+  10,
+  1,
+  10,
+  1,
+  10,
+  1,
+);
+
+// Weights for the second fold step (`pair_lo * 100 + pair_hi`).
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const PAIR_WEIGHTS_100_1 = i16x8(100, 1, 100, 1, 0, 0, 0, 0);
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const PAIR_WEIGHTS_100_1_FULL = i16x8(100, 1, 100, 1, 100, 1, 100, 1);
+
+/**
+ * Parse eight UTF-16 ASCII digits (16 source bytes) into the 8-digit `u32`
+ * value using SIMD.
+ *
+ * Returns `U32.MAX_VALUE` on any non-digit lane.
+ *
+ * @param srcStart Pointer to 16 source bytes (8 UTF-16 chars).
+ * @returns The parsed 8-digit value, or `U32.MAX_VALUE` on invalid input.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function parse8Digits_SIMD(srcStart: usize): u32 {
+  const block = load<v128>(srcStart);
+  const digits = i16x8.sub(block, SPLAT_30);
+  if (v128.any_true(i16x8.gt_u(digits, SPLAT_09))) return U32.MAX_VALUE;
+  const packed = i8x16.narrow_i16x8_u(digits, ZERO_I16X8);
+  const products = i16x8.extmul_low_i8x16_u(packed, PACK_WEIGHTS_10_1);
+  const pairs = i32x4.extadd_pairwise_i16x8_u(products);
+  const pairs16 = i16x8.narrow_i32x4_u(pairs, ZERO_I32X4);
+  const groups = i32x4.dot_i16x8_s(pairs16, PAIR_WEIGHTS_100_1);
+  const lo = i32x4.extract_lane(groups, 0);
+  const hi = i32x4.extract_lane(groups, 1);
+  return <u32>lo * 10_000 + <u32>hi;
+}
+
+/**
+ * Same as {@link parse8Digits_SIMD} but with the validation step removed.
+ * Used in consume-to-end paths.
+ *
+ * @param srcStart Pointer to 16 source bytes (8 UTF-16 chars).
+ * @returns The parsed 8-digit value.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function parse8Digits_SIMD_Unsafe(srcStart: usize): u32 {
+  const block = load<v128>(srcStart);
+  const digits = i16x8.sub(block, SPLAT_30);
+  const packed = i8x16.narrow_i16x8_u(digits, ZERO_I16X8);
+  const products = i16x8.extmul_low_i8x16_u(packed, PACK_WEIGHTS_10_1);
+  const pairs = i32x4.extadd_pairwise_i16x8_u(products);
+  const pairs16 = i16x8.narrow_i32x4_u(pairs, ZERO_I32X4);
+  const groups = i32x4.dot_i16x8_s(pairs16, PAIR_WEIGHTS_100_1);
+  const lo = i32x4.extract_lane(groups, 0);
+  const hi = i32x4.extract_lane(groups, 1);
+  return <u32>lo * 10_000 + <u32>hi;
+}
+
+/**
+ * Parse sixteen UTF-16 ASCII digits (32 source bytes) into one 16-digit
+ * `u64` value using SIMD.
+ *
+ * Two `v128` loads. Combined OR'd validation across both halves means one
+ * branch covers all 16 digits. Both halves' `extmul`s feed a single dot
+ * product, producing 4 four-digit groups that the final parallel-pair
+ * scalar combine merges.
+ *
+ * Returns `U64.MAX_VALUE` on any non-digit lane.
+ *
+ * @param srcStart Pointer to 32 source bytes (16 UTF-16 chars).
+ * @returns The parsed 16-digit value, or `U64.MAX_VALUE` on invalid input.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function parse16Digits_SIMD(srcStart: usize): u64 {
+  const block0 = load<v128>(srcStart);
+  const block1 = load<v128>(srcStart, 16);
+
+  const digits0 = i16x8.sub(block0, SPLAT_30);
+  const digits1 = i16x8.sub(block1, SPLAT_30);
+
+  const bad0 = i16x8.gt_u(digits0, SPLAT_09);
+  const bad1 = i16x8.gt_u(digits1, SPLAT_09);
+  if (v128.any_true(v128.or(bad0, bad1))) return U64.MAX_VALUE;
+
+  const packed = i8x16.narrow_i16x8_u(digits0, digits1);
+  const products_lo = i16x8.extmul_low_i8x16_u(packed, PACK_WEIGHTS_10_1_FULL);
+  const products_hi = i16x8.extmul_high_i8x16_u(packed, PACK_WEIGHTS_10_1_FULL);
+  const pairs_lo = i32x4.extadd_pairwise_i16x8_u(products_lo);
+  const pairs_hi = i32x4.extadd_pairwise_i16x8_u(products_hi);
+  const pairs16 = i16x8.narrow_i32x4_u(pairs_lo, pairs_hi);
+  const groups = i32x4.dot_i16x8_s(pairs16, PAIR_WEIGHTS_100_1_FULL);
+
+  const g0 = i32x4.extract_lane(groups, 0);
+  const g1 = i32x4.extract_lane(groups, 1);
+  const g2 = i32x4.extract_lane(groups, 2);
+  const g3 = i32x4.extract_lane(groups, 3);
+  const pair01 = <u64>g0 * 10_000 + <u64>g1;
+  const pair23 = <u64>g2 * 10_000 + <u64>g3;
+  return pair01 * 100_000_000 + pair23;
+}
+
+/**
+ * Same as {@link parse16Digits_SIMD} but with the validation step removed.
+ * Used in consume-to-end paths.
+ *
+ * @param srcStart Pointer to 32 source bytes (16 UTF-16 chars).
+ * @returns The parsed 16-digit value.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function parse16Digits_SIMD_Unsafe(srcStart: usize): u64 {
+  const block0 = load<v128>(srcStart);
+  const block1 = load<v128>(srcStart, 16);
+  const digits0 = i16x8.sub(block0, SPLAT_30);
+  const digits1 = i16x8.sub(block1, SPLAT_30);
+  const packed = i8x16.narrow_i16x8_u(digits0, digits1);
+  const products_lo = i16x8.extmul_low_i8x16_u(packed, PACK_WEIGHTS_10_1_FULL);
+  const products_hi = i16x8.extmul_high_i8x16_u(packed, PACK_WEIGHTS_10_1_FULL);
+  const pairs_lo = i32x4.extadd_pairwise_i16x8_u(products_lo);
+  const pairs_hi = i32x4.extadd_pairwise_i16x8_u(products_hi);
+  const pairs16 = i16x8.narrow_i32x4_u(pairs_lo, pairs_hi);
+  const groups = i32x4.dot_i16x8_s(pairs16, PAIR_WEIGHTS_100_1_FULL);
+  const g0 = i32x4.extract_lane(groups, 0);
+  const g1 = i32x4.extract_lane(groups, 1);
+  const g2 = i32x4.extract_lane(groups, 2);
+  const g3 = i32x4.extract_lane(groups, 3);
+  const pair01 = <u64>g0 * 10_000 + <u64>g1;
+  const pair23 = <u64>g2 * 10_000 + <u64>g3;
+  return pair01 * 100_000_000 + pair23;
+}

package/assembly/util/snp.ts

@@ -7,7 +7,10 @@ import { POW_TEN_TABLE_32, POW_TEN_TABLE_64 } from "../globals/tables";
 import { atoi } from "./atoi";
 
 // @ts-ignore: Decorator valid here
-@inline export function snp<T extends number>(srcStart: usize, srcEnd: usize): T {
+@inline export function snp<T extends number>(
+  srcStart: usize,
+  srcEnd: usize,
+): T {
   // @ts-ignore: type
   let val: T = 0;
   let char = load<u16>(srcStart) - 48;

package/assembly/util/swar-int.ts

@@ -0,0 +1,248 @@
+// 4-digit lane masks
+const LANE_LO_4: u64 = 0x00ff_00ff_00ff_00ff;
+const ZERO_4: u64 = 0x0030_0030_0030_0030;
+const RANGE_ADD_4: u64 = 0x0006_0006_0006_0006;
+const RANGE_MASK_4: u64 = 0xfff0_fff0_fff0_fff0;
+
+// 32-bit-pair masks used by the pair-multiply fold
+const U32_LO_PAIR: u64 = 0x0000_ffff_0000_ffff;
+
+/**
+ * Magic multiplier for the 4-digit final combine.
+ *
+ * With `pairs = (cd << 32) | ab` where `ab` and `cd` are two-digit fold
+ * results each in `[0, 99]`, multiplying by this constant places
+ * `ab*100 + cd` in the high 32 bits via the u64 multiplication's cross-term.
+ * Taking the high 32 yields the 4-digit value `1000a + 100b + 10c + d`.
+ */
+const FINAL_4_MAGIC: u64 = 0x0000_0064_0000_0001;
+
+/**
+ * Parse four UTF-16 ASCII digits in a `u64` into the 4-digit value, using
+ * the baseline scalar combine. Kept for reference and head-to-head benches.
+ *
+ * Returns `U32.MAX_VALUE` on any non-digit lane.
+ *
+ * @param block Four UTF-16 code units packed into a `u64`.
+ * @returns The parsed 4-digit value, or `U32.MAX_VALUE` on invalid input.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function parse4Digits_Baseline(block: u64): u32 {
+  const digits = (block & LANE_LO_4) - ZERO_4;
+  if (((digits | (digits + RANGE_ADD_4)) & RANGE_MASK_4) != 0) {
+    return U32.MAX_VALUE;
+  }
+  return <u32>(
+    (<u32>(digits & 0xffff) * 1000 +
+      <u32>((digits >> 16) & 0xffff) * 100 +
+      <u32>((digits >> 32) & 0xffff) * 10 +
+      <u32>(digits >> 48))
+  );
+}
+
+/**
+ * Parse four UTF-16 ASCII digits into the 4-digit value.
+ *
+ * Three Lemire-inspired op reductions vs the baseline:
+ *
+ * 1. Skip the initial `& LANE_LO_4` mask. For valid UTF-16 ASCII the high
+ *    byte of each lane is already 0, so the AND is redundant. Validation
+ *    runs before any multiply and rejects every input where dropping the
+ *    AND would produce inter-lane carry corruption.
+ * 2. Mul-then-mask pair fold: apply `digits * 10 + (digits >> 16)` to the
+ *    whole `u64` and mask after. Saves one AND vs the lane-isolated form.
+ * 3. Magic-multiplier final combine: see {@link FINAL_4_MAGIC}.
+ *
+ * Returns `U32.MAX_VALUE` on any non-digit lane.
+ *
+ * @param block Four UTF-16 code units packed into a `u64`.
+ * @returns The parsed 4-digit value, or `U32.MAX_VALUE` on invalid input.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function parse4Digits_PairMul(block: u64): u32 {
+  const digits = block - ZERO_4;
+  if (((digits | (digits + RANGE_ADD_4)) & RANGE_MASK_4) != 0) {
+    return U32.MAX_VALUE;
+  }
+  const pairs = (digits * 10 + (digits >> 16)) & U32_LO_PAIR;
+  return <u32>((pairs * FINAL_4_MAGIC) >> 32);
+}
+
+/**
+ * Same as {@link parse4Digits_PairMul} but with the validation step removed.
+ * Used in consume-to-end paths where the caller has already bounded the
+ * digit range, so per-stride validation isn't needed.
+ *
+ * @param block Four UTF-16 code units packed into a `u64`.
+ * @returns The parsed 4-digit value.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function parse4Digits_PairMul_Unsafe(block: u64): u32 {
+  const digits = block - ZERO_4;
+  const pairs = (digits * 10 + (digits >> 16)) & U32_LO_PAIR;
+  return <u32>((pairs * FINAL_4_MAGIC) >> 32);
+}
+
+/**
+ * Parse eight UTF-16 ASCII digits across two `u64` blocks into one 8-digit
+ * `u32` value.
+ *
+ * Caller passes two consecutive `u64` loads (16 source bytes). Validates
+ * both halves with one combined check, then folds each half via
+ * {@link parse4Digits_PairMul} and combines as `lo * 10_000 + hi`.
+ *
+ * Returns `U32.MAX_VALUE` on any non-digit lane.
+ *
+ * @param lo The first `u64`, four UTF-16 code units.
+ * @param hi The second `u64`, four UTF-16 code units.
+ * @returns The parsed 8-digit value, or `U32.MAX_VALUE` on invalid input.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function parse8Digits_PairMul(lo: u64, hi: u64): u32 {
+  const loDigits = lo - ZERO_4;
+  const hiDigits = hi - ZERO_4;
+  const bad =
+    (loDigits |
+      (loDigits + RANGE_ADD_4) |
+      hiDigits |
+      (hiDigits + RANGE_ADD_4)) &
+    RANGE_MASK_4;
+  if (bad != 0) return U32.MAX_VALUE;
+
+  const loPairs = (loDigits * 10 + (loDigits >> 16)) & U32_LO_PAIR;
+  const hiPairs = (hiDigits * 10 + (hiDigits >> 16)) & U32_LO_PAIR;
+  const loVal = <u32>((loPairs * FINAL_4_MAGIC) >> 32);
+  const hiVal = <u32>((hiPairs * FINAL_4_MAGIC) >> 32);
+  return loVal * 10_000 + hiVal;
+}
+
+/**
+ * Same as {@link parse8Digits_PairMul} but with the validation step removed.
+ * Used in consume-to-end paths.
+ *
+ * @param lo The first `u64`, four UTF-16 code units.
+ * @param hi The second `u64`, four UTF-16 code units.
+ * @returns The parsed 8-digit value.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function parse8Digits_PairMul_Unsafe(lo: u64, hi: u64): u32 {
+  const loDigits = lo - ZERO_4;
+  const hiDigits = hi - ZERO_4;
+  const loPairs = (loDigits * 10 + (loDigits >> 16)) & U32_LO_PAIR;
+  const hiPairs = (hiDigits * 10 + (hiDigits >> 16)) & U32_LO_PAIR;
+  const loVal = <u32>((loPairs * FINAL_4_MAGIC) >> 32);
+  const hiVal = <u32>((hiPairs * FINAL_4_MAGIC) >> 32);
+  return loVal * 10_000 + hiVal;
+}
+
+/**
+ * Non-digit lane mask for a `u64` holding four UTF-16 code units. Returns a
+ * `u64` with bit 7 of each non-digit lane set, or 0 if all four lanes are
+ * valid ASCII `'0'..'9'`. Lets a caller find the digit-run boundary in one
+ * SWAR step:
+ *
+ * ```ts
+ * const mask = nonDigitMask4(block);
+ * if (mask == 0) { /* all valid *\/ }
+ * else { const laneIdx = ctz(mask) >> 3; /* first bad byte *\/ }
+ * ```
+ *
+ * @param block Four UTF-16 code units packed into a `u64`.
+ * @returns A mask with non-digit lanes flagged in their high bit, or 0.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function nonDigitMask4(block: u64): u64 {
+  const digits = (block & LANE_LO_4) - ZERO_4;
+  return (digits | (digits + RANGE_ADD_4)) & RANGE_MASK_4;
+}
+
+/**
+ * Parse sixteen UTF-16 ASCII digits (32 source bytes) into one 16-digit
+ * `u64` value.
+ *
+ * Mirrors the SIMD 16-digit parser's shape using pure SWAR. Four `u64`
+ * loads, one combined validation mask, four independent 4-digit folds (each
+ * a chance for the engine to issue them in parallel), then a parallel-pair
+ * tree combine.
+ *
+ * Best for long-integer atoi: one branch covers 16 digits, the four folds
+ * have no cross-dependencies, and the final combine forms two independent
+ * 8-digit values that merge in one mul-add.
+ *
+ * Returns `U64.MAX_VALUE` on any non-digit lane.
+ *
+ * @param srcStart Pointer to the start of 32 source bytes (16 UTF-16 chars).
+ * @returns The parsed 16-digit value, or `U64.MAX_VALUE` on invalid input.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function parse16Digits_SWAR(srcStart: usize): u64 {
+  const b0 = load<u64>(srcStart);
+  const b1 = load<u64>(srcStart, 8);
+  const b2 = load<u64>(srcStart, 16);
+  const b3 = load<u64>(srcStart, 24);
+
+  const d0 = b0 - ZERO_4;
+  const d1 = b1 - ZERO_4;
+  const d2 = b2 - ZERO_4;
+  const d3 = b3 - ZERO_4;
+
+  const bad =
+    (d0 |
+      (d0 + RANGE_ADD_4) |
+      d1 |
+      (d1 + RANGE_ADD_4) |
+      d2 |
+      (d2 + RANGE_ADD_4) |
+      d3 |
+      (d3 + RANGE_ADD_4)) &
+    RANGE_MASK_4;
+  if (bad != 0) return U64.MAX_VALUE;
+
+  const p0 = (d0 * 10 + (d0 >> 16)) & U32_LO_PAIR;
+  const p1 = (d1 * 10 + (d1 >> 16)) & U32_LO_PAIR;
+  const p2 = (d2 * 10 + (d2 >> 16)) & U32_LO_PAIR;
+  const p3 = (d3 * 10 + (d3 >> 16)) & U32_LO_PAIR;
+
+  const v0 = <u32>((p0 * FINAL_4_MAGIC) >> 32);
+  const v1 = <u32>((p1 * FINAL_4_MAGIC) >> 32);
+  const v2 = <u32>((p2 * FINAL_4_MAGIC) >> 32);
+  const v3 = <u32>((p3 * FINAL_4_MAGIC) >> 32);
+
+  const pair01 = <u64>v0 * 10_000 + <u64>v1;
+  const pair23 = <u64>v2 * 10_000 + <u64>v3;
+  return pair01 * 100_000_000 + pair23;
+}
+
+/**
+ * Same as {@link parse16Digits_SWAR} but with the validation step removed.
+ * Used in consume-to-end paths.
+ *
+ * @param srcStart Pointer to the start of 32 source bytes (16 UTF-16 chars).
+ * @returns The parsed 16-digit value.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function parse16Digits_SWAR_Unsafe(srcStart: usize): u64 {
+  const b0 = load<u64>(srcStart);
+  const b1 = load<u64>(srcStart, 8);
+  const b2 = load<u64>(srcStart, 16);
+  const b3 = load<u64>(srcStart, 24);
+
+  const d0 = b0 - ZERO_4;
+  const d1 = b1 - ZERO_4;
+  const d2 = b2 - ZERO_4;
+  const d3 = b3 - ZERO_4;
+
+  const p0 = (d0 * 10 + (d0 >> 16)) & U32_LO_PAIR;
+  const p1 = (d1 * 10 + (d1 >> 16)) & U32_LO_PAIR;
+  const p2 = (d2 * 10 + (d2 >> 16)) & U32_LO_PAIR;
+  const p3 = (d3 * 10 + (d3 >> 16)) & U32_LO_PAIR;
+
+  const v0 = <u32>((p0 * FINAL_4_MAGIC) >> 32);
+  const v1 = <u32>((p1 * FINAL_4_MAGIC) >> 32);
+  const v2 = <u32>((p2 * FINAL_4_MAGIC) >> 32);
+  const v3 = <u32>((p3 * FINAL_4_MAGIC) >> 32);
+
+  const pair01 = <u64>v0 * 10_000 + <u64>v1;
+  const pair23 = <u64>v2 * 10_000 + <u64>v3;
+  return pair01 * 100_000_000 + pair23;
+}

package/assembly/util/swar.ts

@@ -23,7 +23,12 @@
   // (c & 0xF) + 9 * (c >> 6)
   block = (block & 0x0f000f000f000f) + ((block >> 6) & 0x03000300030003) * 9;
 
-  return <u16>(((block >> 0) << 12) | ((block >> 16) << 8) | ((block >> 32) << 4) | (block >> 48));
+  return <u16>(
+    (((block >> 0) << 12) |
+      ((block >> 16) << 8) |
+      ((block >> 32) << 4) |
+      (block >> 48))
+  );
 }
 
 /**
@@ -48,9 +53,14 @@
  */
 // @ts-expect-error: @inline is a valid decorator
 @inline export function u16_to_hex4_swar(code: u16): u64 {
-  let block = (<u64>((code >> 12) & 0xf)) | ((<u64>((code >> 8) & 0xf)) << 16) | ((<u64>((code >> 4) & 0xf)) << 32) | ((<u64>(code & 0xf)) << 48);
+  let block =
+    (<u64>((code >> 12) & 0xf)) |
+    ((<u64>((code >> 8) & 0xf)) << 16) |
+    ((<u64>((code >> 4) & 0xf)) << 32) |
+    ((<u64>(code & 0xf)) << 48);
 
-  const alphaMask = ((block + 0x0006_0006_0006_0006) >> 4) & 0x0001_0001_0001_0001;
+  const alphaMask =
+    ((block + 0x0006_0006_0006_0006) >> 4) & 0x0001_0001_0001_0001;
   block += 0x0030_0030_0030_0030 + alphaMask * 39;
   return block;
 }

package/lib/as-bs.ts

@@ -21,7 +21,7 @@ export namespace bs {
   export let offset: usize = buffer;
 
   /** Byte length of the buffer. */
-  let bufferSize: usize = MIN_BUFFER_SIZE;
+  export let bufferSize: usize = MIN_BUFFER_SIZE;
 
   /** Proposed size of output */
   export let stackSize: usize = 0;
@@ -104,6 +104,19 @@ export namespace bs {
     pauseStackSizes.length = index;
   }
 
+  /**
+   * Resets the buffer to a clean, empty state. Call this after a throw aborts a
+   * serialize/deserialize op mid-flight: a partial run can leave `offset`
+   * advanced and the pause stacks non-empty, which would corrupt the next op.
+   */
+  // @ts-expect-error: @inline is a valid decorator
+  @inline export function reset(): void {
+    offset = buffer;
+    stackSize = 0;
+    pauseOffsets.length = 0;
+    pauseStackSizes.length = 0;
+  }
+
   /**
    * Proposes that the buffer size is should be greater than or equal to the proposed size.
    * If necessary, reallocates the buffer to the exact new size.
@@ -180,7 +193,8 @@ export namespace bs {
       memory.copy(_out, buffer, len);
       return changetype<T>(_out);
     } else {
-      const pauseOffset = buffer + unchecked(pauseOffsets[pauseOffsets.length - 1]);
+      const pauseOffset =
+        buffer + unchecked(pauseOffsets[pauseOffsets.length - 1]);
       const len = offset - pauseOffset;
       // @ts-expect-error: __new is a runtime builtin
       const _out = __new(len, idof<T>());
@@ -330,15 +344,22 @@ export namespace sc {
   // @ts-expect-error: JSON_CACHE may not be defined. If so, it will default to false.
   export const CACHE_ENABLED: bool = isDefined(JSON_CACHE) ? JSON_CACHE : false;
   // @ts-expect-error: JSON_CACHE_SIZE may not be defined. If so, it will default to 1MB.
-  export const CACHE_BYTES: usize = isDefined(JSON_CACHE_SIZE) ? <usize>JSON_CACHE_SIZE : 1 << 20;
+  export const CACHE_BYTES: usize = isDefined(JSON_CACHE_SIZE)
+    ? <usize>JSON_CACHE_SIZE
+    : 1 << 20;
   /** Minimum serialized length to cache - smaller outputs aren't worth caching */
   export const MIN_CACHE_LEN: usize = 128;
   /** Size of the circular arena buffer for cached strings */
-  export const ARENA_SIZE: usize = CACHE_BYTES >= MIN_CACHE_LEN ? CACHE_BYTES : MIN_CACHE_LEN;
+  export const ARENA_SIZE: usize =
+    CACHE_BYTES >= MIN_CACHE_LEN ? CACHE_BYTES : MIN_CACHE_LEN;
 
   /** Number of cache slots (power of 2 for efficient masking). Set to 0 when caching disabled. */
-  const CACHE_SIZE_BASE: i32 = CACHE_ENABLED ? i32(ARENA_SIZE >> 10 >= 1 ? ARENA_SIZE >> 10 : 1) : 0;
-  export const CACHE_SIZE: usize = CACHE_ENABLED ? <usize>(1 << (32 - clz<i32>(CACHE_SIZE_BASE - 1))) : 0;
+  const CACHE_SIZE_BASE: i32 = CACHE_ENABLED
+    ? i32(ARENA_SIZE >> 10 >= 1 ? ARENA_SIZE >> 10 : 1)
+    : 0;
+  export const CACHE_SIZE: usize = CACHE_ENABLED
+    ? <usize>(1 << (32 - clz<i32>(CACHE_SIZE_BASE - 1)))
+    : 0;
   /** Bitmask for fast modulo operation on cache index */
   export const CACHE_MASK: usize = CACHE_SIZE > 0 ? CACHE_SIZE - 1 : 0;