json-as 1.3.8 → 1.4.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## 2026-06-05 - v1.4.0
+
+- feat(lazy-fields): **on-demand (lazy) field parsing.** Mark a field `@lazy`, wrap its type as `JSON.Lazy<T>`, or set a class-wide default with `@json({ lazy: "auto" | "all" })` (and opt individual fields back out with `@eager`). A lazy field stores its raw JSON slice at parse time and parses it into the field's type only on first access (then caches); a field you never read is never parsed, and an untouched field round-trips by copying its original source bytes — never re-parsed or re-serialized. `auto` defers the expensive-to-parse fields (strings, arrays, maps/sets, `JSON.Value`/`Obj`/`Raw`, non-trivial nested structs) and keeps cheap ones eager (primitives, enums, `Date`, tiny all-scalar structs); `all` defers every field (best for proxy / filter / forward over large payloads). Skipping or forwarding fields is several× faster than eager and the win grows with payload size. The slot is a single `u64` — `0` = absent, `u64.MAX_VALUE` = materialized, otherwise a packed `(start<<32)|end` source range; a ≤32-bit scalar packs its value into the slot directly (no traced memo field). `@omitnull` / `@omitif` work on lazy fields (null-ness is read from the slot without materializing). A class with a custom `@serializer`/`@deserializer` can't have lazy fields (the transform reports an error). See the Lazy Fields guide for the full API and trade-offs
+- perf(transform): the generated fast-path deserializer (`__DESERIALIZE_FAST`) is split into ~32-field chunk helper methods instead of one unrolled function — for both the straight-line tiers and the `seenAny`-stateful `@omitnull`/`@omitif` tiers (the latter threads `seenAny` across chunk boundaries through the call ABI, packed into the `u64` return alongside `srcStart`). A wide struct previously emitted a single function large enough to crash the Binaryen optimizer ("crashed during optimize") a few hundred fields in; chunked, the fast path stays compilable at any width (verified to 1000 fields) and optimizes faster, since Binaryen's per-function passes are superlinear
+- perf(codegen): dropped `@inline` from the (de)serialize worker functions and removed every `inline.always()` call-site directive. They forced each worker to be copied into every dispatch / call site; as plain shared calls the generated module shrinks (~18% on the all-lazy `large` struct) and the Binaryen `optimize` phase eases. Dispatchers and genuinely small helpers keep `@inline`
+- fix(lazy-fields): the lazy serialize path now `ensureSize`s before the structural key literals, not just the value passthrough. A wide struct (~150 fields, long keys) could overrun the output buffer once a passthrough left it nearly full — `JSON.stringify(JSON.parse<T>(...))` trapped with `unreachable`. The passthrough reserves exactly the slice bytes (unlike eager string serialize, which over-reserves for quotes/escaping), so the key writes that follow needed their own bounds check
+- fix(lazy-fields): a *constructed* (not parsed) instance keeps its declared field defaults. Lazy lowering replaced each field with a slot and dropped its initializer, so `new T()` serialized the type default (`null` / `0`) instead of e.g. `"x"` from `name: string = "x"`; the slot is now seeded in the materialized-default state. `JSON.parse` (which builds via `__new`, skipping field initializers) is unaffected
+- fix(serialize): `@omitnull` / `@omitif` fields emit a **leading** comma gated on a runtime "wrote" flag, not a trailing one. Optional fields sort to the front, so a present field followed by omitted ones — or an all-optional struct — left a dangling trailing comma, i.e. invalid JSON like `{"a":"1",}`. Added a regression test (first / last / gap / all-absent / all-present, plus the mixed-with-regular case)
+- feat: `JSON.Value` moved to a NaN-boxed representation, and its value scanning now runs through the SWAR / SIMD scanners (~60% faster on value-heavy input)
+- bench: committed eager-vs-lazy benchmarks under `assembly/__benches__/lazy/` (deserialize / round-trip / serialize) + `lazy:"auto"` variants of small/medium/large/token/vec3, and a `lazy` json-as struct in the multi-library comparison (`__benches__/multilib/`); charting in `scripts/build-chart15.ts` and the multilib charts
+- docs: Lazy Fields guide + performance charts (eager-vs-lazy by payload size and a multi-library throughput comparison), full JSDoc for the decorators in `assembly/index.d.ts`, and a single shared chart colour palette (`scripts/lib/palette.ts`)
+
+- feat: `JSON.parse<T>(data, out)` — deserialize into an existing object graph instead of allocating a fresh one, symmetric with the existing `JSON.stringify<T>(data, out)`. On the fast path every field is reused in place (nested structs threaded as `dst`, strings `__renew`d only when the byte length changes, arrays keeping capacity), so a steady-state re-parse of the same shape allocates **nothing** after the first call — ~4× on SWAR (~720k → ~2.8M ops/s) and ~4.5× on SIMD on the multilib struct payload, heap `totalDelta` 1,034,240 B → 0. Backward compatible: `out` defaults to a type-correct zero via `__zero<T>()` (branches on `isReference`/`isManaged` at compile time, since a bare `changetype<T>(0)` is a size mismatch for value types like `bool`/`f64`)
+- feat: `JSON.stringify<T>(data, out)` now reuses `out` for composite values (structs, arrays, strings), not just the scalar/`Date` fast paths. The reference serialize branches route their final write through a new `bs.outTo<T>(target)` that overwrites the existing string in place — or `__renew`s when the length differs — instead of `__new`-ing a fresh one via `bs.out`. Zero-alloc serialize on reuse: SWAR ~2.31M → ~2.61M ops/s (~+13%), heap `totalDelta` 882,000 B → 0
+- perf: the fast path (`__DESERIALIZE_FAST`) is now generated for **NAIVE** mode. It was disabled for naive (`requestedFastPath = USE_FAST_PATH && codegenMode !== JSONMode.NAIVE`), so naive always ran `__DESERIALIZE_SLOW` after `__INITIALIZE` had reallocated every field — which meant `parse(data, out)` reuse reallocated the whole graph in naive. Enabling it is purely additive (the slow path remains the fallback for whitespace / reordered / missing-key input): naive fresh parse ~2× (~314k → ~644k ops/s), naive reuse ~6.7× (~316k → ~2.1M) with nested structs/arrays/strings now reused in place. Main suite (10,590) and RFC suite unchanged across all three modes
+- perf: escape-free string **fields** skip the scratch-buffer round-trip in NAIVE. `deserializeStringField_NAIVE` previously copied every char into `bs` then `bs`→field; it now scans for the closing quote without touching `bs` and copies source→field directly when no backslash is present (matching the SWAR/SIMD field paths), diverting to a `bs`-based decode tail only for escaped strings. ~+6% naive fresh parse; SWAR/SIMD already did this
+- fix(build): drop `@inline` from `deserializeStringField_NAIVE`. Once the fast path was enabled for naive (above), this loop-bearing scanner got inlined into every string-field call site inside the `@inline __DESERIALIZE_FAST`, exploding binaryen's optimize phase — `bun run bench:as -- large --mode naive` went to ~118 s in `optimize` alone (the transform itself is ~23 ms). Kept as a single shared function — one call per field — matching the already-non-inline SWAR/SIMD field deserializers. naive `large` build **120.6 s → 8.6 s** asc (full repro 2:17 → ~13.5 s), and it's also ~12% *faster* at runtime (the bloated inline body optimized worse). `__DESERIALIZE_FAST` itself stays `@inline`
+- test: `assembly/__tests__/parseinto.spec.ts` — reuse correctness across all three modes: `parse(data, out)` fully overwrites the target (with pointer-identity asserts that nested structs and arrays are reused, not reallocated), and `stringify(data, out)` reuses the output string in place (same length) and resizes correctly (different length)
+- bench: `json-as-struct-{deserialize,stringify}-reuse.bench.ts` under `__benches__/multilib/` — reuse-path counterparts to the fresh benches, used with `--memory` to confirm the zero-allocation steady state
+
+## 2026-06-01 - v1.3.9
+
+- fix: remove readFileSync which failed under virtual file systems
+
 ## 2026-06-01 - v1.3.8
 
 - feat(strict): the **naive value-path deserializers now reject malformed JSON** instead of silently accepting it (RFC 8259). Numbers (`deserializeFloat_NAIVE`) are validated against the JSON number grammar — no leading zeros, bare `-`, empty fraction/exponent, `+` sign, hex, or trailing garbage (the `NaN`/`Infinity` extension is preserved). Strings (`deserializeString_NAIVE`) reject unescaped control chars, illegal/incomplete escapes, non-hex `\u`, and missing surrounding quotes. The scalar/typed **array scanners** (`f64[]`/`i*[]`/`u*[]`/`bool[]`/`string[]`) were rewritten as strict state machines: `[`-framed, single-comma separated, no leading/trailing/doubled commas, no inter-value garbage. On the JSONTestSuite `n_` corpus (parsed against concrete types, one spec per case in `assembly/__tests__/rfc/`), naive now **rejects 179/188** reject-cases — up from 55 — the remaining 9 being the intentional `NaN`/`Infinity` extension (5) plus arbitrary-`JSON.Value`/formfeed/struct-trailing edges (4). Non-object rejects compile to uncatchable aborts until try-as traces the value path; object rejects (struct `__DESERIALIZE_SLOW`) are catchable today. Main suite (10,557) and curated rfc suite (801) stay green across all three modes

