json-as 1.3.7 → 1.3.9

package/assembly/serialize/index/typedarray.ts

@@ -3,11 +3,11 @@ import { JSON } from "../..";
 export {
   serializeArrayBufferUnsafe,
   serializeTypedArray,
-} from "../simple/typedarray";
+} from "../naive/typedarray";
 import {
   serializeArrayBufferUnsafe,
   serializeTypedArray,
-} from "../simple/typedarray";
+} from "../naive/typedarray";
 
 
 @inline export function serializeDynamic(type: u16, data: usize): void {
@@ -73,12 +73,3 @@ import {
     }
   }
 }
-
-
-@inline export function serializeArrayBuffer(data: ArrayBuffer): void {
-  const dataStart = changetype<usize>(data);
-  serializeArrayBufferUnsafe(
-    dataStart,
-    changetype<OBJECT>(dataStart - TOTAL_OVERHEAD).rtSize,
-  );
-}

package/assembly/serialize/index.ts

@@ -11,3 +11,4 @@ export * from "./index/set";
 export * from "./index/staticarray";
 export * from "./index/string";
 export * from "./index/struct";
+export * from "./index/typedarray";

package/assembly/serialize/{simple → naive}/array.ts

@@ -5,6 +5,10 @@ import { serializeBoolUnsafe } from "./bool";
 import { serializeFloat32Unsafe, serializeFloat64Unsafe } from "./float";
 import { serializeIntegerUnsafe } from "./integer";
 import { serializeString } from "../index/string";
+import {
+  dragonbox_f32_buffered,
+  dragonbox_f64_buffered,
+} from "../../util/dragonbox";
 
 
 @inline
@@ -50,6 +54,16 @@ function serializeArrayElement<T>(value: T): void {
     else serializeFloat64Unsafe(<f64>value);
     return;
   }
+  if (isManaged<T>() || isReference<T>()) {
+    // Preserve runtime custom serializers for subclass instances stored in
+    // parent-typed arrays before falling back to the static dispatcher.
+    // @ts-ignore: transform-defined at runtime when present
+    if (isDefined(value.__SERIALIZE_CUSTOM)) {
+      // @ts-ignore: transform-defined at runtime when present
+      value.__SERIALIZE_CUSTOM();
+      return;
+    }
+  }
   JSON.__serialize<T>(value);
 }
 
@@ -167,6 +181,69 @@ function serializeU8ArrayFast(src: u8[]): void {
   store<u16>(bs.offset - 2, BRACKET_RIGHT);
 }
 
