json-as 1.4.0 → 1.5.0

package/assembly/deserialize/index/arbitrary.ts

@@ -1,8 +1,7 @@
 import { JSON } from "../..";
-import { deserializeArray } from "./array";
 import { deserializeBoolean } from "./bool";
 import { deserializeFloat } from "./float";
-import { deserializeObject } from "./object";
+import { deserializeObject, deserializeJsonArray, getParseSrc } from "./object";
 import { deserializeString } from "./string";
 import { BRACE_LEFT, BRACKET_LEFT, CHAR_N, QUOTE } from "../../custom/chars";
 
@@ -11,15 +10,34 @@ export function deserializeArbitrary(
   srcEnd: usize,
   dst: usize,
 ): JSON.Value {
+  const v = parseArbitraryValue(srcStart, srcEnd);
+  // Reuse path (`JSON.parse<JSON.Value>(data, out)`): write the parsed bits into
+  // the caller's handle (with the GC barrier for any managed payload).
+  return dst != 0 ? JSON.Value.__adoptInto(dst, v) : v;
+}
+
+function parseArbitraryValue(srcStart: usize, srcEnd: usize): JSON.Value {
   const firstChar = load<u16>(srcStart);
-  if (firstChar == QUOTE) {
-    return JSON.Value.from(deserializeString(srcStart, srcEnd));
-  } else if (firstChar == BRACE_LEFT) {
-    return JSON.Value.from(deserializeObject(srcStart, srcEnd, 0));
+  if (
+    firstChar == QUOTE ||
+    firstChar == BRACE_LEFT ||
+    firstChar == BRACKET_LEFT
+  ) {
+    // Lazy by default: when a parse is in flight (source anchor present), defer
+    // strings and composites (the allocating shapes) - store the exact raw slice
+    // and materialize on first access. Cheap primitives stay eager below.
+    const src = getParseSrc();
+    if (src.length != 0) {
+      const end = JSON.Util.scanValueEnd<JSON.Value>(srcStart, srcEnd);
+      return JSON.Value.fromSlice(srcStart, end, src);
+    }
+    if (firstChar == QUOTE)
+      return JSON.Value.from(deserializeString(srcStart, srcEnd));
+    return firstChar == BRACE_LEFT
+      ? JSON.Value.from(deserializeObject(srcStart, srcEnd, 0))
+      : JSON.Value.from(deserializeJsonArray(srcStart, srcEnd, 0));
   } else if (firstChar - 48 <= 9 || firstChar == 45) {
     return JSON.Value.from(deserializeFloat<f64>(srcStart, srcEnd));
-  } else if (firstChar == BRACKET_LEFT) {
-    return JSON.Value.from(deserializeArray<JSON.Value[]>(srcStart, srcEnd, 0));
   } else if (firstChar == 116 || firstChar == 102) {
     return JSON.Value.from(deserializeBoolean(srcStart, srcEnd));
   } else if (firstChar == CHAR_N) {

package/assembly/deserialize/index/float.ts

@@ -12,8 +12,7 @@ import {
   deserializeFloatField_SIMD,
 } from "../simd/float";
 
-// @ts-ignore: inline
-@inline export function deserializeFloat<T>(srcStart: usize, srcEnd: usize): T {
+export function deserializeFloat<T>(srcStart: usize, srcEnd: usize): T {
   if (JSON_MODE == JSONMode.SIMD) {
     return deserializeFloat_SIMD<T>(srcStart, srcEnd);
   } else if (JSON_MODE == JSONMode.NAIVE) {
@@ -23,8 +22,7 @@ import {
   }
 }
 
-// @ts-ignore: inline
-@inline export function deserializeFloatField<T extends number>(
+export function deserializeFloatField<T extends number>(
   srcStart: usize,
   srcEnd: usize,
   dstObj: usize,

package/assembly/deserialize/index/integer.ts

@@ -21,8 +21,7 @@ import {
  * @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 deserializeInteger<T extends number>(
+export function deserializeInteger<T extends number>(
   srcStart: usize,
   srcEnd: usize,
 ): T {
@@ -46,8 +45,7 @@ import {
  * @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<T extends number>(
+export function deserializeIntegerField<T extends number>(
   srcStart: usize,
   srcEnd: usize,
   dstObj: usize,

package/assembly/deserialize/index/object.ts

@@ -1 +1,6 @@
-export { deserializeObject } from "../naive/object";
+export {
+  deserializeObject,
+  deserializeJsonArray,
+  setParseSrc,
+  getParseSrc,
+} from "../naive/object";

package/assembly/deserialize/index/string.ts

@@ -12,11 +12,7 @@ import {
   deserializeStringField_SWAR,
 } from "../swar/string";
 
-
-@inline export function deserializeString(
-  srcStart: usize,
-  srcEnd: usize,
-): string {
+export function deserializeString(srcStart: usize, srcEnd: usize): string {
   if (JSON_MODE == JSONMode.SIMD) {
     return deserializeString_SIMD(srcStart, srcEnd);
   } else if (JSON_MODE == JSONMode.NAIVE) {
@@ -26,8 +22,7 @@ import {
   }
 }
 
-
-@inline export function deserializeStringField<T extends string | null>(
+export function deserializeStringField<T extends string | null>(
   srcStart: usize,
   srcEnd: usize,
   dstObj: usize,

package/assembly/deserialize/index/unsigned.ts

@@ -21,8 +21,7 @@ import {
  * @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<T extends number>(
+export function deserializeUnsigned<T extends number>(
   srcStart: usize,
   srcEnd: usize,
 ): T {
@@ -46,8 +45,7 @@ import {
  * @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<T extends number>(
+export function deserializeUnsignedField<T extends number>(
   srcStart: usize,
   srcEnd: usize,
   dstObj: usize,

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

@@ -2,7 +2,7 @@ import { atoi, isSpace } from "../../../util";
 import { COMMA, BRACKET_LEFT, BRACKET_RIGHT } from "../../../custom/chars";
 
 // Strict RFC 8259 integer-token check over [start, end): optional minus (signed
-// types only), then a lone `0` or [1-9] digits — no leading zeros, fraction,
+// types only), then a lone `0` or [1-9] digits - no leading zeros, fraction,
 // exponent, or trailing garbage. Throws otherwise.
 function validateJSONInteger(start: usize, end: usize, signed: bool): void {
   let ptr = start;

package/assembly/deserialize/naive/array/map.ts

@@ -29,7 +29,7 @@ export function deserializeMapArray<T extends Map<any, any>[]>(
     );
 
   // Each `{...}` map element is parsed in a single pass via deserializeMapBody,
-  // which reports where it ended — no separate scan to find the closing brace.
+  // which reports where it ended - no separate scan to find the closing brace.
   while (srcStart < srcEnd) {
     if (load<u16>(srcStart) == BRACE_LEFT) {
       const m = instantiate<valueof<T>>();

package/assembly/deserialize/naive/array/object.ts

@@ -29,7 +29,7 @@ export function deserializeObjectArray<T extends unknown[]>(
     );
 
   // Each `{...}` element is parsed in a single pass via parseObjectBody, which
-  // reports where it ended — no separate scan to find the closing brace.
+  // reports where it ended - no separate scan to find the closing brace.
   while (srcStart < srcEnd) {
     if (load<u16>(srcStart) == BRACE_LEFT) {
       const obj = new JSON.Obj();

package/assembly/deserialize/naive/array/struct.ts

@@ -34,14 +34,32 @@ export function deserializeStructArray<T extends unknown[]>(
         (srcEnd - srcStart).toString(),
     );
 
+  // Reuse existing element slots when `dst` already holds elements (no per-call
+  // allocation on a reused array); fall back to push for fresh/extra slots and
+  // trim any leftovers from a previous, longer parse.
+  let index = 0;
   while (srcStart < srcEnd) {
     const code = load<u16>(srcStart);
     if (code == BRACE_LEFT && depth++ == 0) {
       lastIndex = srcStart;
     } else if (code == BRACE_RIGHT && --depth == 0) {
-      out.push(JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 2)));
+      const valueEnd = (srcStart += 2);
+      if (<usize>index < <usize>out.length) {
+        const slot = changetype<usize>(unchecked(out[index]));
+        if (slot != 0) {
+          JSON.__deserialize<valueof<T>>(lastIndex, valueEnd, slot);
+        } else {
+          unchecked(
+            (out[index] = JSON.__deserialize<valueof<T>>(lastIndex, valueEnd)),
+          );
+        }
+      } else {
+        out.push(JSON.__deserialize<valueof<T>>(lastIndex, valueEnd));
+      }
+      index++;
     }
     srcStart += 2;
   }
+  if (<usize>index < <usize>out.length) out.length = index;
   return out;
 }

package/assembly/deserialize/naive/bool.ts

@@ -1,8 +1,4 @@
-// @ts-ignore: inline
-@inline export function deserializeBoolean(
-  srcStart: usize,
-  srcEnd: usize,
-): boolean {
+export function deserializeBoolean(srcStart: usize, srcEnd: usize): boolean {
   const block = load<u64>(srcStart);
   if (block == 28429475166421108) return true;
   else if (block == 32370086184550502 && load<u16>(srcStart, 8) == 101)

package/assembly/deserialize/naive/date.ts

@@ -1,7 +1,6 @@
 import { ptrToStr } from "../../util/ptrToStr";
 
-// @ts-ignore: inline
-@inline export function deserializeDate(srcStart: usize, srcEnd: usize): Date {
+export function deserializeDate(srcStart: usize, srcEnd: usize): Date {
   // Use AssemblyScript's date parser
   const d = Date.fromString(ptrToStr(srcStart + 2, srcEnd - 2));
 

package/assembly/deserialize/naive/float.ts

@@ -61,11 +61,7 @@ function validateJSONNumber(srcStart: usize, srcEnd: usize): void {
   if (ptr != end) throw new Error("Invalid JSON number: trailing characters");
 }
 
-// @ts-ignore: inline
-@inline export function deserializeFloat_NAIVE<T>(
-  srcStart: usize,
-  srcEnd: usize,
-): T {
+export function deserializeFloat_NAIVE<T>(srcStart: usize, srcEnd: usize): T {
   validateJSONNumber(srcStart, srcEnd);
   // @ts-ignore
   const type: T = 0;
@@ -113,8 +109,7 @@ function scanFloatEnd(srcStart: usize, srcEnd: usize): usize {
   return ptr;
 }
 
-// @ts-ignore: inline
-@inline export function deserializeFloatField_NAIVE<T extends number>(
+export function deserializeFloatField_NAIVE<T extends number>(
   srcStart: usize,
   srcEnd: usize,
   dstObj: usize,

package/assembly/deserialize/naive/integer.ts

@@ -1,7 +1,6 @@
 import { atoi } from "../../util/atoi";
 
-// @ts-ignore: inline
-@inline export function deserializeInteger_NAIVE<T extends number>(
+export function deserializeInteger_NAIVE<T extends number>(
   srcStart: usize,
   srcEnd: usize,
 ): T {

package/assembly/deserialize/naive/map.ts

@@ -10,8 +10,8 @@ import { isSpace, scanStringEnd } from "../../util";
 import { scanValueEnd } from "../../util/scanValueEnd";
 import { lastValueEnd, parseValue } from "./object";
 
-// @ts-ignore: Decorator is valid here
-@inline function deserializeMapKey<T>(start: usize, end: usize): T {
+function deserializeMapKey<T>(start: usize, end: usize): T {
+  // @ts-expect-error: exists
   const keyText = JSON.__deserialize<string>(start - 2, end + 2);
   if (isString<T>()) return changetype<T>(keyText);
   return JSON.parse<T>(keyText);
@@ -85,7 +85,7 @@ export function deserializeMapBody<T extends Map<any, any>>(
 
     if (isReference<valueof<T>>() && arbitraryValue) {
       const val = parseValue(srcStart, srcEnd);
-      // @ts-ignore: type — valueof<T> is JSON.Value in this branch
+      // @ts-ignore: type - valueof<T> is JSON.Value in this branch
       changetype<nonnull<T>>(out).set(
         deserializeMapKey<indexof<T>>(keyStart, keyEnd),
         changetype<valueof<T>>(changetype<usize>(val)),
@@ -117,8 +117,7 @@ export function deserializeMapBody<T extends Map<any, any>>(
   throw new Error("Failed to parse JSON!");
 }
 
-// @ts-ignore: Decorator is valid here
-@inline export function deserializeMapField<T extends Map<any, any>>(
+export function deserializeMapField<T extends Map<any, any>>(
   srcStart: usize,
   srcEnd: usize,
   dstObj: usize,
@@ -130,7 +129,7 @@ export function deserializeMapBody<T extends Map<any, any>>(
     out = changetype<T>(instantiate<T>());
     store<T>(fieldPtr, out);
   } else {
-    // Reusing an existing field map — clear it before repopulating. Fresh maps
+    // Reusing an existing field map - clear it before repopulating. Fresh maps
     // (deserializeMap / deserializeMapArray) skip this.
     changetype<nonnull<T>>(out).clear();
   }

package/assembly/deserialize/naive/object.ts

@@ -16,14 +16,11 @@ import { deserializeFloat } from "../index/float";
 import { deserializeString } from "../index/string";
 
 // "true"  as a u64 of UTF-16 code units (LE).
-// @ts-ignore: inline
-@inline const TRUE_WORD: u64 = 28429475166421108;
-// "alse"  — the tail of "false", read at +2 so the leading 'f' is skipped.
-// @ts-ignore: inline
-@inline const ALSE_WORD: u64 = 28429466576093281;
+const TRUE_WORD: u64 = 28429475166421108;
+// "alse"  - the tail of "false", read at +2 so the leading 'f' is skipped.
+const ALSE_WORD: u64 = 28429466576093281;
 // "null"  as a u64 of UTF-16 code units (LE).
-// @ts-ignore: inline
-@inline const NULL_WORD: u64 = 30399761348886638;
+const NULL_WORD: u64 = 30399761348886638;
 
 // End offset (just past the value) of the most recent parseValue() call. The
 // recursive-descent parser reports each value's end through this single cursor
@@ -32,12 +29,32 @@ import { deserializeString } from "../index/string";
 // parseValue() runs, so recursion never clobbers a still-needed value.
 let parseValueEnd: usize = 0;
 
+// Source string for the parse currently in flight. When non-empty, nested
+// objects/arrays are deferred: instead of being recursively materialized, each
+// is stored as a lazy JSON.Value holding its raw slice + this anchor (see
+// JSON.Value.fromSlice / JSON.Types.Lazy). Set at the top of JSON.parse (and in
+// JSON.Value.materialize), both of which save/restore it for re-entrancy, so any
+// lazy value built during a parse points into that parse's own source buffer.
+let parseSrc: string = "";
+export function setParseSrc(s: string): void {
+  parseSrc = s;
+}
+export function getParseSrc(): string {
+  return parseSrc;
+}
+
 export function deserializeObject(
   srcStart: usize,
   srcEnd: usize,
   dst: usize,
 ): JSON.Obj {
-  const out = changetype<JSON.Obj>(dst || changetype<usize>(new JSON.Obj()));
+  const reuse = dst != 0;
+  const out = changetype<JSON.Obj>(
+    reuse ? dst : changetype<usize>(new JSON.Obj()),
+  );
+  // Reuse path (`JSON.parse<JSON.Obj>(data, out)`): empty the handle first,
+  // keeping its buffer capacity, so we overwrite rather than append stale data.
+  if (reuse) out.clear();
 
   while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
 
@@ -58,6 +75,104 @@ export function deserializeObject(
   return out;
 }
 
+export function deserializeJsonArray(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): JSON.Arr {
+  const reuse = dst != 0;
+  const out = changetype<JSON.Arr>(
+    reuse ? dst : changetype<usize>(new JSON.Arr()),
+  );
+  if (reuse) out.clear();
+
+  while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
+
+  if (srcEnd == srcStart)
+    throw new Error("Input string had zero length or was all whitespace");
+  if (load<u16>(srcStart) != BRACKET_LEFT)
+    throw new Error("Expected '[' at start of array");
+  if (load<u16>(srcEnd - 2) != BRACKET_RIGHT)
+    throw new Error("Expected ']' at end of array");
+
+  parseArrayBodySlots(out, srcStart + 2, srcEnd);
+  return out;
+}
+
+/**
+ * Parses array elements starting at `srcStart` (just past the opening `[`) into
+ * a JSON.Arr's NaN-boxed value slots, returning the offset just after the
+ * matching `]`. Mirrors {@link parseObjectBody} without keys.
+ */
+export function parseArrayBodySlots(
+  out: JSON.Arr,
+  srcStart: usize,
+  srcEnd: usize,
+): usize {
+  out._src = parseSrc;
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (isSpace(code) || code == COMMA) {
+      srcStart += 2;
+      continue;
+    }
+    if (code == BRACKET_RIGHT) return srcStart + 2;
+    if (parseSrc.length != 0) {
+      out.pushRawSlot(parseSlotBits(srcStart, srcEnd));
+    } else {
+      out.pushRawSlot(
+        JSON.Value.bitsFrom<JSON.Value>(parseValue(srcStart, srcEnd)),
+      );
+    }
+    srcStart = parseValueEnd;
+  }
+  return srcEnd;
+}
+
+/**
+ * Parses a single object-member value into a NaN-boxed value slot, setting
+ * {@link parseValueEnd} to the offset just past it. Strings and composites are
+ * deferred (a `valBox(Lazy, startPtr)` slice the object parses on first access);
+ * numbers, booleans and null are parsed eagerly inline. Requires {@link parseSrc}
+ * to be set (the caller guards), since a lazy slot points into it.
+ */
+function parseSlotBits(srcStart: usize, srcEnd: usize): u64 {
+  const code = load<u16>(srcStart);
+  if (code == QUOTE || code == BRACE_LEFT || code == BRACKET_LEFT) {
+    const end = JSON.Util.scanValueEnd<JSON.Value>(srcStart, srcEnd);
+    parseValueEnd = end;
+    return JSON.Value.lazyBits(changetype<usize>(parseSrc), srcStart, end);
+  } else if (code - 48 <= 9 || code == 45) {
+    let p = srcStart + 2;
+    while (p < srcEnd) {
+      const c = load<u16>(p);
+      if (c == COMMA || c == BRACKET_RIGHT || c == BRACE_RIGHT || isSpace(c))
+        break;
+      p += 2;
+    }
+    parseValueEnd = p;
+    return JSON.Value.f64Bits(deserializeFloat<f64>(srcStart, p));
+  } else if (code == CHAR_T) {
+    if (load<u64>(srcStart) != TRUE_WORD)
+      throw new Error("Expected 'true' in JSON");
+    parseValueEnd = srcStart + 8;
+    return JSON.Value.boolBits(true);
+  } else if (code == CHAR_F) {
+    if (load<u64>(srcStart, 2) != ALSE_WORD)
+      throw new Error("Expected 'false' in JSON");
+    parseValueEnd = srcStart + 10;
+    return JSON.Value.boolBits(false);
+  } else if (code == CHAR_N) {
+    if (load<u64>(srcStart) != NULL_WORD)
+      throw new Error("Expected 'null' in JSON");
+    parseValueEnd = srcStart + 8;
+    return JSON.Value.nullBits();
+  }
+  throw new Error(
+    "Unexpected character in JSON '" + String.fromCharCode(code) + "'",
+  );
+}
+
 /**
  * Parses a single JSON value whose first character is at `srcStart` (`srcEnd`
  * is an upper bound). Returns the value and sets {@link parseValueEnd} to the
@@ -81,8 +196,8 @@ export function parseValue(srcStart: usize, srcEnd: usize): JSON.Value {
     parseValueEnd = parseObjectBody(obj, srcStart + 2, srcEnd);
     return JSON.Value.from(obj);
   } else if (code == BRACKET_LEFT) {
-    const arr = instantiate<JSON.Value[]>();
-    parseValueEnd = parseArrayBody(arr, srcStart + 2, srcEnd);
+    const arr = new JSON.Arr();
+    parseValueEnd = parseArrayBodySlots(arr, srcStart + 2, srcEnd);
     return JSON.Value.from(arr);
   } else if (code - 48 <= 9 || code == 45) {
     let p = srcStart + 2;
@@ -132,8 +247,19 @@ export function parseArrayBody(
       continue;
     }
     if (code == BRACKET_RIGHT) return srcStart + 2;
-    out.push(parseValue(srcStart, srcEnd));
-    srcStart = parseValueEnd;
+    if (
+      (code == BRACE_LEFT || code == BRACKET_LEFT || code == QUOTE) &&
+      parseSrc.length != 0
+    ) {
+      // Defer strings and composites (the allocating shapes): store the raw
+      // slice, parse on first access. Cheap primitives stay eager below.
+      const end = JSON.Util.scanValueEnd<JSON.Value>(srcStart, srcEnd);
+      out.push(JSON.Value.fromSlice(srcStart, end, parseSrc));
+      srcStart = end;
+    } else {
+      out.push(parseValue(srcStart, srcEnd));
+      srcStart = parseValueEnd;
+    }
   }
   return srcEnd;
 }
@@ -148,6 +274,11 @@ export function parseObjectBody(
   srcStart: usize,
   srcEnd: usize,
 ): usize {
+  // Anchor the source for this object's deferred value slots (start pointers
+  // into it). Set here so every caller - deserializeObject, the JSON.Obj[]
+  // array path, parseValue, the map path - gets it. Empty off the parse path,
+  // where no lazy slots are produced.
+  out._src = parseSrc;
   while (srcStart < srcEnd) {
     let code = load<u16>(srcStart);
 
@@ -185,7 +316,14 @@ export function parseObjectBody(
     // --- value ---
     while (srcStart < srcEnd && isSpace((code = load<u16>(srcStart))))
       srcStart += 2;
-    out.appendRaw(keyStart, keyEnd, parseValue(srcStart, srcEnd));
+    if (parseSrc.length != 0) {
+      // Parsing: store a NaN-boxed slot directly (strings/composites deferred,
+      // scalars eager) - no per-value JSON.Value object.
+      out.appendRawSlot(keyStart, keyEnd, parseSlotBits(srcStart, srcEnd));
+    } else {
+      // Off the parse path (no source anchor): box eagerly.
+      out.appendRaw(keyStart, keyEnd, parseValue(srcStart, srcEnd));
+    }
     srcStart = parseValueEnd;
   }
   return srcEnd;

package/assembly/deserialize/naive/raw.ts

@@ -1,10 +1,6 @@
 import { JSON } from "../..";
 import { ptrToStr } from "../../util/ptrToStr";
 
-// @ts-ignore: inline
-@inline export function deserializeRaw(
-  srcStart: usize,
-  srcEnd: usize,
-): JSON.Raw {
+export function deserializeRaw(srcStart: usize, srcEnd: usize): JSON.Raw {
   return JSON.Raw.from(ptrToStr(srcStart, srcEnd));
 }

package/assembly/deserialize/naive/set.ts

@@ -156,8 +156,7 @@ export function deserializeSet<T extends Set<any>>(
   return out;
 }
 
-// @ts-expect-error: Decorator valid here
-@inline function deserializeSetBody<T extends Set<any>>(
+function deserializeSetBody<T extends Set<any>>(
   srcStart: usize,
   srcEnd: usize,
   out: T,
@@ -166,8 +165,7 @@ export function deserializeSet<T extends Set<any>>(
   return deserializeSetDirect<T>(srcStart, srcEnd, changetype<nonnull<T>>(out));
 }
 
-// @ts-expect-error: Decorator valid here
-@inline export function deserializeSetField<T extends Set<any>>(
+export function deserializeSetField<T extends Set<any>>(
   srcStart: usize,
   srcEnd: usize,
   dstObj: usize,

package/assembly/deserialize/naive/staticarray.ts

@@ -112,8 +112,7 @@ export function deserializeStaticArray<T extends StaticArray<any>>(
   throw new Error("Could not parse static array of type " + nameof<T>() + "!");
 }
 
-
-@inline export function deserializeStaticArrayField<T extends StaticArray<any>>(
+export function deserializeStaticArrayField<T extends StaticArray<any>>(
   srcStart: usize,
   srcEnd: usize,
   dstObj: usize,

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) ||
@@ -148,7 +145,7 @@ function writeStringToField(
 // 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`.
+// actually present - the common escape-free case never touches `bs`.
 function deserializeEscapedStringField_NAIVE(
   payloadStart: usize,
   escPos: usize,
@@ -201,8 +198,8 @@ function deserializeEscapedStringField_NAIVE(
 // 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.
+// 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,

package/assembly/deserialize/naive/unsigned.ts

@@ -1,7 +1,6 @@
 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 {

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 {