package/README.md

@@ -497,7 +497,7 @@ The following charts compare JSON-AS against JavaScript's native `JSON` implemen
 
 > Note: Benchmarks reflect the **latest version**. Older versions may show different performance.
 >
-> Current local benchmark machine: AMD Ryzen 7 7800X3D (8 cores, 8 threads), 96 MB L3 cache, 32 GB RAM.
+> Current local benchmark machine: Apple M4 Max (16 cores — 12 performance + 4 efficiency), 64 GB RAM, macOS 26.
 >
 > Benchmark results include normal end-to-end work such as allocating the destination object or array before deserializing into it. Raw parser throughput is higher than the published figures because these numbers intentionally include that allocation/setup cost.
 
@@ -537,6 +537,46 @@ The following charts compare JSON-AS against JavaScript's native `JSON` implemen
 <img src="https://raw.githubusercontent.com/JairusSW/json-as/refs/heads/docs/charts/chart10.png" alt="Performance Chart 10">
 </details>
 
+<details>
+<summary>Primitive (de)serialize charts (click to expand)</summary>
+
+<img src="https://raw.githubusercontent.com/JairusSW/json-as/refs/heads/docs/charts/chart11.svg" alt="Primitive serialization performance">
+
+<img src="https://raw.githubusercontent.com/JairusSW/json-as/refs/heads/docs/charts/chart12.svg" alt="Primitive deserialization performance">
+</details>
+
+### Library comparison
+
+How `json-as` stacks up against other JSON libraries on a ~5 KiB GitHub-repo payload: JavaScript's native `JSON` and `fast-json` (each in a fresh V8), plus the `assemblyscript-json` package. The `json-as` bars (generated struct, lazy struct, and dynamic `JSON.Obj`) are averaged across the NAIVE / SWAR / SIMD scan modes.
+
+<img src="https://raw.githubusercontent.com/JairusSW/json-as/refs/heads/docs/charts/chart14.png" alt="Library comparison - deserialize throughput">
+
+<img src="https://raw.githubusercontent.com/JairusSW/json-as/refs/heads/docs/charts/chart13.png" alt="Library comparison - serialize throughput">
+
+### Lazy Fields
+
+Mark a field `@lazy` (or `JSON.Lazy<T>`, or a whole class with `@json({ lazy: "auto" })`) to defer it: its raw JSON slice is stored at parse time and parsed only on first access. Fields you skip are never parsed, and untouched fields pass through their original bytes on serialize. See the [Lazy Fields guide](https://docs.jairus.dev/json-as/guide/lazy-fields) for the full API and trade-offs.
+
+Skipping the deferred fields makes deserialization several times faster, and the win grows with payload size:
+
+<img src="https://raw.githubusercontent.com/JairusSW/json-as/refs/heads/docs/charts/lazy-deserialize.svg" alt="Lazy deserialize: eager vs lazy by payload size">
+
+The proxy / filter / forward case - parse then re-serialize without reading the deferred fields - copies their raw bytes straight through:
+
+<img src="https://raw.githubusercontent.com/JairusSW/json-as/refs/heads/docs/charts/lazy-roundtrip.svg" alt="Lazy round-trip: eager vs lazy by payload size">
+
+Re-emitting a parsed object forwards the untouched fields' raw bytes instead of rebuilding them:
+
+<img src="https://raw.githubusercontent.com/JairusSW/json-as/refs/heads/docs/charts/lazy-serialize.svg" alt="Lazy serialize: eager vs lazy by payload size">
+
+<details>
+<summary>Access-pattern comparison (click to expand)</summary>
+
+Skipping, reading one field, or forwarding is far faster than eager; reading every deferred field costs a little more (the work is deferred, not removed):
+
+<img src="https://raw.githubusercontent.com/JairusSW/json-as/refs/heads/docs/charts/lazy-access-pattern.svg" alt="Lazy access pattern: eager vs lazy">
+</details>
+
 ### Performance Tuning
 
 Instead of using flags for setting options, `json-as` is configured by environmental variables.
@@ -583,6 +623,14 @@ npm run bench:as
 npm run bench:js
 ```
 
+The AS suite includes **lazy variants** — `small.lazy.bench.ts`, `medium.lazy.bench.ts`, `large.lazy.bench.ts`, `token.lazy.bench.ts`, and `vec3.lazy.bench.ts` — which mark their structs `@json({ lazy: "auto" })` and dump to `<name>-lazy` logs, so eager and lazy can be compared side by side. Run one on its own with:
+
+```bash
+bun run bench:as medium.lazy --mode simd
+```
+
+> Note: `large.lazy.bench.ts` stresses the optimizer — `lazy: "auto"` on the ~150-field `Repo` generates a getter and serialize branch per field, which can overrun **stock** Binaryen (it crashes during optimize). Build it with a patched/larger-budget Binaryen, or prefer per-field `@lazy` on very wide schemas.
+
 5. Build charts from the latest local logs:
 
 ```bash

package/assembly/deserialize/index/arbitrary.ts

@@ -1,7 +1,7 @@
 import { JSON } from "../..";
 import { deserializeArray } from "./array";
 import { deserializeBoolean } from "./bool";
-import { deserializeFloat_NAIVE } from "../naive/float";
+import { deserializeFloat } from "./float";
 import { deserializeObject } from "./object";
 import { deserializeString } from "./string";
 import { BRACE_LEFT, BRACKET_LEFT, CHAR_N, QUOTE } from "../../custom/chars";
@@ -17,7 +17,7 @@ export function deserializeArbitrary(
   } else if (firstChar == BRACE_LEFT) {
     return JSON.Value.from(deserializeObject(srcStart, srcEnd, 0));
   } else if (firstChar - 48 <= 9 || firstChar == 45) {
-    return JSON.Value.from(deserializeFloat_NAIVE<f64>(srcStart, srcEnd));
+    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) {

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

@@ -1,18 +1,5 @@
-import {
-  BACK_SLASH,
-  BRACE_LEFT,
-  BRACE_RIGHT,
-  BRACKET_LEFT,
-  BRACKET_RIGHT,
-  CHAR_F,
-  CHAR_N,
-  CHAR_T,
-  COMMA,
-  QUOTE,
-} from "../../../custom/chars";
 import { JSON } from "../../../";
-import { isSpace, scanStringEnd } from "../../../util";
-import { ptrToStr } from "../../../util/ptrToStr";
+import { parseArrayBody } from "../object";
 
 export function deserializeArbitraryArray(
   srcStart: usize,
@@ -22,127 +9,7 @@ export function deserializeArbitraryArray(
   const out = changetype<JSON.Value[]>(
     dst || changetype<usize>(instantiate<JSON.Value[]>()),
   );
-  let lastIndex: usize = 0;
-  let depth: u32 = 0;
-  // if (load<u16>(srcStart) != BRACKET_LEFT)
-  srcStart += 2;
-  while (srcStart < srcEnd) {
-    const code = load<u16>(srcStart);
-    // console.log("code: " + String.fromCharCode(code));
-    if (code == BRACE_LEFT) {
-      lastIndex = srcStart;
-      depth++;
-      srcStart += 2;
-      while (srcStart < srcEnd) {
-        const code = load<u16>(srcStart);
-        if (code == BRACE_RIGHT) {
-          if (--depth == 0) {
-            // @ts-ignore: type
-            out.push(JSON.__deserialize<JSON.Value>(lastIndex, srcStart + 2));
-            // console.log("Value (object): " + ptrToStr(lastIndex, srcStart + 2));
-            break;
-          }
-        } else if (code == BRACE_LEFT) depth++;
-        srcStart += 2;
-      }
-    } else if (code == QUOTE) {
-      lastIndex = srcStart;
-      srcStart = scanStringEnd(srcStart, srcEnd);
-      if (srcStart >= srcEnd)
-        throw new Error("Unterminated string in JSON array");
-      // @ts-ignore: exists
-      out.push(JSON.__deserialize<JSON.Value>(lastIndex, srcStart + 2));
-      srcStart += 2;
-      // console.log("next: " + String.fromCharCode(load<u16>(srcStart)));
-    } else if (code - 48 <= 9 || code == 45) {
-      // console.log("trigger int")
-      lastIndex = srcStart;
-      srcStart += 2;
-      while (srcStart < srcEnd) {
-        const code = load<u16>(srcStart);
-        if (code == COMMA || code == BRACKET_RIGHT || isSpace(code)) {
-          // @ts-ignore: type
-          out.push(JSON.__deserialize<JSON.Value>(lastIndex, srcStart));
-          // console.log("Value (number): " + ptrToStr(lastIndex, srcStart));
-          break;
-        }
-        srcStart += 2;
-      }
-      // console.log("next: " + String.fromCharCode(load<u16>(srcStart)));
-    } else if (code == BRACE_LEFT) {
-      lastIndex = srcStart;
-      depth++;
-      srcStart += 2;
-      while (srcStart < srcEnd) {
-        const code = load<u16>(srcStart);
-        if (code == BRACE_RIGHT) {
-          if (--depth == 0) {
-            // @ts-ignore: type
-            out.push(JSON.__deserialize<JSON.Value>(lastIndex, srcStart + 2));
-            // console.log("Value (object): " + ptrToStr(lastIndex, srcStart + 2));
-            while (isSpace(load<u16>((srcStart += 2)))) {
-              /* empty */
-            }
-            break;
-          }
-        } else if (code == BRACE_LEFT) depth++;
-        srcStart += 2;
-      }
-    } else if (code == BRACKET_LEFT) {
-      lastIndex = srcStart;
-      depth++;
-      srcStart += 2;
-      while (srcStart < srcEnd) {
-        const code = load<u16>(srcStart);
-        if (code == QUOTE) {
-          srcStart = scanStringEnd(srcStart, srcEnd);
-          if (srcStart >= srcEnd)
-            throw new Error("Unterminated string in JSON array");
-        } else if (code == BRACKET_RIGHT) {
-          if (--depth == 0) {
-            // @ts-ignore: type
-            out.push(JSON.__deserialize<JSON.Value>(lastIndex, srcStart + 2));
-            // console.log("Value (array): " + ptrToStr(lastIndex, srcStart + 2));
-            while (isSpace(load<u16>((srcStart += 2)))) {
-              /* empty */
-            }
-            break;
-          }
-        } else if (code == BRACKET_LEFT) depth++;
-        srcStart += 2;
-      }
-    } else if (code == CHAR_T) {
-      if (load<u64>(srcStart) == 28429475166421108) {
-        // @ts-ignore: type
-        out.push(JSON.__deserialize<JSON.Value>(srcStart, (srcStart += 8)));
-        // console.log("Value (bool): " + ptrToStr(srcStart - 8, srcStart));
-        // while (isSpace(load<u16>((srcStart += 2)))) {
-        //   /* empty */
-        // }
-        // console.log("next: " + String.fromCharCode(load<u16>(srcStart)));
-      }
-    } else if (code == CHAR_F) {
-      if (load<u64>(srcStart, 2) == 28429466576093281) {
-        // @ts-ignore: type
-        out.push(JSON.__deserialize<JSON.Value>(srcStart, (srcStart += 10)));
-        // console.log("Value (bool): " + ptrToStr(srcStart - 10, srcStart));
-        // while (isSpace(load<u16>((srcStart += 2)))) {
-        //   /* empty */
-        // }
-        // console.log("next: " + String.fromCharCode(load<u16>(srcStart)));
-      }
-    } else if (code == CHAR_N) {
-      if (load<u64>(srcStart) == 30399761348886638) {
-        // console.log("Value (null): " + ptrToStr(srcStart, srcStart + 8));
-        // @ts-ignore: type
-        out.push(JSON.__deserialize<JSON.Value>(srcStart, (srcStart += 8)));
-        // while (isSpace(load<u16>((srcStart += 2)))) {
-        //   /* empty */
-        // }
-      }
-    }
-    srcStart += 2;
-  }
-  // @ts-ignore: type
+  // Skip the opening '[' and parse elements single-pass until the matching ']'.
+  parseArrayBody(out, srcStart + 2, srcEnd);
   return out;
 }

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

@@ -1,5 +1,6 @@
 import { BRACKET_LEFT, BRACKET_RIGHT } from "../../../custom/chars";
 import { JSON } from "../../../";
+import { parseArrayBody } from "../object";
 
 export function deserializeArrayArray<T extends unknown[][]>(
   srcStart: usize,
@@ -9,9 +10,37 @@ export function deserializeArrayArray<T extends unknown[][]>(
   const out = changetype<nonnull<T>>(
     dst || changetype<usize>(instantiate<T>()),
   );
+
+  // Compile-time: is each inner array a dynamic JSON.Value[] (vs a typed array)?
+  let arbitraryInner = false;
+  if (isManaged<valueof<valueof<T>>>() || isReference<valueof<valueof<T>>>()) {
+    // @ts-ignore: instanceof on the (reference) inner element type
+    arbitraryInner =
+      changetype<nonnull<valueof<valueof<T>>>>(0) instanceof JSON.Value;
+  }
+
+  srcStart += 2; // skip the outer '['
+
+  if (isReference<valueof<valueof<T>>>() && arbitraryInner) {
+    // Single-pass: each inner `[...]` is a JSON.Value[] parsed in one scan
+    // (this also correctly skips ']' inside strings, unlike the depth scan).
+    while (srcStart < srcEnd) {
+      if (load<u16>(srcStart) == BRACKET_LEFT) {
+        const inner = instantiate<JSON.Value[]>();
+        srcStart = parseArrayBody(inner, srcStart + 2, srcEnd);
+        // @ts-ignore: valueof<T> is JSON.Value[] in this branch
+        out.push(changetype<valueof<T>>(changetype<usize>(inner)));
+      } else {
+        srcStart += 2;
+      }
+    }
+    return out;
+  }
+
+  // Typed inner arrays: scan each element's bounds, then hand the exact range
+  // to its generated (bounds-taking) deserializer.
   let lastIndex: usize = 0;
   let depth: u32 = 0;
-  srcStart += 2;
   while (srcStart < srcEnd - 2) {
     const code = load<u16>(srcStart);
     if (code == BRACKET_LEFT && depth++ == 0) {

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

@@ -4,12 +4,7 @@ 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,
 // exponent, or trailing garbage. Throws otherwise.
-// @ts-ignore: inline
-@inline function validateJSONInteger(
-  start: usize,
-  end: usize,
-  signed: bool,
-): void {
+function validateJSONInteger(start: usize, end: usize, signed: bool): void {
   let ptr = start;
   if (ptr < end && load<u16>(ptr) == 45) {
     if (!signed) throw new Error("Invalid JSON number: minus on unsigned");

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

@@ -1,11 +1,7 @@
-import {
-  BRACE_LEFT,
-  BRACE_RIGHT,
-  BRACKET_LEFT,
-  BRACKET_RIGHT,
-} from "../../../custom/chars";
+import { BRACE_LEFT, BRACKET_LEFT, BRACKET_RIGHT } from "../../../custom/chars";
 import { JSON } from "../../..";
 import { isSpace } from "util/string";
+import { deserializeMapBody } from "../map";
 
 export function deserializeMapArray<T extends Map<any, any>[]>(
   srcStart: usize,
@@ -15,8 +11,6 @@ export function deserializeMapArray<T extends Map<any, any>[]>(
   const out = changetype<nonnull<T>>(
     dst || changetype<usize>(instantiate<T>()),
   );
-  let lastIndex: usize = 0;
-  let depth: u32 = 0;
 
   while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
 
@@ -34,14 +28,16 @@ export function deserializeMapArray<T extends Map<any, any>[]>(
         (srcEnd - srcStart).toString(),
     );
 
+  // Each `{...}` map element is parsed in a single pass via deserializeMapBody,
+  // which reports where it ended — no separate scan to find the closing brace.
   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)));
+    if (load<u16>(srcStart) == BRACE_LEFT) {
+      const m = instantiate<valueof<T>>();
+      srcStart = deserializeMapBody<valueof<T>>(srcStart, srcEnd, m);
+      out.push(m);
+    } else {
+      srcStart += 2;
     }
-    srcStart += 2;
   }
   return out;
 }

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

@@ -1,11 +1,7 @@
-import {
-  BRACE_LEFT,
-  BRACE_RIGHT,
-  BRACKET_LEFT,
-  BRACKET_RIGHT,
-} from "../../../custom/chars";
+import { BRACE_LEFT, BRACKET_LEFT, BRACKET_RIGHT } from "../../../custom/chars";
 import { JSON } from "../../..";
 import { isSpace } from "util/string";
+import { parseObjectBody } from "../object";
 
 export function deserializeObjectArray<T extends unknown[]>(
   srcStart: usize,
@@ -15,8 +11,6 @@ export function deserializeObjectArray<T extends unknown[]>(
   const out = changetype<nonnull<T>>(
     dst || changetype<usize>(instantiate<T>()),
   );
-  let lastIndex: usize = 0;
-  let depth: u32 = 0;
 
   while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
 
@@ -34,14 +28,16 @@ export function deserializeObjectArray<T extends unknown[]>(
         (srcEnd - srcStart).toString(),
     );
 
+  // Each `{...}` element is parsed in a single pass via parseObjectBody, which
+  // reports where it ended — no separate scan to find the closing brace.
   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)));
+    if (load<u16>(srcStart) == BRACE_LEFT) {
+      const obj = new JSON.Obj();
+      srcStart = parseObjectBody(obj, srcStart + 2, srcEnd);
+      out.push(changetype<valueof<T>>(changetype<usize>(obj)));
+    } else {
+      srcStart += 2;
     }
-    srcStart += 2;
   }
   return out;
 }

package/assembly/deserialize/naive/float.ts

@@ -7,8 +7,7 @@ import { isSpace } from "../../util";
 // garbage. f64.parse alone is lenient (parses a numeric prefix and ignores the
 // rest), so this guard is what makes the naive value path reject malformed
 // numbers like `0e`, `-01`, `1.`, `2.e3`, `0x42`.
-// @ts-ignore: inline
-@inline function validateJSONNumber(srcStart: usize, srcEnd: usize): void {
+function validateJSONNumber(srcStart: usize, srcEnd: usize): void {
   let ptr = srcStart;
   while (ptr < srcEnd && isSpace(load<u16>(ptr))) ptr += 2;
   let end = srcEnd;
@@ -76,8 +75,7 @@ import { isSpace } from "../../util";
   return f32.parse(ptrToStr(srcStart, srcEnd));
 }
 
-// @ts-ignore: inline
-@inline function scanFloatEnd(srcStart: usize, srcEnd: usize): usize {
+function scanFloatEnd(srcStart: usize, srcEnd: usize): usize {
   let ptr = srcStart;
   if (ptr < srcEnd && load<u16>(ptr) == 45) ptr += 2; // optional minus
 

package/assembly/deserialize/naive/integer.ts

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