+// Specialized float-array serializer: dragonbox + trailing comma in a
+// uniform per-iteration body, then overwrite the final comma with `]`. The
+// generic dispatcher splits the loop into "N-1 elements with comma, then
+// last element without, then `]`" — the branch on each `i < end` check
+// stalls the loop's tight bs.offset advance pattern. This variant runs the
+// same number of stores per iteration (dragonbox output + COMMA), but the
+// uniform loop body inlines better and the trailing `]` is a single fixed
+// overwrite outside the loop.
+function serializeF64ArrayFast(src: f64[]): void {
+  const len = src.length;
+  // Worst case per element: ~24 chars for f64 + comma = 50 bytes.
+  // Slight over-reserve (66) matches the existing `reservePrimitiveArray`
+  // budget and keeps a safety margin for any NaN/Inf spelling.
+  bs.proposeSize(4 + <u32>len * 66);
+  store<u16>(bs.offset, BRACKET_LEFT);
+  bs.offset += 2;
+  if (len == 0) {
+    store<u16>(bs.offset, BRACKET_RIGHT);
+    bs.offset += 2;
+    return;
+  }
+
+  // Hoist `bs.offset` into a local so the loop body has a single
+  // monotonically-advancing pointer instead of two reads + two writes back
+  // to the global per iteration.
+  const dataStart = src.dataStart;
+  let offset = bs.offset;
+  for (let i: i32 = 0; i < len; i++) {
+    const v = load<f64>(dataStart + ((<usize>i) << 3));
+    const size = dragonbox_f64_buffered(offset, v) << 1;
+    store<u16>(offset + size, COMMA);
+    offset += size + 2;
+  }
+  // Overwrite the final trailing comma with `]`.
+  store<u16>(offset - 2, BRACKET_RIGHT);
+  bs.offset = offset;
+}
+
+function serializeF32ArrayFast(src: f32[]): void {
+  const len = src.length;
+  // Worst case for f32 is ~16 chars + comma = ~34 bytes; mirror the budget
+  // used by `reservePrimitiveArray`.
+  bs.proposeSize(4 + <u32>len * 34);
+  store<u16>(bs.offset, BRACKET_LEFT);
+  bs.offset += 2;
+  if (len == 0) {
+    store<u16>(bs.offset, BRACKET_RIGHT);
+    bs.offset += 2;
+    return;
+  }
+
+  const dataStart = src.dataStart;
+  let offset = bs.offset;
+  for (let i: i32 = 0; i < len; i++) {
+    const v = load<f32>(dataStart + ((<usize>i) << 2));
+    const size = dragonbox_f32_buffered(offset, v) << 1;
+    store<u16>(offset + size, COMMA);
+    offset += size + 2;
+  }
+  store<u16>(offset - 2, BRACKET_RIGHT);
+  bs.offset = offset;
+}
+
 function serializeI8ArrayFast(src: i8[]): void {
   const len = src.length;
   // Worst case: every element is `-DDD,` = 5 chars = 10 bytes; plus 4 for `[]`.
@@ -226,6 +303,16 @@ export function serializeArray<T extends any[]>(src: T): void {
     serializeI8ArrayFast(changetype<i8[]>(src));
     return;
   }
+  if (isFloat<valueof<T>>() && sizeof<valueof<T>>() == 8) {
+    // @ts-expect-error: T is f64[]
+    serializeF64ArrayFast(changetype<f64[]>(src));
+    return;
+  }
+  if (isFloat<valueof<T>>() && sizeof<valueof<T>>() == 4) {
+    // @ts-expect-error: T is f32[]
+    serializeF32ArrayFast(changetype<f32[]>(src));
+    return;
+  }
 
   const len = src.length;
   const end = len - 1;

package/assembly/serialize/{simple → naive}/string.ts

@@ -16,7 +16,7 @@ import { serializeStruct } from "./struct";
  * @returns void
  */
 // @ts-ignore: inline
-@inline export function serializeString(src: string): void {
+@inline export function serializeString_NAIVE(src: string): void {
   const srcSize = bytes(src);
   bs.proposeSize(srcSize + 4);
   let srcPtr = changetype<usize>(src);

package/assembly/serialize/swar/string.ts

@@ -174,132 +174,6 @@ export function serializeString_SWAR(src: string): void {
   bs.offset += 2;
 }
 
-export function serializeString_SWAR_ExperimentalTableEscapes(
-  src: string,
-): void {
-  let srcStart = changetype<usize>(src);
-  const srcSize = changetype<OBJECT>(srcStart - TOTAL_OVERHEAD).rtSize;
-  const srcEnd = srcStart + srcSize;
-  const srcEnd8 = srcEnd - 8;
-
-  bs.proposeSize(srcSize + 4);
-  store<u16>(bs.offset, 34); // "
-  bs.offset += 2;
-
-  while (srcStart < srcEnd8) {
-    const block = load<u64>(srcStart);
-    let mask = detect_escapable_u64_swar_safe(block);
-    store<u64>(bs.offset, block);
-
-    if (mask === 0) {
-      srcStart += 8;
-      bs.offset += 8;
-      continue;
-    }
-
-    do {
-      const laneIdx = usize(ctz(mask) >> 3);
-      const srcIdx = srcStart + laneIdx;
-      // Even (0 2 4 6) -> Confirmed ASCII Escape
-      // Odd (1 3 5 7) -> Possibly a Unicode code unit or surrogate
-      if ((laneIdx & 1) === 0) {
-        mask &= mask - 1;
-        const code = load<u16>(srcIdx);
-        const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + (code << 2));
-
-        if ((escaped & 0xffff) != BACK_SLASH) {
-          bs.growSize(10);
-          const dstIdx = bs.offset + laneIdx;
-          store<u64>(dstIdx, U00_MARKER);
-          store<u32>(dstIdx, escaped, 8);
-          store<u64>(dstIdx, load<u64>(srcIdx, 2), 12);
-          bs.offset += 10;
-        } else {
-          bs.growSize(2);
-          const dstIdx = bs.offset + laneIdx;
-          store<u32>(dstIdx, escaped);
-          store<u64>(dstIdx, load<u64>(srcIdx, 2), 4);
-          bs.offset += 2;
-        }
-        continue;
-      }
-      mask &= mask - 1;
-
-      const code = load<u16>(srcIdx - 1);
-      if (code < 0xd800 || code > 0xdfff) continue;
-
-      if (code <= 0xdbff && srcIdx + 2 < srcEnd) {
-        const next = load<u16>(srcIdx, 1);
-        if (next >= 0xdc00 && next <= 0xdfff) {
-          // paired surrogate
-          // mask &= ~(0xFF << ((laneIdx+2) << 3));
-          mask &= mask - 1;
-          continue;
-        }
-      }
-
-      bs.growSize(10);
-
-      // unpaired high/low surrogate
-      const dstIdx = bs.offset + laneIdx - 1;
-      store<u32>(dstIdx, U_MARKER); // \u
-      store<u64>(dstIdx, u16_to_hex4_swar(code), 4);
-      store<u64>(dstIdx, load<u64>(srcIdx, 1), 12);
-      bs.offset += 10;
-    } while (mask !== 0);
-
-    srcStart += 8;
-    bs.offset += 8;
-  }
-
-  while (srcStart <= srcEnd - 2) {
-    const code = load<u16>(srcStart);
-
-    if (code == BACK_SLASH || code == QUOTE || code < 32) {
-      const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + (code << 2));
-      if ((escaped & 0xffff) != BACK_SLASH) {
-        bs.growSize(10);
-        store<u64>(bs.offset, U00_MARKER);
-        store<u32>(bs.offset, escaped, 8);
-        bs.offset += 12;
-      } else {
-        bs.growSize(2);
-        store<u32>(bs.offset, escaped);
-        bs.offset += 4;
-      }
-      srcStart += 2;
-      continue;
-    }
-
-    if (code < 0xd800 || code > 0xdfff) {
-      store<u16>(bs.offset, code);
-      bs.offset += 2;
-      srcStart += 2;
-      continue;
-    }
-
-    if (code <= 0xdbff && srcStart + 2 <= srcEnd - 2) {
-      const next = load<u16>(srcStart, 2);
-      if (next >= 0xdc00 && next <= 0xdfff) {
-        // valid surrogate pair
-        store<u16>(bs.offset, code);
-        store<u16>(bs.offset + 2, next);
-        bs.offset += 4;
-        srcStart += 4;
-        continue;
-      }
-    }
-
-    // unpaired high/low surrogate
-    write_u_escape(code);
-    srcStart += 2;
-    continue;
-  }
-
-  store<u16>(bs.offset, 34); // "
-  bs.offset += 2;
-}
-
 // @ts-expect-error: @inline is a valid decorator
 @inline function write_u_escape(code: u16): void {
   bs.growSize(10);
@@ -326,16 +200,3 @@ export function serializeString_SWAR_ExperimentalTableEscapes(
     0x8000_8000_8000_8000;
   return (ascii_mask & (~hi_mask >> 8)) | hi_mask;
 }
-
-// @ts-expect-error: @inline is a valid decorator
-@inline export function detect_escapable_u64_swar_unsafe(block: u64): u64 {
-  const lo = block & 0x00ff_00ff_00ff_00ff;
-  const loSafe = lo | 0x0100_0100_0100_0100;
-  const ascii_mask =
-    ((loSafe - 0x0020_0020_0020_0020) | // lt 0x20
-      ((loSafe ^ 0x0022_0022_0022_0022) - 0x0001_0001_0001_0001) | // eq 0x22
-      ((loSafe ^ 0x005c_005c_005c_005c) - 0x0001_0001_0001_0001)) & // eq 0x5C
-    (0x0080_0080_0080_0080 & ~lo); // replace each lane with 0x80
-  const hi = block & 0xff00_ff00_ff00_ff00; // add possible non-ascii code units
-  return ascii_mask | hi;
-}

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;
@@ -572,7 +573,11 @@ function dragonboxCoreF32(buffer: usize, value: f32): u32 {
     reinterpret<u32>(value) & 0x7fffff,
     (reinterpret<u32>(value) >>> 23) & 0xff,
   );
-  let len = itoa_buffered<u32>(buffer + ((<usize>sign) << 1), digits);
+  // 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);
 }
 
@@ -588,7 +593,7 @@ function dragonboxCoreF64(buffer: usize, value: f64): u32 {
     bits & 0x000fffffffffffff,
     <i32>((bits >>> 52) & 0x7ff),
   );
-  let len = itoa_buffered<u64>(buffer + ((<usize>sign) << 1), digits);
+  let len = itoaU64(buffer + ((<usize>sign) << 1), digits);
   return <u32>(prettify(buffer + ((<usize>sign) << 1), len, _dbK) + sign);
 }
 
