json-as 1.3.9 → 1.5.0

package/assembly/deserialize/naive/string.ts

@@ -4,15 +4,13 @@ import { __heap_base } from "memory";
 import { BACK_SLASH, QUOTE } from "../../custom/chars";
 import { DESERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
 
-// @ts-ignore: inline
-@inline function hexDigit(c: u16): u32 {
+function hexDigit(c: u16): u32 {
   if (c <= 0x39) return c - 0x30; // '0'-'9'
   if (c <= 0x46) return c - 0x37; // 'A'-'F'
   return c - 0x57; // 'a'-'f'
 }
 
-// @ts-ignore: inline
-@inline function hex4ToU16(srcStart: usize): u16 {
+function hex4ToU16(srcStart: usize): u16 {
   return <u16>(
     ((hexDigit(load<u16>(srcStart)) << 12) |
       (hexDigit(load<u16>(srcStart, 2)) << 8) |
@@ -21,8 +19,7 @@ import { DESERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
   );
 }
 
-// @ts-ignore: inline
-@inline function isHexDigit(c: u16): bool {
+function isHexDigit(c: u16): bool {
   return (
     (c >= 0x30 && c <= 0x39) ||
     (c >= 0x41 && c <= 0x46) ||
@@ -33,8 +30,7 @@ import { DESERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
 // Strict RFC 8259 check for the char following a backslash, at [escPtr, srcEnd).
 // Legal escapes: " \ / b f n r t and \uXXXX (4 hex digits). Throws otherwise:
 // unknown escape letter, a trailing backslash, or a short / non-hex \u.
-// @ts-ignore: inline
-@inline function validateEscape(escPtr: usize, srcEnd: usize): void {
+function validateEscape(escPtr: usize, srcEnd: usize): void {
   if (escPtr >= srcEnd)
     throw new Error("Invalid JSON string: incomplete escape");
   const code = load<u16>(escPtr);
@@ -65,8 +61,7 @@ import { DESERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
     throw new Error("Invalid JSON string: illegal escape");
 }
 
-// @ts-ignore: inline
-@inline export function deserializeString_NAIVE(
+export function deserializeString_NAIVE(
   srcStart: usize,
   srcEnd: usize,
 ): string {
@@ -121,8 +116,7 @@ import { DESERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
 
 // Writes into the destination field, reusing or resizing the backing string.
 // Mirrors `writeStringToField` in ../swar/string.ts.
-// @ts-ignore: inline
-@inline function writeStringToField(
+function writeStringToField(
   dstFieldPtr: usize,
   srcStart: usize,
   byteLength: u32,
@@ -148,23 +142,26 @@ import { DESERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
   memory.copy(stringPtr, srcStart, byteLength);
 }
 
-// @ts-ignore: inline
-@inline export function deserializeStringField_NAIVE<T extends string | null>(
-  srcStart: usize,
+// Escape-bearing tail of the field parse: the clean prefix [payloadStart,
+// escPos) is bulk-copied into the scratch buffer, then escapes are decoded into
+// it, and the result is written to the field. Only reached when a backslash is
+// actually present - the common escape-free case never touches `bs`.
+function deserializeEscapedStringField_NAIVE(
+  payloadStart: usize,
+  escPos: usize,
   srcEnd: usize,
-  dstObj: usize,
-  dstOffset: usize = 0,
+  dstFieldPtr: usize,
 ): usize {
-  const dstFieldPtr = dstObj + dstOffset;
-  if (srcStart + 2 > srcEnd || load<u16>(srcStart) != QUOTE)
-    abort("Expected leading quote");
-
-  const payloadStart = srcStart + 2;
-  srcStart = payloadStart;
-
   bs.offset = bs.buffer;
   bs.ensureSize(<u32>(srcEnd - payloadStart));
 
+  const prefixLen = escPos - payloadStart;
+  if (prefixLen) {
+    memory.copy(bs.offset, payloadStart, prefixLen);
+    bs.offset += prefixLen;
+  }
+
+  let srcStart = escPos;
   while (srcStart < srcEnd) {
     const block = load<u16>(srcStart);
 
@@ -197,3 +194,50 @@ import { DESERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
   abort("Expected closing quote");
   return 0;
 }
+
+// NOT @inline: this is a loop-bearing scanner called per string field. As an
+// always-inline entry it gets inlined into every field call site inside the
+// @inline __DESERIALIZE_FAST, exploding binaryen's optimize phase on large
+// schemas (~118s on the `large` bench). Kept as a single shared function - one
+// call per field - matching the non-inline SWAR/SIMD field deserializers.
+export function deserializeStringField_NAIVE<T extends string | null>(
+  srcStart: usize,
+  srcEnd: usize,
+  dstObj: usize,
+  dstOffset: usize = 0,
+): usize {
+  const dstFieldPtr = dstObj + dstOffset;
+  if (srcStart + 2 > srcEnd || load<u16>(srcStart) != QUOTE)
+    abort("Expected leading quote");
+
+  const payloadStart = srcStart + 2;
+  srcStart = payloadStart;
+
+  // Scan for the closing quote without touching the scratch buffer. For the
+  // common escape-free case the bytes are a verbatim slice of the source, so we
+  // copy source -> field directly (mirrors the SWAR/SIMD field paths). Only a
+  // backslash diverts to the escape-decoding tail above.
+  while (srcStart < srcEnd) {
+    const block = load<u16>(srcStart);
+    if (block == QUOTE) {
+      writeStringToField(
+        dstFieldPtr,
+        payloadStart,
+        <u32>(srcStart - payloadStart),
+      );
+      return srcStart + 2;
+    }
+    if (block == BACK_SLASH) {
+      return deserializeEscapedStringField_NAIVE(
+        payloadStart,
+        srcStart,
+        srcEnd,
+        dstFieldPtr,
+      );
+    }
+    srcStart += 2;
+  }
+
+  abort("Expected closing quote");
+  return 0;
+}

package/assembly/deserialize/naive/typedarray.ts

@@ -2,8 +2,7 @@ import { COMMA, BRACKET_RIGHT } from "../../custom/chars";
 import { deserializeFloat_NAIVE } from "./float";
 import { atoi, isSpace } from "../../util";
 
-
-@inline function countTypedArrayElements(srcStart: usize, srcEnd: usize): i32 {
+function countTypedArrayElements(srcStart: usize, srcEnd: usize): i32 {
   let count = 0;
 
   while (srcStart < srcEnd) {

package/assembly/deserialize/naive/unsigned.ts

@@ -1,15 +1,13 @@
 import { atoi } from "../../util/atoi";
 
-// @ts-ignore: inline
-@inline export function deserializeUnsigned_NAIVE<T extends number>(
+export function deserializeUnsigned_NAIVE<T extends number>(
   srcStart: usize,
   srcEnd: usize,
 ): T {
   return atoi<T>(srcStart, srcEnd);
 }
 
-// @ts-ignore: inline
-@inline export function deserializeUnsignedField_NAIVE<T extends number>(
+export function deserializeUnsignedField_NAIVE<T extends number>(
   srcStart: usize,
   srcEnd: usize,
   dstObj: usize,

package/assembly/deserialize/simd/array/integer.ts

@@ -40,11 +40,7 @@ const ASCII_ZERO_4: u64 = 0x0030003000300030;
 // @ts-expect-error: decorators valid here
 @lazy const PAIR_WEIGHTS_100_1 = i16x8(100, 1, 100, 1, 0, 0, 0, 0);
 
-// @ts-expect-error: decorators valid here
-@inline function storeSignedInteger<T extends number[]>(
-  slot: usize,
-  value: i64,
-): void {
+function storeSignedInteger<T extends number[]>(slot: usize, value: i64): void {
   if (sizeof<valueof<T>>() == sizeof<i8>()) {
     store<i8>(slot, <i8>value);
   } else if (sizeof<valueof<T>>() == sizeof<i16>()) {
@@ -58,8 +54,7 @@ const ASCII_ZERO_4: u64 = 0x0030003000300030;
   }
 }
 
-// @ts-expect-error: decorators valid here
-@inline function storeUnsignedInteger<T extends number[]>(
+function storeUnsignedInteger<T extends number[]>(
   slot: usize,
   value: u64,
 ): void {
@@ -76,8 +71,7 @@ const ASCII_ZERO_4: u64 = 0x0030003000300030;
   }
 }
 
-// @ts-expect-error: decorators valid here
-@inline function tryParseEightDigitsSIMD(srcStart: usize, value: u64): u64 {
+function tryParseEightDigitsSIMD(srcStart: usize, value: u64): u64 {
   const block = load<v128>(srcStart);
   const digits = i16x8.sub(block, SPLAT_30);
   if (v128.any_true(i16x8.gt_u(digits, SPLAT_09))) return 0;
@@ -96,8 +90,7 @@ const ASCII_ZERO_4: u64 = 0x0030003000300030;
 // As in the SWAR variant: the parse helpers take a `slot` (`writePtr`) and
 // store directly. The dispatcher owns `out.length = maxElements` and the
 // per-element `writePtr` advance so `Array.push` is removed for every
-// @ts-expect-error: decorators valid here
-@inline function parseSignedIntegerSIMD<T extends number[]>(
+function parseSignedIntegerSIMD<T extends number[]>(
   srcStart: usize,
   srcEnd: usize,
   slot: usize,
@@ -135,8 +128,7 @@ const ASCII_ZERO_4: u64 = 0x0030003000300030;
   return srcStart;
 }
 
-// @ts-expect-error: decorators valid here
-@inline function parseUnsignedIntegerSIMD<T extends number[]>(
+function parseUnsignedIntegerSIMD<T extends number[]>(
   srcStart: usize,
   srcEnd: usize,
   slot: usize,

package/assembly/deserialize/simd/float.ts

@@ -3,7 +3,7 @@
 // `parse8Digits_SIMD` (16 bytes / 8 digits) before falling through to
 // `parse4Digits_PairMul` (8 bytes / 4 digits) and finally the scalar tail.
 //
-// Output is bit-identical to `f64.parse` / `f32.parse` for every input — the
+// Output is bit-identical to `f64.parse` / `f32.parse` for every input - the
 // SIMD strides only change how the u64 mantissa is accumulated, not what it
 // becomes.
 //
@@ -23,8 +23,7 @@ const ASCII_ZERO: u16 = 48;
 const ASCII_E_UP: u16 = 69;
 const ASCII_E_LO: u16 = 101;
 
-// @ts-ignore: inline
-@inline function fallback<T>(srcStart: usize, srcEnd: usize): T {
+function fallback<T>(srcStart: usize, srcEnd: usize): T {
   const s = ptrToStr(srcStart, srcEnd);
   // @ts-ignore
   const type: T = 0;
@@ -34,8 +33,7 @@ const ASCII_E_LO: u16 = 101;
   return <T>(<f32>f32.parse(s));
 }
 
-// @ts-ignore: inline
-@inline function fallbackField<T extends number>(
+function fallbackField<T extends number>(
   origStart: usize,
   end: usize,
   fieldPtr: usize,
@@ -48,11 +46,7 @@ const ASCII_E_LO: u16 = 101;
   }
 }
 
-// @ts-ignore: inline
-@inline export function deserializeFloat_SIMD<T>(
-  srcStart: usize,
-  srcEnd: usize,
-): T {
+export function deserializeFloat_SIMD<T>(srcStart: usize, srcEnd: usize): T {
   const origStart = srcStart;
   let p = srcStart;
   let negative = false;
@@ -168,8 +162,7 @@ const ASCII_E_LO: u16 = 101;
   return <T>(<f32>result);
 }
 
-// @ts-ignore: inline
-@inline export function deserializeFloatField_SIMD<T extends number>(
+export function deserializeFloatField_SIMD<T extends number>(
   srcStart: usize,
   srcEnd: usize,
   dstObj: usize,

package/assembly/deserialize/simd/integer.ts

@@ -38,11 +38,7 @@ const ASCII_ZERO: u16 = 48;
  * @param value  The `u64` accumulator, interpreted as a two's-complement
  *               signed integer for narrower types.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline function storeSignedToField<T extends number>(
-  dstPtr: usize,
-  value: u64,
-): void {
+function storeSignedToField<T extends number>(dstPtr: usize, value: u64): void {
   if (sizeof<T>() == 1) {
     store<i8>(dstPtr, <i8>value);
   } else if (sizeof<T>() == 2) {
@@ -61,8 +57,7 @@ const ASCII_ZERO: u16 = 48;
  * @param dstPtr Destination pointer (already includes any field offset).
  * @param value  The `u64` accumulator.
  */
-// @ts-expect-error: decorator valid here
-@inline function storeUnsignedToField<T extends number>(
+function storeUnsignedToField<T extends number>(
   dstPtr: usize,
   value: u64,
 ): void {
@@ -88,8 +83,7 @@ const ASCII_ZERO: u16 = 48;
  * @param srcEnd   Pointer just past the last code unit.
  * @returns The parsed value, two's-complement truncated to `T`.
  */
-// @ts-expect-error: decorator valid here
-@inline export function deserializeInteger_SIMD<T extends number>(
+export function deserializeInteger_SIMD<T extends number>(
   srcStart: usize,
   srcEnd: usize,
 ): T {
@@ -130,8 +124,7 @@ const ASCII_ZERO: u16 = 48;
  * @param dstOffset Byte offset of the field within `dstObj`.
  * @returns The source position immediately after the last digit consumed.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function deserializeIntegerField_SIMD<T extends number>(
+export function deserializeIntegerField_SIMD<T extends number>(
   srcStart: usize,
   srcEnd: usize,
   dstObj: usize,
@@ -170,8 +163,7 @@ const ASCII_ZERO: u16 = 48;
  * @param srcEnd   Pointer just past the last code unit.
  * @returns The parsed value, truncated to `T`.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function deserializeUnsigned_SIMD<T extends number>(
+export function deserializeUnsigned_SIMD<T extends number>(
   srcStart: usize,
   srcEnd: usize,
 ): T {
@@ -207,8 +199,7 @@ const ASCII_ZERO: u16 = 48;
  * @param dstOffset Byte offset of the field within `dstObj`.
  * @returns The source position immediately after the last digit consumed.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function deserializeUnsignedField_SIMD<T extends number>(
+export function deserializeUnsignedField_SIMD<T extends number>(
   srcStart: usize,
   srcEnd: usize,
   dstObj: usize,

package/assembly/deserialize/simd/string.ts

@@ -63,20 +63,14 @@ import { hex4_to_u16_swar } from "../../util/swar";
  * @param dst buffer to write to
  * @returns number of bytes written
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline function copyStringFromSource_SIMD(
-  srcStart: usize,
-  byteLength: usize,
-): string {
+function copyStringFromSource_SIMD(srcStart: usize, byteLength: usize): string {
   if (byteLength == 0) return changetype<string>("");
-  // @ts-expect-error: __new is a runtime builtin
   const out = __new(byteLength, idof<string>());
   memory.copy(out, srcStart, byteLength);
   return changetype<string>(out);
 }
 
-// @ts-expect-error: @inline is a valid decorator
-@inline function writeStringToField_SIMD(
+function writeStringToField_SIMD(
   dstFieldPtr: usize,
   srcStart: usize,
   byteLength: u32,
@@ -107,11 +101,7 @@ import { hex4_to_u16_swar } from "../../util/swar";
 // handling (no closing-quote search). Same HYBRID strategy as the field path
 // (see deserializeEscapedStringField_SIMD): escape blocks use a free
 // whole-block v128 store for the plain prefix; clean runs stream the first
-// block then bulk-memcpy the remainder. Output is sliced out of `bs` scratch.
-//
-// Deliberately NOT @inline: cold escape path. Inlining the nested-loop v128
-// body at every call site explodes `--converge` compile time on large schemas
-// for no runtime gain (one call per escaped string).
+
 function deserializeEscapedString_SIMD(
   payloadStart: usize,
   escapeStart: usize,
@@ -233,16 +223,16 @@ export function deserializeString_SIMD(srcStart: usize, srcEnd: usize): string {
     }
 
     const laneIdx = usize(ctz(mask) << 1);
-    return inline.always(
-      deserializeEscapedString_SIMD(payloadStart, srcStart + laneIdx, srcEnd),
+    return deserializeEscapedString_SIMD(
+      payloadStart,
+      srcStart + laneIdx,
+      srcEnd,
     );
   }
 
   while (srcStart < srcEnd) {
     if (load<u16>(srcStart) == BACK_SLASH) {
-      return inline.always(
-        deserializeEscapedString_SIMD(payloadStart, srcStart, srcEnd),
-      );
+      return deserializeEscapedString_SIMD(payloadStart, srcStart, srcEnd);
     }
     srcStart += 2;
   }
@@ -255,18 +245,14 @@ export function deserializeString_SIMD(srcStart: usize, srcEnd: usize): string {
 // reused `bs` scratch buffer, then written once via writeStringToField_SIMD.
 //
 // Strategy (validated against run-copy and pure-stream variants across escape
-// densities — see __benches__/custom/simd-string-deser-variants-h2h):
+// densities - see __benches__/custom/simd-string-deser-variants-h2h):
 //   * Escape-bearing block: a single whole-block v128 store copies the plain
 //     prefix for free; then the escape is decoded scalar.
 //   * Clean block: stream the first one cheaply, but if the clean run keeps
-//     going, switch to one bulk memory.copy for the remainder — bandwidth-
+//     going, switch to one bulk memory.copy for the remainder - bandwidth-
 //     optimal on long sparse runs, avoiding a per-block-store cliff on large
 //     inputs. This dominates both alternatives: stream-cheap on dense escapes,
-//     memcpy-fast on long runs.
-//
-// Deliberately NOT @inline: cold escape path. As an @inline it was inlined into
-// deserializeStringField_SIMD at every struct string-field site, exploding
-// `--converge` compile time ~24x on large schemas (4s → 99s) for no runtime
+
 // gain. The hot no-escape scan + writeStringToField stay inline in the caller.
 function deserializeEscapedStringField_SIMD(
   payloadStart: usize,
@@ -387,10 +373,6 @@ function deserializeEscapedStringField_SIMD(
   return srcStart;
 }
 
-// NOT @inline: as an @inline entry, binaryen inlined the (loop-bearing) escaped
-// scanner into every per-field copy, exploding `large` SIMD compile ~24x
-// (4s→99s, 221KB→555KB wasm). Kept as a single shared function — matches
-// deserializeStringField_SWAR (also non-inline) and costs only one call/field.
 export function deserializeStringField_SIMD<T extends string | null>(
   srcStart: usize,
   srcEnd: usize,
@@ -427,13 +409,11 @@ export function deserializeStringField_SIMD<T extends string | null>(
       return srcIdx + 2;
     }
     // backslash → vectorized escaped scan (no more SWAR fallback)
-    return inline.always(
-      deserializeEscapedStringField_SIMD(
-        payloadStart,
-        srcIdx,
-        srcEnd,
-        dstFieldPtr,
-      ),
+    return deserializeEscapedStringField_SIMD(
+      payloadStart,
+      srcIdx,
+      srcEnd,
+      dstFieldPtr,
     );
   }
 
@@ -448,13 +428,11 @@ export function deserializeStringField_SIMD<T extends string | null>(
       return srcStart + 2;
     }
     if (char == BACK_SLASH) {
-      return inline.always(
-        deserializeEscapedStringField_SIMD(
-          payloadStart,
-          srcStart,
-          srcEnd,
-          dstFieldPtr,
-        ),
+      return deserializeEscapedStringField_SIMD(
+        payloadStart,
+        srcStart,
+        srcEnd,
+        dstFieldPtr,
       );
     }
     srcStart += 2;

package/assembly/deserialize/swar/array/arbitrary.ts

@@ -2,8 +2,7 @@ import { JSON } from "../../..";
 import { deserializeGenericArrayBody } from "./generic";
 import { ensureArrayField } from "./shared";
 
-
-@inline export function deserializeArbitraryArrayField(
+export function deserializeArbitraryArrayField(
   srcStart: usize,
   srcEnd: usize,
   fieldPtr: usize,

package/assembly/deserialize/swar/array/array.ts

@@ -3,8 +3,7 @@ import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
 import { deserializeFloatArrayBody } from "./float";
 import { ensureArrayField, scanValueEnd, skipWhitespace } from "./shared";
 
-
-@inline export function deserializeArrayArrayBody<T extends unknown[][]>(
+export function deserializeArrayArrayBody<T extends unknown[][]>(
   srcStart: usize,
   srcEnd: usize,
   out: T,
@@ -91,8 +90,7 @@ import { ensureArrayField, scanValueEnd, skipWhitespace } from "./shared";
   throw new Error("Failed to parse JSON!");
 }
 
-
-@inline export function deserializeArrayArrayField<T extends unknown[][]>(
+export function deserializeArrayArrayField<T extends unknown[][]>(
   srcStart: usize,
   srcEnd: usize,
   fieldPtr: usize,

package/assembly/deserialize/swar/array/bool.ts

@@ -8,8 +8,7 @@ import {
 import { isSpace } from "../../../util";
 import { ensureArrayElementSlot, ensureArrayField } from "./shared";
 
-
-@inline function deserializeBooleanArrayBody<T extends boolean[]>(
+function deserializeBooleanArrayBody<T extends boolean[]>(
   srcStart: usize,
   srcEnd: usize,
   out: T,
@@ -60,8 +59,7 @@ import { ensureArrayElementSlot, ensureArrayField } from "./shared";
   throw new Error("Failed to parse JSON!");
 }
 
-
-@inline export function deserializeBooleanArrayField<T extends boolean[]>(
+export function deserializeBooleanArrayField<T extends boolean[]>(
   srcStart: usize,
   srcEnd: usize,
   fieldPtr: usize,

package/assembly/deserialize/swar/array/box.ts

@@ -2,8 +2,7 @@ import { JSON } from "../../..";
 import { deserializeGenericArrayBody } from "./generic";
 import { ensureArrayField } from "./shared";
 
-
-@inline export function deserializeBoxArrayField<T extends JSON.Box<any>[]>(
+export function deserializeBoxArrayField<T extends JSON.Box<any>[]>(
   srcStart: usize,
   srcEnd: usize,
   fieldPtr: usize,

package/assembly/deserialize/swar/array/float.ts

@@ -8,21 +8,11 @@ import { parse4Digits_PairMul } from "../../../util/swar-int";
 import { loadPow10, MAX_EXACT_MANTISSA, MAX_EXACT_POW10 } from "../float";
 import { isSpace } from "../../../util";
 
-
-@inline function skipFloatArrayWhitespace(
-  srcStart: usize,
-  srcEnd: usize,
-): usize {
+function skipFloatArrayWhitespace(srcStart: usize, srcEnd: usize): usize {
   while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   return srcStart;
 }
-
-// @ts-ignore: inline
-@inline function fallbackStore<E>(
-  origStart: usize,
-  end: usize,
-  slot: usize,
-): void {
+function fallbackStore<E>(origStart: usize, end: usize, slot: usize): void {
   const s = ptrToStr(origStart, end);
   if (sizeof<E>() == sizeof<f32>()) {
     store<f32>(slot, f32.parse(s));
@@ -46,8 +36,7 @@ import { isSpace } from "../../../util";
  * digit, lone minus, malformed exponent suffix). Valid-but-out-of-range
  * numbers are handled inline.
  */
-// @ts-expect-error: decorators valid here
-@inline export function parseFloatElementSWAR<E>(
+export function parseFloatElementSWAR<E>(
   srcStart: usize,
   srcEnd: usize,
   slot: usize,
@@ -78,7 +67,7 @@ import { isSpace } from "../../../util";
   }
 
   // Fractional mantissa: parse4 SWAR stride + scalar tail. Same u64
-  // accumulator as the integer part — exponent compensates for fracDigits.
+  // accumulator as the integer part - exponent compensates for fracDigits.
   let fracDigits: i32 = 0;
   if (p < srcEnd && load<u16>(p) == 46) {
     p += 2;
@@ -165,7 +154,7 @@ import { isSpace } from "../../../util";
     // the `ptrToStr` allocation + strtod re-parse.
     result = scientific(mantissa, exponent);
   } else {
-    // >19 mantissa digits — beyond u64 capacity, may need strtod's sticky-bit
+    // >19 mantissa digits - beyond u64 capacity, may need strtod's sticky-bit
     // pattern. Hand off to f*.parse on the float's substring.
     fallbackStore<E>(origStart, p, slot);
     return p;
@@ -256,7 +245,7 @@ export function deserializeFloatArray_SWAR<T extends number[]>(
 }
 
 /**
- * Field/into variant — parses `[..]` into the existing `out` array and
+ * Field/into variant - parses `[..]` into the existing `out` array and
  * returns the cursor past the closing `]`.
  *
  * Worst-case pre-sizing (`(srcEnd - srcStart) >> 2`) used by the top-level
@@ -265,7 +254,7 @@ export function deserializeFloatArray_SWAR<T extends number[]>(
  * `[lon,lat]` would over-allocate megabytes of f64 capacity. Instead we
  * use `ensureArrayElementSlot`'s grow-or-reuse strategy.
  */
-@inline export function deserializeFloatArrayBody<T extends number[]>(
+export function deserializeFloatArrayBody<T extends number[]>(
   srcStart: usize,
   srcEnd: usize,
   out: T,
@@ -316,9 +305,7 @@ export function deserializeFloatArray_SWAR<T extends number[]>(
 
   throw new Error("Failed to parse JSON!");
 }
-
-
-@inline export function deserializeFloatArrayField<T extends number[]>(
+export function deserializeFloatArrayField<T extends number[]>(
   srcStart: usize,
   srcEnd: usize,
   fieldPtr: usize,

package/assembly/deserialize/swar/array/generic.ts

@@ -7,8 +7,7 @@ import {
   skipWhitespace,
 } from "./shared";
 
-
-@inline export function deserializeGenericArrayBody<T extends unknown[]>(
+export function deserializeGenericArrayBody<T extends unknown[]>(
   srcStart: usize,
   srcEnd: usize,
   out: T,
@@ -48,8 +47,7 @@ import {
   throw new Error("Failed to parse JSON!");
 }
 
-
-@inline export function deserializeGenericArrayField<T extends unknown[]>(
+export function deserializeGenericArrayField<T extends unknown[]>(
   srcStart: usize,
   srcEnd: usize,
   fieldPtr: usize,