json-as 1.3.8 → 1.4.0

package/assembly/serialize/index/object.ts

@@ -2,11 +2,10 @@ import { bs } from "../../../lib/as-bs";
 import { JSON } from "../..";
 import { BRACE_LEFT, BRACE_RIGHT, COLON, COMMA } from "../../custom/chars";
 import { serializeArbitrary } from "./arbitrary";
-import { serializeString } from "./string";
+import { serializeStringRange } from "../naive/string";
 
 export function serializeObject(src: JSON.Obj): void {
   const srcSize = src.size;
-  const srcEnd = srcSize - 1;
 
   if (srcSize == 0) {
     bs.proposeSize(4);
@@ -15,28 +14,32 @@ export function serializeObject(src: JSON.Obj): void {
     return;
   }
 
-  const keys = src.keys();
-  const values = src.values();
+  const vals = src._vals;
+  const kbuf = changetype<usize>(src._kbuf);
+  const kused = src._kused;
 
   bs.proposeSize(4 + <u32>(srcSize - 1) * 2 + <u32>srcSize * 2);
   store<u16>(bs.offset, BRACE_LEFT);
   bs.offset += 2;
 
-  for (let i = 0; i < srcEnd; i++) {
-    serializeString(unchecked(keys[i]));
+  // Walk the length-prefixed key buffer in lockstep with the values, emitting
+  // each key straight from its slice (no per-key string materialization).
+  let pos = 0;
+  let i = 0;
+  while (pos < kused) {
+    const len = <i32>load<u16>(kbuf + ((<usize>pos) << 1));
+    if (i != 0) {
+      store<u16>(bs.offset, COMMA);
+      bs.offset += 2;
+    }
+    serializeStringRange(kbuf + ((<usize>(pos + 1)) << 1), (<usize>len) << 1);
     store<u16>(bs.offset, COLON);
     bs.offset += 2;
-
-    serializeArbitrary(unchecked(values[i]));
-    store<u16>(bs.offset, COMMA);
-    bs.offset += 2;
+    serializeArbitrary(unchecked(vals[i]));
+    pos += 1 + len;
+    i++;
   }
 
-  serializeString(unchecked(keys[srcEnd]));
-  store<u16>(bs.offset, COLON);
-  bs.offset += 2;
-  serializeArbitrary(unchecked(values[srcEnd]));
-
   store<u16>(bs.offset, BRACE_RIGHT);
   bs.offset += 2;
 }

package/assembly/serialize/naive/string.ts

@@ -17,9 +17,16 @@ import { serializeStruct } from "./struct";
  */
 // @ts-ignore: inline
 @inline export function serializeString_NAIVE(src: string): void {
-  const srcSize = bytes(src);
+  serializeStringRange(changetype<usize>(src), bytes(src));
+}
+
+/**
+ * Serializes a raw UTF-16 range as a quoted, escaped JSON string. Lets callers
+ * (e.g. JSON.Obj key serialization) emit a string straight from a buffer slice
+ * without first materializing a heap `string`.
+ */
+export function serializeStringRange(srcPtr: usize, srcSize: usize): void {
   bs.proposeSize(srcSize + 4);
-  let srcPtr = changetype<usize>(src);
   const srcEnd = srcPtr + srcSize;
 
   store<u16>(bs.offset, QUOTE);

package/assembly/serialize/swar/string.ts

@@ -182,8 +182,7 @@ export function serializeString_SWAR(src: string): void {
   bs.offset += 12;
 }
 
-// @ts-expect-error: @inline is a valid decorator
-@inline export function detect_escapable_u64_swar_safe(block: u64): u64 {
+export function detect_escapable_u64_swar_safe(block: u64): u64 {
   const hi = block & 0xff00_ff00_ff00_ff00;
   const lo = block & 0x00ff_00ff_00ff_00ff;
   // Setting bit 8 of each 16-bit lane (high byte LSB) prevents borrow from a

package/assembly/util/atoi.ts

@@ -3,8 +3,7 @@
  * @param str
  * @returns
  */
-// @ts-ignore: inline
-@inline export function atoi<T>(srcStart: usize, srcEnd: usize): T {
+export function atoi<T>(srcStart: usize, srcEnd: usize): T {
   // @ts-ignore: type
   let val: T = 0;
   if (isSigned<T>()) {

package/assembly/util/dragonbox.ts

@@ -118,8 +118,6 @@ function computeRoundUpShorter32(cache: u64, beta: i32): u32 {
   return (<u32>(cache >>> (39 - beta)) + 1) >>> 1;
 }
 
-
-@inline
 function removeTrailingZeros32(significand: u32): u32 {
   let exponent = 0;
   let r = rotr32(significand * 184254097, 4);
@@ -161,8 +159,6 @@ function checkDivisibilityAndDivideByPow10_32_1(n: u32): u64 {
   return ((<u64>(prod >>> 16)) << 32) | ((prod & 0xffff) < 6554 ? 1 : 0);
 }
 
-
-@inline
 function computeMul64(u: u64, cacheHigh: u64, cacheLow: u64): void {
   const high = umul128_upper64(u, cacheHigh);
 
@@ -187,8 +183,6 @@ function computeMul64(u: u64, cacheHigh: u64, cacheLow: u64): void {
   _dbMulIsInteger = rLow == 0;
 }
 
-
-@inline
 function computeMulParity64(
   twoF: u64,
   cacheHigh: u64,
@@ -233,8 +227,6 @@ function computeRoundUpShorter64(cacheHigh: u64, beta: i32): u64 {
   return ((cacheHigh >>> (10 - beta)) + 1) >>> 1;
 }
 
-
-@inline
 function removeTrailingZeros64(significand: u64): u64 {
   let exponent = 0;
   let r = rotr64(significand * 28999941890838049, 8);

package/assembly/util/itoa-fast.ts

@@ -59,8 +59,7 @@ function initPairs(): void {
  * 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 {
+export function itoaU32(buf: usize, v: u32): u32 {
   if (v < 10) {
     store<u16>(buf, <u16>(v + 0x30));
     return 1;
@@ -165,8 +164,7 @@ function initPairs(): void {
  * 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 {
+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;
@@ -187,8 +185,7 @@ function initPairs(): void {
  * 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 {
+export function itoaU64(buf: usize, v: u64): u32 {
   if (v <= <u64>u32.MAX_VALUE) {
     return itoaU32(buf, <u32>v);
   }

package/assembly/util/parsefloat-fast.ts

@@ -64,8 +64,7 @@ const MAX_EXACT_MANTISSA: u64 = 1 << 53;
  * 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 {
+export function parseFloatFast<T>(srcStart: usize, srcEnd: usize): T {
   const origStart = srcStart;
   let p = srcStart;
   let negative = false;

package/assembly/util/scanValueEnd.ts

@@ -27,8 +27,7 @@ import { scanStringEnd } from "./stringScan";
  * 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 {
+export function scanValueEnd<T = usize>(srcStart: usize, srcEnd: usize): usize {
   if (srcStart >= srcEnd) return 0;
   const first = load<u16>(srcStart);
 

package/assembly/util/scanValueEndSimd.ts

@@ -0,0 +1,160 @@
+import {
+  BACK_SLASH,
+  BRACE_LEFT,
+  BRACE_RIGHT,
+  BRACKET_LEFT,
+  BRACKET_RIGHT,
+  COMMA,
+  QUOTE,
+} from "../custom/chars";
+import { isSpace } from "./isSpace";
+
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_QUOTE = i16x8.splat(<i16>QUOTE);
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_BACK_SLASH = i16x8.splat(<i16>BACK_SLASH);
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_BRACE_RIGHT = i16x8.splat(<i16>BRACE_RIGHT);
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_BRACKET_RIGHT = i16x8.splat(<i16>BRACKET_RIGHT);
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_COMMA = i16x8.splat(<i16>COMMA);
+// @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
+// 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: @inline is a valid decorator
+@inline 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 {
+  const structural = v128.or(
+    v128.or(i16x8.eq(block, SPLAT_COMMA), i16x8.eq(block, SPLAT_BRACE_RIGHT)),
+    i16x8.eq(block, SPLAT_BRACKET_RIGHT),
+  );
+  // (c - 9) u<= 4  covers tab/LF/VT/FF/CR; space handled separately.
+  const whitespace = v128.or(
+    i16x8.le_u(i16x8.sub(block, SPLAT_WS_LO), SPLAT_WS_SPAN),
+    i16x8.eq(block, SPLAT_SPACE),
+  );
+  return i16x8.bitmask(v128.or(structural, whitespace));
+}
+
+function scanQuotedValueEnd_SIMD(srcStart: usize, srcEnd: usize): usize {
+  srcStart += 2;
+  const srcEnd16 = srcEnd >= 16 ? srcEnd - 16 : 0;
+
+  while (srcStart <= srcEnd16) {
+    const block = load<v128>(srcStart);
+    const mask = quoteOrBackslashMask(block);
+    if (mask == 0) {
+      srcStart += 16;
+      continue;
+    }
+
+    const laneIdx = usize(ctz(mask) << 1);
+    const srcIdx = srcStart + laneIdx;
+    const code = load<u16>(srcIdx);
+    if (code == QUOTE) return srcIdx + 2;
+    if (srcIdx + 2 >= srcEnd) return 0;
+    srcStart = srcIdx + 4;
+  }
+
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (code == QUOTE) return srcStart + 2;
+    if (code == BACK_SLASH) {
+      if (srcStart + 2 >= srcEnd) return 0;
+      srcStart += 4;
+      continue;
+    }
+    srcStart += 2;
+  }
+
+  return 0;
+}
+
+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.
+  let depth: i32 = 1;
+  let ptr = srcStart + 2;
+  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;
+    }
+    ptr += 2;
+  }
+  return 0;
+}
+
+function scanScalarValueEnd_SIMD(srcStart: usize, srcEnd: usize): usize {
+  const srcEnd16 = srcEnd >= 16 ? srcEnd - 16 : 0;
+  while (srcStart <= srcEnd16) {
+    const mask = scalarTerminatorMask(load<v128>(srcStart));
+    if (mask == 0) {
+      srcStart += 16;
+      continue;
+    }
+    return srcStart + usize(ctz(mask) << 1);
+  }
+
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (
+      code == COMMA ||
+      code == BRACKET_RIGHT ||
+      code == BRACE_RIGHT ||
+      isSpace(code)
+    )
+      return srcStart;
+    srcStart += 2;
+  }
+
+  return srcStart;
+}
+
+// @ts-expect-error: @inline is a valid decorator
+@inline export function scanValueEnd_SIMD<T>(
+  srcStart: usize,
+  srcEnd: usize,
+): usize {
+  if (srcStart >= srcEnd) return 0;
+  const first = load<u16>(srcStart);
+
+  if (isString<nonnull<T>>() && first == QUOTE)
+    return scanQuotedValueEnd_SIMD(srcStart, srcEnd);
+  if (isArray<nonnull<T>>() && first == BRACKET_LEFT)
+    return scanCompositeValueEnd_SIMD(srcStart, srcEnd);
+  if (
+    (isManaged<nonnull<T>>() || isReference<nonnull<T>>()) &&
+    first == BRACE_LEFT
+  )
+    return scanCompositeValueEnd_SIMD(srcStart, srcEnd);
+
+  if (first == QUOTE) return scanQuotedValueEnd_SIMD(srcStart, srcEnd);
+  if (first == BRACE_LEFT || first == BRACKET_LEFT)
+    return scanCompositeValueEnd_SIMD(srcStart, srcEnd);
+  return scanScalarValueEnd_SIMD(srcStart, srcEnd);
+}

package/assembly/util/scanValueEndSwar.ts

@@ -0,0 +1,142 @@
+import {
+  BACK_SLASH,
+  BRACE_LEFT,
+  BRACE_RIGHT,
+  BRACKET_LEFT,
+  BRACKET_RIGHT,
+  COMMA,
+  QUOTE,
+} from "../custom/chars";
+import { isSpace } from "./isSpace";
+
+// SWAR analogue of `scanValueEndSimd.ts`, processing four UTF-16 lanes per
+// 64-bit word for the SWAR build mode (no SIMD feature). Each mask is a fast
+// FILTER — a matched lane is re-checked with a real `load<u16>` before acting —
+// so the masks may over-match non-ASCII lanes whose low byte equals a target
+// (the verify rejects them). Lane byte offset within a hit word is
+// `ctz(mask) >> 3` (detection bit sits at lane*16 + 7).
+
+// @ts-expect-error: @inline is a valid decorator
+@inline const ONES: u64 = 0x0001_0001_0001_0001;
+// @ts-expect-error: @inline is a valid decorator
+@inline const HI: u64 = 0x0080_0080_0080_0080;
+
+// 16-bit-lane "equals" partials (pre-`& HI`); OR several, then `& HI` once.
+// @ts-expect-error: @inline is a valid decorator
+@inline function eqPart(block: u64, splat: u64): u64 {
+  const t = block ^ splat;
+  return (t - ONES) & ~t;
+}
+
+// @ts-expect-error: @inline is a valid decorator
+@inline const S_QUOTE: u64 = 0x0022_0022_0022_0022;
+// @ts-expect-error: @inline is a valid decorator
+@inline const S_BACK_SLASH: u64 = 0x005c_005c_005c_005c;
+
+// @ts-expect-error: @inline is a valid decorator
+@inline function quoteOrBackslashMask(block: u64): u64 {
+  return (eqPart(block, S_QUOTE) | eqPart(block, S_BACK_SLASH)) & HI;
+}
+
+function scanQuotedValueEnd_SWAR(srcStart: usize, srcEnd: usize): usize {
+  srcStart += 2;
+  const srcEnd8 = srcEnd >= 8 ? srcEnd - 8 : 0;
+
+  // Fast-skip 8-byte windows until a real quote (return) or a backslash, then
+  // hand off to the precise scalar tail (which resolves escape runs). The mask
+  // is a filter, so each candidate lane is verified with a real `load<u16>`;
+  // non-ASCII lanes that spuriously match are skipped (neither quote nor
+  // backslash), and `srcStart` is left at the window start for the tail.
+  while (srcStart <= srcEnd8) {
+    let mask = quoteOrBackslashMask(load<u64>(srcStart));
+    if (mask == 0) {
+      srcStart += 8;
+      continue;
+    }
+    do {
+      const srcIdx = srcStart + (usize(ctz(mask)) >> 3);
+      mask &= mask - 1;
+      const code = load<u16>(srcIdx);
+      if (code == QUOTE) return srcIdx + 2;
+      if (code == BACK_SLASH) break;
+    } while (mask != 0);
+    break;
+  }
+
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (code == QUOTE && load<u16>(srcStart - 2) != BACK_SLASH)
+      return srcStart + 2;
+    srcStart += 2;
+  }
+  return 0;
+}
+
+function scanCompositeValueEnd_SWAR(srcStart: usize, srcEnd: usize): usize {
+  // Scalar depth tracking (structural tokens are sparse; a bulk token-mask scan
+  // loses to a tight loop on token-dense objects) with SWAR quoted-skip for
+  // nested string values — where the long runs are.
+  let depth: i32 = 1;
+  let ptr = srcStart + 2;
+  while (ptr < srcEnd) {
+    const code = load<u16>(ptr);
+    if (code == QUOTE) {
+      ptr = scanQuotedValueEnd_SWAR(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;
+    }
+    ptr += 2;
+  }
+  return 0;
+}
+
+function scanScalarValueEnd_SWAR(srcStart: usize, srcEnd: usize): usize {
+  // Scalars (number/true/false/null) are short, so a plain scalar terminator
+  // scan beats setting up SWAR masks per word.
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (
+      code == COMMA ||
+      code == BRACKET_RIGHT ||
+      code == BRACE_RIGHT ||
+      isSpace(code)
+    )
+      return srcStart;
+    srcStart += 2;
+  }
+  return srcStart;
+}
+
+/**
+ * SWAR `scanValueEnd`: position just past the value at `srcStart`. Strings and
+ * objects/arrays use the SWAR token scans above; scalars use a short scalar
+ * loop. Returns 0 on empty input or an unterminated string/composite.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function scanValueEnd_SWAR<T>(
+  srcStart: usize,
+  srcEnd: usize,
+): usize {
+  if (srcStart >= srcEnd) return 0;
+  const first = load<u16>(srcStart);
+
+  if (isString<nonnull<T>>() && first == QUOTE)
+    return scanQuotedValueEnd_SWAR(srcStart, srcEnd);
+  if (isArray<nonnull<T>>() && first == BRACKET_LEFT)
+    return scanCompositeValueEnd_SWAR(srcStart, srcEnd);
+  if (
+    (isManaged<nonnull<T>>() || isReference<nonnull<T>>()) &&
+    first == BRACE_LEFT
+  )
+    return scanCompositeValueEnd_SWAR(srcStart, srcEnd);
+
+  if (first == QUOTE) return scanQuotedValueEnd_SWAR(srcStart, srcEnd);
+  if (first == BRACE_LEFT || first == BRACKET_LEFT)
+    return scanCompositeValueEnd_SWAR(srcStart, srcEnd);
+  return scanScalarValueEnd_SWAR(srcStart, srcEnd);
+}

package/assembly/util/scientific.ts

@@ -54,8 +54,7 @@ const POWERS5: usize = memory.data<i32>([
   );
 }
 
-// @ts-ignore: inline
-@inline function scaledown(significand: u64, exp: i32): f64 {
+function scaledown(significand: u64, exp: i32): f64 {
   const denom: u64 = 6103515625; // 1e14 * 0x1p-14
   const scale = reinterpret<f64>(0x3f06849b86a12b9b); // 1e-14 * 0x1p32
 
@@ -82,8 +81,7 @@ const POWERS5: usize = memory.data<i32>([
   return NativeMath.scalbn(<f64>significand, <i32>shift);
 }
 
-// @ts-ignore: inline
-@inline function scaleup(significand: u64, exp: i32): f64 {
+function scaleup(significand: u64, exp: i32): f64 {
   const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;
   let shift = ctz(significand);
   significand >>= shift;
@@ -111,8 +109,7 @@ const POWERS5: usize = memory.data<i32>([
  * @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 {
+export function scientific(significand: u64, exp: i32): f64 {
   if (!significand || exp < -342) return 0;
   if (exp > 308) return Infinity;
   let significandf = <f64>significand;

package/assembly/util/simd-int.ts

@@ -82,8 +82,7 @@
  * @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 {
+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;
@@ -104,8 +103,7 @@
  * @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 {
+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);
@@ -132,8 +130,7 @@
  * @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 {
+export function parse16Digits_SIMD(srcStart: usize): u64 {
   const block0 = load<v128>(srcStart);
   const block1 = load<v128>(srcStart, 16);
 
@@ -168,8 +165,7 @@
  * @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 {
+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);

package/assembly/util/snp.ts

@@ -6,11 +6,7 @@
 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 {
+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/stringScan.ts

@@ -1,7 +1,6 @@
 import { BACK_SLASH, QUOTE } from "../custom/chars";
 
-// @ts-ignore
-@inline export function isUnescapedQuote(ptr: usize): bool {
+export function isUnescapedQuote(ptr: usize): bool {
   if (load<u16>(ptr) != QUOTE) return false;
 
   let escaped = false;
@@ -13,8 +12,7 @@ import { BACK_SLASH, QUOTE } from "../custom/chars";
   return !escaped;
 }
 
-// @ts-ignore
-@inline export function scanStringEnd(ptr: usize, end: usize): usize {
+export function scanStringEnd(ptr: usize, end: usize): usize {
   ptr += 2;
   while (ptr < end) {
     if (load<u16>(ptr) == QUOTE && isUnescapedQuote(ptr)) return ptr;

package/assembly/util/swar-int.ts

@@ -97,8 +97,7 @@ const FINAL_4_MAGIC: u64 = 0x0000_0064_0000_0001;
  * @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 {
+export function parse8Digits_PairMul(lo: u64, hi: u64): u32 {
   const loDigits = lo - ZERO_4;
   const hiDigits = hi - ZERO_4;
   const bad =
@@ -174,8 +173,7 @@ const FINAL_4_MAGIC: u64 = 0x0000_0064_0000_0001;
  * @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 {
+export function parse16Digits_SWAR(srcStart: usize): u64 {
   const b0 = load<u64>(srcStart);
   const b1 = load<u64>(srcStart, 8);
   const b2 = load<u64>(srcStart, 16);
@@ -220,8 +218,7 @@ const FINAL_4_MAGIC: u64 = 0x0000_0064_0000_0001;
  * @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 {
+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);

package/lib/as-bs.ts

@@ -287,6 +287,43 @@ export namespace bs {
     }
     return changetype<T>(out);
   }
+
+  /**
+   * Like `out<T>()`, but writes the finished bytes into the existing object
+   * `target`, reusing its allocation: an in-place overwrite when the size
+   * already matches, `__renew` when it differs. Falls back to a fresh
+   * `out<T>()` when `target` is null or a static (`< __heap_base`), so callers
+   * can pass an empty/uninitialized target on the first call. Mirrors the reuse
+   * policy of `toField`, but for the top-level return value.
+   */
+  // @ts-expect-error: @inline is a valid decorator
+  @inline export function outTo<T>(target: usize): T {
+    if (target < __heap_base) return out<T>();
+    let len: usize;
+    let src: usize;
+    if (cacheOutput === 0) {
+      len = offset - buffer;
+      src = buffer;
+    } else {
+      len = cacheOutputLen;
+      src = cacheOutput;
+    }
+    let dst = target;
+    if (changetype<OBJECT>(target - TOTAL_OVERHEAD).rtSize != len) {
+      // @ts-expect-error: __renew is a runtime builtin
+      dst = __renew(target, len);
+    }
+    memory.copy(dst, src, len);
+    if (cacheOutput === 0) {
+      finalizeDynamicOutput(len);
+    } else {
+      cacheOutput = 0;
+      cacheOutputLen = 0;
+      offset = buffer;
+      stackSize = 0;
+    }
+    return changetype<T>(dst);
+  }
 }
 
 /**