@@ -615,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);
 }
 
@@ -641,6 +647,7 @@ 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);
 }
 

package/assembly/util/itoa-fast.ts

@@ -1,20 +1,31 @@
-// Fast integer -> UTF-16 stringification (jeaiii-style).
+// Fast integer -> UTF-16 stringification.
 //
-// Background: AS std's `itoa_buffered` runs `decimalCount32` (a width
-// classifier) then `utoa32_dec_lut` (a backward-writing div-by-10000
-// loop). On wasm/V8 the function-call overhead between those steps shows
-// up clearly for short widths (2-4 digits) where the per-element work is
-// otherwise tiny.
+// 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:
 //
-// This module ports the jeaiii (James Edward Anhalt III) algorithm:
-//   - One `@inline` function per signed/unsigned u32/u64.
-//   - Width-ladder of `if (v < 10^k)` checks emits digits forward in a
-//     single pass; the same comparisons that would have driven a separate
-//     `decimalCount` are reused as the dispatch.
-//   - Each digit-pair is written as a single `store<u32>` from a 400-byte
-//     LUT (`DIGIT_PAIRS_UTF16`) keyed on `value % 100`.
-//   - All `/` and `%` are by compile-time constants (10 / 100 / 10000 /
-//     10^8) so the wasm tier lowers them to multiply-shift.
+//   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`.
 
@@ -43,7 +54,7 @@ function initPairs(): void {
 }
 
 /**
- * jeaiii-style u32 -> UTF-16 stringification, forward write.
+ * 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).
@@ -169,7 +180,7 @@ function initPairs(): void {
 }
 
 /**
- * jeaiii-style u64 -> UTF-16 stringification.
+ * 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.
@@ -224,7 +235,7 @@ function initPairs(): void {
       store<u16>(buf, 0x2d); // '-'
       return 1 + itoaU64(buf + 2, <u64>-v);
     }
-    return itoaU64(buf, <u64>v);
+    return itoaU64(buf, <u64>value);
   }
   return itoaU64(buf, <u64>value);
 }

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;
+}

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/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.