json-as 1.3.6 → 1.3.8

package/CHANGELOG.md

@@ -1,5 +1,50 @@
 # Changelog
 
+## 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
+- feat(strict): under `JSON_STRICT=true` the generated `__DESERIALIZE_SLOW` object scanner now rejects malformed key positions — an unquoted / single-quoted / numeric key, or garbage after a value with no separating comma — by requiring the first non-space char at each key position to be a string-opening quote, `,`, or `}` (`transform/src/index.ts`). Combined with the existing strict unknown-key-by-value-type guards, this brings RFC 8259 `n_object` coverage to **28/28** (all three modes) in the conformance suite (`assembly/__tests__/rfc/struct-reject.spec.ts`, parsed against one rich all-value-type schema so every guard is generated). Gated on `JSON_STRICT`, so the default lenient build is unchanged
+- test: RFC 8259 accept-side coverage is now complete — all **95** `y_` (must-accept) cases parse via the dynamic `JSON.Value` type (`assembly/__tests__/rfc/accept.spec.ts`) and **31/35** `i_` (impl-defined) cases (`impl.spec.ts`), all green across NAIVE/SWAR/SIMD. The 4 deferred `i_` cases are uncatchable traps (raw UTF-16/BOM byte input, depth-500 nesting). RFC suite now 804 tests across 3 modes
+- fix: tier-1 (the exact byte-template fast path) over-matched whitespace after a colon. For input like `{"k": v}` (a space after the colon but otherwise compact — e.g. Python's `json.dumps` default), tier-1 matched the minified `{"k":` prefix then read the value at a fixed offset that the space shifted, feeding a misaligned pointer to the value deserializer — string fields `abort`ed ("Expected leading quote") and float fields hit `unreachable`. Tier-1 now checks for whitespace after the colon and bails to the (whitespace-tolerant) tier-2 instead of mis-reading. Surfaced via the RFC 8259 conformance work
+- fix: add `bs.reset()` to `lib/as-bs.ts` — restores the shared serialization buffer to a clean state (offset + pause stacks) after a throw aborts a (de)serialize mid-flight, so the next op isn't corrupted by a dangling offset
+- test: begin RFC 8259 conformance coverage from nst/JSONTestSuite as typed specs (`assembly/__tests__/rfc-object.spec.ts`, accept/round-trip cases; see `RFC-DEFERRED.md` for status and the reject-case blocker)
+
+- perf: pretty-printed JSON now stays on the fast path instead of collapsing to the naive scalar deserializer (the "canada 10×"). The transform's `__DESERIALIZE_FAST` gained a whitespace-tolerant **tier 2**: when the exact packed-`u64` byte-template (tier 1) misses on inter-token whitespace, instead of dumping the whole object to `__DESERIALIZE_SLOW` (~5× slower) it re-matches per field using the same packed key constants but skips whitespace between every structural token (`{`, key, `:`, value, `,`, `}`). Minified input never reaches tier 2, so tier 1 keeps peak speed. canada *pretty* deserialize **~139 → ~1,180 MB/s (SWAR)** / **~1,150 MB/s (SIMD)** — on par with minified; on a value-heavy struct tier 2 costs ~1% over tier 1 (worst case ~2× on a 16-field all-primitive struct). The SWAR array bodies (`deserializeArrayArrayBody`, `deserializeFloatArrayBody`, the inline string/object array element loops) were made whitespace-tolerant to match
+- fix: `JSON.parse` / `JSON.__deserialize` accepted a fast-path result only when it consumed *exactly* to `srcEnd`. Pretty files end in a newline, so tier 2 stopped just past the closing `}` and the **entire object silently fell back to the slow path despite a successful parse** — this was the real cause of the pretty penalty (tier 2 alone only moved canada 139 → 220 MB/s; this fix took 220 → ~1,180). The fast path is now accepted when only trailing whitespace remains (`skipWhitespace(fastEnd, srcEnd) == srcEnd`)
+- perf: optional-field structs (`@omitnull` / `@omitif`) get a whitespace-tolerant tier 2 as well — a probe-and-commit variant that matches each field's key with a lookahead cursor and only commits past the separator + key + `:` when it matches, so omitted fields are skipped without consuming input. Previously these structs fell to slow on *any* whitespace. ~1.18× of tier-1 on a pretty 7-field optional struct, vs the ~5× slow path it used to hit
+- fix: enforce a uniform whitespace contract across **every** deserialize handler in all three modes (field and non-field): the entry points (`JSON.parse` / `JSON.__deserialize`) skip leading whitespace once, and every handler now assumes `srcStart` points at the first non-whitespace char and never re-skips it. Removed ~17 now-redundant leading-whitespace trims from composite handlers (naive `object`/`map`/`set` + array/staticarray composites; SWAR array bodies); composites still skip whitespace *internally* since they are the caller for their child values/keys
+- fix: Map and Set struct **fields** did not handle internal whitespace — `deserializeMapBody` had no inter-token skips at all, and `deserializeSetDirect`'s skips were gated behind an `allowWhitespace` flag the field path left `false`. Concrete structs with `Map`/`Set` fields parsed from pretty input silently misparsed (only the generic-box slow path that existing tests exercised handled it). Both now skip whitespace unconditionally
+- fix: `scanValueEnd` (both `util/scanValueEnd.ts` and `swar/array/shared.ts`) now stops a scalar value at trailing whitespace, not just `,`/`]`/`}`. The returned range previously included trailing spaces (e.g. `"1 "`), which the SWAR/SIMD scalar number parsers — assuming `[srcStart,srcEnd)` is the exact value — misparsed (a whitespaced map value `{ "p" : 1 }` deserialized to `-6`). Now matches the already-correct `JSON.Util.scanValueEnd`
+- bench: add `assembly/__benches__/custom/tier-h2h.bench.ts` — tier-1 (minified) vs tier-2 (one leading space, isolating pure path overhead) vs tier-2 (fully pretty), across a value-heavy `medium` struct, a 16-field all-primitive worst case, and an optional-field struct (with a non-optional twin to isolate the `seenAny` tier-1 overhead)
+- test: add concrete-struct whitespace coverage to `whitespace.spec.ts` — tier-2 fast-path structs (nested objects, float/string/object arrays), the optional-field probe path, top-level leading whitespace for every scalar/array type, and one struct touching every field-handler family (scalar/string/nested-object/array/Map/Set) parsed from heavily-whitespaced (leading + internal + trailing) input
+- perf: fully vectorize the SIMD string **field** deserializer. `deserializeStringField_SIMD` previously bailed to `deserializeStringField_SWAR` on the first backslash, so SIMD mode got zero vectorization on escaped struct fields. It now runs a HYBRID escaped scanner — v128 scan for `"`/`\`; escape-bearing blocks use a single whole-block v128 store to copy the plain prefix for free, then decode the escape; clean runs stream the first block then bulk-`memcpy` the remainder (bandwidth-optimal on long sparse runs, no large-input cliff). Validated against run-copy and pure-stream variants across escape densities; ~+10–20% on common small/moderate/sparse cases
+- perf: replace the SWAR string **field** scanner (formerly the run-copy `deserializeEscapedStringScan_SWAR_SplitTuned`) with the same HYBRID strategy, renamed `deserializeEscapedStringField_SWAR`. On the `swar-string-deser-hybrid-h2h` bench: +50–70% dense, +17–22% moderate, +37–48% sparse — the prior run-copy scanner read each plain run twice (scan + `memcpy`)
+- perf/fix: the standalone whole-value scanners (`deserializeString_SWAR` / `deserializeString_SIMD`) also move to the HYBRID strategy, replacing the older "overflow-pattern" SIMD code. Also fixes a latent out-of-bounds read on short escaped strings — the unguarded `srcEnd - 16` underflow is now guarded with `srcEnd >= 16`
+- refactor: route string-field deserialization through the `deserialize/index/string.ts` dispatcher (`deserializeStringField`), matching the integer/unsigned/float field helpers, instead of the transform hard-coding `deserializeStringField_SWAR` / `_SIMD` by `codegenMode`. Adds a real `deserializeStringField_NAIVE` (NAIVE builds previously deserialized struct string fields with the SWAR field scanner) and unifies all three mode variants on the 3-param `(srcStart, srcEnd, dstFieldPtr)` signature
+- refactor: rename the `simple/` (de)serialize implementation directories to `naive/` and carry the mode suffix on the source functions (`*_NAIVE` / `*_SWAR` / `*_SIMD`), eliminating the `as X_NAIVE` import aliases at call sites
+- fix(build): drop `@inline` from `deserializeStringField_SIMD`. As an `@inline` entry it let binaryen inline the loop-bearing escaped scanner into every struct string-field call site, exploding `large` SIMD compile ~24× under `--converge` (4 s → 99 s, 221 KB → 555 KB wasm). Kept as a single shared function (matching the already-non-inline `deserializeStringField_SWAR`); `large` SIMD build is back to ~4 s / 138 KB with unchanged runtime
+- bench: add string-perf benches under `assembly/__benches__/custom/` — `simd-string-deser-scratch-h2h`, `simd-string-deser-variants-h2h`, `simd-string-deser-standalone-h2h`, and `swar-string-deser-hybrid-h2h` (escape-density head-to-heads for the HYBRID scanners); `serialize-string-modes-h2h` (NAIVE/SWAR/SIMD landscape, confirms streaming serialize already beats run-copy 2–6× so no HYBRID change is warranted); and `serialize-string-safety-h2h`, which checks SWAR/SIMD serialize byte-for-byte against NAIVE across 430 adversarial escape/surrogate/boundary-length inputs — confirming the SIMD `store<v128>` overflow stores stay within buffer slack
+
+## 2026-05-20
+
+- perf: unify the SWAR 4-digit kernel across array entry points. `swar/array/integer.ts` and `swar/array/float.ts` now import `parse4Digits_PairMul` from `util/swar-int.ts` (Lemire-style PairMul) instead of defining a local Baseline variant. `JSON.parse<u32[]>` ~27.4 ms/op @ 64 MiB (up ~17% from ~33 ms) and `JSON.parse<Int32Array>` ~29.5 ms/op @ 64 MiB (up ~17% from ~35.6 ms). Float wins are smaller (~2-4%) since dragonbox dominates
+- perf: `deserializeIntegerArrayInto` (the `Array<int>` struct-field path) inlines `parseSignedIntegerSWAR` / `parseUnsignedIntegerSWAR` directly instead of routing through the per-element `deserializeIntegerField` / `deserializeUnsignedField` dispatchers. The element parser is now identical across all three call sites (top-level `JSON.parse<T[]>`, `swar/typedarray.ts`, struct field). Tuning note: array path uses parse4 + scalar even for unsigned — parse8 wins for the single-token struct field where the digit run is aligned, but in arrays the `,` separator lands mid-load and forces a wasted validate, costing ~23% on `u32-64mib`
+- refactor: fold byte-identical `deserializeObjectArrayInto` and `deserializeStructArrayInto` into one shared helper in `swar/array/shared.ts`. The two outer wrappers retain their type-specific names and now delegate; net ~130 lines removed
+- bench: add `assembly/__benches__/custom/u32-array-field.bench.ts` covering the unsigned struct-field path (no existing bench targeted `deserializeIntegerArrayInto` for `Array<u32>`); add `uint8array-512mib.bench.ts` for round-trip throughput at the largest payload AS's GC allows (BLOCK_MAXSIZE = (1<<30)-16, so a managed UTF-16 string maxes out near 1 GiB = 512 MiB of UTF-8). Built via a single `__new` + `memory.copy` to avoid concat/slice peaking past the wasm cap; the deserialize bench drops the source string and runs `__collect()` before the serialize bench so the per-op ~1 GiB output fits. SWAR ~1,350 MB/s deserialize, ~1,130 MB/s serialize at 512 MiB
+
+## 2026-05-19 - 1.3.7
+
+- fix: anchor the json-as transform's import-path rewrite on the *trailing* `json-as` directory via `lastIndexOf`. Under pnpm/yarn-pnp the install path is `.pnpm/json-as@<ver>_<hash>/node_modules/json-as`; the previous `indexOf` matched the version-qualified store directory and leaked it into every emitted runtime import, crashing AS during `program.initialize` (AssertionError at `program.ts:1183`). Flat-npm consumers were unaffected. Test coverage added in `transform/__tests__/normalize-base-rel.test.mjs` (8 layout cases, including pnpm with version+hash). Runnable via `npm run test:transform`
+- perf: `JSON.parse<u8[]>` SWAR / SIMD throughput at ~64 MiB up to ~2.8 GB/s (SWAR) and ~4.6 GB/s (SIMD), up from ~750 MB/s in both modes. SWAR cascades three u64 fast paths (3-/2-/1-digit single-element); SIMD batch-decodes 2 elements per v128 load via `i32x4.dot_i16x8_s` across six (a, b)-width patterns (0x88 / 0x48 / 0x44 / 0x24 / 0x28 / 0x22), falling back to the SWAR cascade for the remainder
+- perf: `JSON.parse<u32[]>` (and other wider integer arrays) now use worst-case `srcLen >> 2` pre-allocation + unchecked direct stores via a `writePtr`, eliminating `Array.push`'s per-element capacity check. ~2.2 GB/s SWAR, ~2.7 GB/s SIMD on the u32-64mib bench (up from ~1.2 GB/s); the same pattern applies to all integer widths. Parse helpers (`parseSignedIntegerSWAR`, `parseUnsignedIntegerSWAR`, signed/unsigned scalar and SIMD variants) now take a `slot: usize` instead of `out: T` and store via `storeSignedInteger` / `storeUnsignedInteger`
+- perf: `JSON.parse<bool[]>` ~10 GB/s across all modes (up from ~1.5 GB/s). Same pre-allocation + unchecked-store pattern; the per-element u64 magic-constant token match stays
+- perf: `JSON.parse<f64[]>` / `JSON.parse<f32[]>` ~870 MB/s, up from ~735 MB/s, via pre-allocation + unchecked stores. The remaining cost is in `f64.parse` itself (Grisu)
+- perf: `JSON.stringify<u8[]>` ~5.1 GB/s, up from ~680 MB/s (7.4×), via a 256-entry UTF-16 LUT that packs the `"DDD,"` representation of each `u8` value into a single u64 plus a parallel byte-count LUT. Trailing comma is overwritten by `]` after the loop. `JSON.stringify<i8[]>` follows the same path with a peeled `-`
+- perf: `JSON.stringify<bool[]>` ~4.6 GB/s, up from ~1.1 GB/s (4.2×), by folding the per-element comma into the element write (`store<u64>(TRUE_COMMA_LO) + store<u16>(0x002c, 8)` for `"true,"`; `store<u64>(FALSE_COMMA_LO) + store<u32>(0x002c_0065, 8)` for `"false,"`)
+- perf: replace AS std's `itoa_buffered` in the integer serialize path with a jeaiii-style forward-writing itoa (`assembly/util/itoa-fast.ts`). The new path uses a 100-entry UTF-16 digit-pair LUT, computes digit count from a width-ladder so `decimalCount32` is no longer a separate call, and `@inline`s into the array loop. `JSON.stringify<i32[]>` ~1.8 GB/s, up from ~1.35 GB/s. Per-width gains range from 1.0× (1-digit) to 3.4× (2-digit) in the head-to-head bench
+- bench: new throughput benches at `assembly/__benches__/custom/{u8,u32,f64,bool}-64mib.bench.ts` for deserialize and `serialize-primitive-arrays.bench.ts` for stringify; head-to-head benches `itoa-h2h.bench.ts` (`itoa_buffered` vs jeaiii) and `parsefloat-h2h.bench.ts` (existing parser vs Lemire-lite at `util/parsefloat-fast.ts` — research, not wired in due to test expectations encoding the existing parser's rounding behaviour)
+- deps: pin `as-test` to `^1.1.10` and `try-as` to `^1.0.1`
+
 ## 2026-05-14 - 1.3.6
 
 - fix: prevent cross-lane borrow propagation in `detect_escapable_u64_swar_safe` and `detect_escapable_u64_swar_unsafe` by ORing `0x0100_0100_0100_0100` into each 16-bit lane before the SWAR subtraction steps, eliminating corrupted output (`\u00\0\0`) when a NUL or other control character precedes a printable character in SWAR string serialization

package/README.md

@@ -493,7 +493,7 @@ The `json-as` library is engineered for **multi-GB/s processing speeds**, levera
 
 ### Comparison to JavaScript
 
-The following charts compare JSON-AS (both SWAR and SIMD variants) against JavaScript's native `JSON` implementation. The published charts are generated locally and pushed to the `docs` branch.
+The following charts compare JSON-AS against JavaScript's native `JSON` implementation. It's as fair as possible and runs on V8's turboshaft optimizer. The published charts are generated locally and pushed to the `docs` branch.
 
 > Note: Benchmarks reflect the **latest version**. Older versions may show different performance.
 >

package/assembly/deserialize/helpers/uint.ts

@@ -1,4 +1,7 @@
-export function deserializeUintScan<T extends number>(src: usize, dst: usize): usize {
+export function deserializeUintScan<T extends number>(
+  src: usize,
+  dst: usize,
+): usize {
   let digit = <T>load<u16>(src) - 48;
   if (digit > 9) abort("Found invalid digit");
   let val = digit;

package/assembly/deserialize/index/arbitrary.ts

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

@@ -1,24 +1,42 @@
 import { JSON, JSONMode } from "../..";
-import { deserializeArbitraryArray } from "../simple/array/arbitrary";
-import { deserializeArrayArray } from "../simple/array/array";
-import { deserializeBooleanArray } from "../simple/array/bool";
-import { deserializeBoxArray } from "../simple/array/box";
-import { deserializeFloatArray } from "../simple/array/float";
-import { deserializeGenericArray } from "../simple/array/generic";
-import { deserializeIntegerArray as deserializeIntegerArray_NAIVE } from "../simple/array/integer";
-import { deserializeMapArray } from "../simple/array/map";
-import { deserializeObjectArray } from "../simple/array/object";
-import { deserializeRawArray } from "../simple/array/raw";
-import { deserializeStringArray } from "../simple/array/string";
-import { deserializeStructArray } from "../simple/array/struct";
+import { deserializeArbitraryArray } from "../naive/array/arbitrary";
+import { deserializeArrayArray } from "../naive/array/array";
+import { deserializeBooleanArray } from "../naive/array/bool";
+import { deserializeBoxArray } from "../naive/array/box";
+import { deserializeFloatArray_NAIVE } from "../naive/array/float";
+import { deserializeGenericArray } from "../naive/array/generic";
+import { deserializeIntegerArray_NAIVE } from "../naive/array/integer";
+import { deserializeMapArray } from "../naive/array/map";
+import { deserializeObjectArray } from "../naive/array/object";
+import { deserializeRawArray } from "../naive/array/raw";
+import { deserializeStringArray_NAIVE } from "../naive/array/string";
+import { deserializeStructArray } from "../naive/array/struct";
 import { deserializeIntegerArray_SIMD } from "../simd/array/integer";
 import { deserializeIntegerArray_SWAR } from "../swar/array/integer";
+import { deserializeFloatArray_SWAR } from "../swar/array/float";
+import { deserializeStringArray_SWAR } from "../swar/array/string";
 
-export { deserializeArrayField, deserializeArrayField as deserializeArrayField_SWAR } from "../swar/array";
+export {
+  deserializeArrayField,
+  deserializeArrayField as deserializeArrayField_SWAR,
+} from "../swar/array";
 
-export function deserializeArray<T extends unknown[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
+export function deserializeArray<T extends unknown[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): T {
   if (isString<valueof<T>>()) {
-    return <T>deserializeStringArray(srcStart, srcEnd, dst);
+    // SWAR/SIMD routes through the same `Into` helper used by the
+    // struct-field path; that helper carries the `null` token fast path
+    // for `(string | null)[]`. NAIVE keeps the naive scanner, which
+    // currently only handles non-nullable string arrays. The naive
+    // variant's static `string[]` return type is bit-identical to
+    // `(string | null)[]` so `changetype<T>` is a runtime no-op.
+    if (JSON_MODE == JSONMode.SWAR || JSON_MODE == JSONMode.SIMD) {
+      return deserializeStringArray_SWAR<T>(srcStart, srcEnd, dst);
+    }
+    return changetype<T>(deserializeStringArray_NAIVE(srcStart, srcEnd, dst));
   } else if (isBoolean<valueof<T>>()) {
     return deserializeBooleanArray<T>(srcStart, srcEnd, dst);
   } else if (isInteger<valueof<T>>()) {
@@ -33,7 +51,11 @@ export function deserializeArray<T extends unknown[]>(srcStart: usize, srcEnd: u
       return deserializeIntegerArray_NAIVE<T>(srcStart, srcEnd, dst);
     }
   } else if (isFloat<valueof<T>>()) {
-    return deserializeFloatArray<T>(srcStart, srcEnd, dst);
+    if (JSON_MODE == JSONMode.SWAR || JSON_MODE == JSONMode.SIMD) {
+      // @ts-ignore: float array branch
+      return deserializeFloatArray_SWAR<T>(srcStart, srcEnd, dst);
+    }
+    return deserializeFloatArray_NAIVE<T>(srcStart, srcEnd, dst);
   } else if (isArray<valueof<T>>()) {
     return deserializeArrayArray<T>(srcStart, srcEnd, dst);
   } else if (isManaged<valueof<T>>() || isReference<valueof<T>>()) {
@@ -56,7 +78,10 @@ export function deserializeArray<T extends unknown[]>(srcStart: usize, srcEnd: u
     } else if (isDefined(type.__DESERIALIZE_CUSTOM)) {
       return deserializeStructArray<T>(srcStart, srcEnd, dst);
       // @ts-ignore: defined by transform
-    } else if (isDefined(type.__DESERIALIZE_SLOW) || isDefined(type.__DESERIALIZE_FAST)) {
+    } else if (
+      isDefined(type.__DESERIALIZE_SLOW) ||
+      isDefined(type.__DESERIALIZE_FAST)
+    ) {
       return deserializeStructArray<T>(srcStart, srcEnd, dst);
     }
     throw new Error("Could not parse array of type " + nameof<T>() + "!");

package/assembly/deserialize/index/bool.ts

@@ -1 +1 @@
-export { deserializeBoolean } from "../simple/bool";
+export { deserializeBoolean } from "../naive/bool";

package/assembly/deserialize/index/date.ts

@@ -1 +1 @@
-export { deserializeDate } from "../simple/date";
+export { deserializeDate } from "../naive/date";

package/assembly/deserialize/index/float.ts

@@ -1 +1,40 @@
-export { deserializeFloat } from "../simple/float";
+import { JSONMode } from "../..";
+import {
+  deserializeFloat_NAIVE,
+  deserializeFloatField_NAIVE,
+} from "../naive/float";
+import {
+  deserializeFloat_SWAR,
+  deserializeFloatField_SWAR,
+} from "../swar/float";
+import {
+  deserializeFloat_SIMD,
+  deserializeFloatField_SIMD,
+} from "../simd/float";
+
+// @ts-ignore: inline
+@inline 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) {
+    return deserializeFloat_NAIVE<T>(srcStart, srcEnd);
+  } else {
+    return deserializeFloat_SWAR<T>(srcStart, srcEnd);
+  }
+}
+
+// @ts-ignore: inline
+@inline export function deserializeFloatField<T extends number>(
+  srcStart: usize,
+  srcEnd: usize,
+  dstObj: usize,
+  dstOffset: usize = 0,
+): usize {
+  if (JSON_MODE == JSONMode.SIMD) {
+    return deserializeFloatField_SIMD<T>(srcStart, srcEnd, dstObj, dstOffset);
+  } else if (JSON_MODE == JSONMode.NAIVE) {
+    return deserializeFloatField_NAIVE<T>(srcStart, srcEnd, dstObj, dstOffset);
+  } else {
+    return deserializeFloatField_SWAR<T>(srcStart, srcEnd, dstObj, dstOffset);
+  }
+}

package/assembly/deserialize/index/integer.ts

@@ -1 +1,68 @@
-export { deserializeInteger } from "../simple/integer";
+import { JSONMode } from "../..";
+import {
+  deserializeInteger_NAIVE,
+  deserializeIntegerField_NAIVE,
+} from "../naive/integer";
+import {
+  deserializeInteger_SWAR,
+  deserializeIntegerField_SWAR,
+} from "../swar/integer";
+import {
+  deserializeInteger_SIMD,
+  deserializeIntegerField_SIMD,
+} from "../simd/integer";
+
+/**
+ * Compile-time dispatch for {@link deserializeInteger_NAIVE},
+ * {@link deserializeInteger_SWAR}, and {@link deserializeInteger_SIMD}
+ * based on `JSON_MODE`.
+ *
+ * @param srcStart Pointer to the first UTF-16 code unit.
+ * @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>(
+  srcStart: usize,
+  srcEnd: usize,
+): T {
+  if (JSON_MODE == JSONMode.SIMD) {
+    return deserializeInteger_SIMD<T>(srcStart, srcEnd);
+  } else if (JSON_MODE == JSONMode.NAIVE) {
+    return deserializeInteger_NAIVE<T>(srcStart, srcEnd);
+  } else {
+    return deserializeInteger_SWAR<T>(srcStart, srcEnd);
+  }
+}
+
+/**
+ * Compile-time dispatch for {@link deserializeIntegerField_NAIVE},
+ * {@link deserializeIntegerField_SWAR}, and
+ * {@link deserializeIntegerField_SIMD} based on `JSON_MODE`.
+ *
+ * @param srcStart  Pointer to the first UTF-16 code unit.
+ * @param srcEnd    Pointer just past the last code unit.
+ * @param dstObj    Destination object pointer.
+ * @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>(
+  srcStart: usize,
+  srcEnd: usize,
+  dstObj: usize,
+  dstOffset: usize = 0,
+): usize {
+  if (JSON_MODE == JSONMode.SIMD) {
+    return deserializeIntegerField_SIMD<T>(srcStart, srcEnd, dstObj, dstOffset);
+  } else if (JSON_MODE == JSONMode.NAIVE) {
+    return deserializeIntegerField_NAIVE<T>(
+      srcStart,
+      srcEnd,
+      dstObj,
+      dstOffset,
+    );
+  } else {
+    return deserializeIntegerField_SWAR<T>(srcStart, srcEnd, dstObj, dstOffset);
+  }
+}

package/assembly/deserialize/index/map.ts

@@ -1 +1 @@
-export { deserializeMap } from "../simple/map";
+export { deserializeMap, deserializeMapField } from "../naive/map";

package/assembly/deserialize/index/object.ts

@@ -1 +1 @@
-export { deserializeObject } from "../simple/object";
+export { deserializeObject } from "../naive/object";

package/assembly/deserialize/index/raw.ts

@@ -1 +1 @@
-export { deserializeRaw } from "../simple/raw";
+export { deserializeRaw } from "../naive/raw";

package/assembly/deserialize/index/set.ts

@@ -1 +1 @@
-export { deserializeSet } from "../simple/set";
+export { deserializeSet, deserializeSetField } from "../naive/set";

package/assembly/deserialize/index/staticarray.ts

@@ -1 +1,4 @@
-export { deserializeStaticArray } from "../simple/staticarray";
+export {
+  deserializeStaticArray,
+  deserializeStaticArrayField,
+} from "../naive/staticarray";

package/assembly/deserialize/index/string.ts

@@ -1,10 +1,22 @@
 import { JSONMode } from "../..";
-import { deserializeString as deserializeString_NAIVE } from "../simple/string";
-import { deserializeString_SIMD } from "../simd/string";
-import { deserializeString_SWAR } from "../swar/string";
+import {
+  deserializeString_NAIVE,
+  deserializeStringField_NAIVE,
+} from "../naive/string";
+import {
+  deserializeString_SIMD,
+  deserializeStringField_SIMD,
+} from "../simd/string";
+import {
+  deserializeString_SWAR,
+  deserializeStringField_SWAR,
+} from "../swar/string";
 
 
-@inline export function deserializeString(srcStart: usize, srcEnd: usize): string {
+@inline export function deserializeString(
+  srcStart: usize,
+  srcEnd: usize,
+): string {
   if (JSON_MODE == JSONMode.SIMD) {
     return deserializeString_SIMD(srcStart, srcEnd);
   } else if (JSON_MODE == JSONMode.NAIVE) {
@@ -13,3 +25,19 @@ import { deserializeString_SWAR } from "../swar/string";
     return deserializeString_SWAR(srcStart, srcEnd);
   }
 }
+
+
+@inline export function deserializeStringField<T extends string | null>(
+  srcStart: usize,
+  srcEnd: usize,
+  dstObj: usize,
+  dstOffset: usize = 0,
+): usize {
+  if (JSON_MODE == JSONMode.SIMD) {
+    return deserializeStringField_SIMD<T>(srcStart, srcEnd, dstObj, dstOffset);
+  } else if (JSON_MODE == JSONMode.NAIVE) {
+    return deserializeStringField_NAIVE<T>(srcStart, srcEnd, dstObj, dstOffset);
+  } else {
+    return deserializeStringField_SWAR<T>(srcStart, srcEnd, dstObj, dstOffset);
+  }
+}

package/assembly/deserialize/index/struct.ts

@@ -1 +1 @@
-export { deserializeStruct } from "../simple/struct";
+export { deserializeStruct } from "../naive/struct";

package/assembly/deserialize/index/typedarray.ts

@@ -1,15 +1,35 @@
-import { bytes } from "../../util";
-export { deserializeArrayBuffer, deserializeTypedArray } from "../simple/typedarray";
-import { deserializeArrayBuffer, deserializeTypedArray } from "../simple/typedarray";
+import { JSONMode } from "../..";
+import {
+  deserializeArrayBuffer_NAIVE,
+  deserializeTypedArray_NAIVE,
+} from "../naive/typedarray";
+import {
+  deserializeArrayBuffer_SWAR,
+  deserializeTypedArray_SWAR,
+} from "../swar/typedarray";
 
+// SWAR/SIMD modes share the same SWAR-only fast path: a single
+// comma-count pass plus inline parsing. The NAIVE path keeps the
+// scalar double-pass implementation for compat.
 
-@inline export function parseArrayBuffer(data: string): ArrayBuffer {
-  const dataSize = bytes(data);
-  const dataPtr = changetype<usize>(data);
-  return deserializeArrayBuffer(dataPtr, dataPtr + dataSize, 0);
+export function deserializeTypedArray<T extends ArrayLike<number>>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize = 0,
+): T {
+  if (JSON_MODE == JSONMode.SWAR || JSON_MODE == JSONMode.SIMD) {
+    return deserializeTypedArray_SWAR<T>(srcStart, srcEnd, dst);
+  }
+  return deserializeTypedArray_NAIVE<T>(srcStart, srcEnd, dst);
 }
 
-
-@inline export function __deserializeArrayBuffer(srcStart: usize, srcEnd: usize, dst: usize = 0): ArrayBuffer {
-  return deserializeArrayBuffer(srcStart, srcEnd, dst);
+export function deserializeArrayBuffer(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize = 0,
+): ArrayBuffer {
+  if (JSON_MODE == JSONMode.SWAR || JSON_MODE == JSONMode.SIMD) {
+    return deserializeArrayBuffer_SWAR(srcStart, srcEnd, dst);
+  }
+  return deserializeArrayBuffer_NAIVE(srcStart, srcEnd, dst);
 }

package/assembly/deserialize/index/unsigned.ts

@@ -1 +1,78 @@
-export { deserializeUnsigned } from "../simple/unsigned";
+import { JSONMode } from "../..";
+import {
+  deserializeUnsigned_NAIVE,
+  deserializeUnsignedField_NAIVE,
+} from "../naive/unsigned";
+import {
+  deserializeUnsigned_SWAR,
+  deserializeUnsignedField_SWAR,
+} from "../swar/integer";
+import {
+  deserializeUnsigned_SIMD,
+  deserializeUnsignedField_SIMD,
+} from "../simd/integer";
+
+/**
+ * Compile-time dispatch for {@link deserializeUnsigned_NAIVE},
+ * {@link deserializeUnsigned_SWAR}, and {@link deserializeUnsigned_SIMD}
+ * based on `JSON_MODE`.
+ *
+ * @param srcStart Pointer to the first UTF-16 code unit.
+ * @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>(
+  srcStart: usize,
+  srcEnd: usize,
+): T {
+  if (JSON_MODE == JSONMode.SIMD) {
+    return deserializeUnsigned_SIMD<T>(srcStart, srcEnd);
+  } else if (JSON_MODE == JSONMode.NAIVE) {
+    return deserializeUnsigned_NAIVE<T>(srcStart, srcEnd);
+  } else {
+    return deserializeUnsigned_SWAR<T>(srcStart, srcEnd);
+  }
+}
+
+/**
+ * Compile-time dispatch for {@link deserializeUnsignedField_NAIVE},
+ * {@link deserializeUnsignedField_SWAR}, and
+ * {@link deserializeUnsignedField_SIMD} based on `JSON_MODE`.
+ *
+ * @param srcStart  Pointer to the first UTF-16 code unit.
+ * @param srcEnd    Pointer just past the last code unit.
+ * @param dstObj    Destination object pointer.
+ * @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>(
+  srcStart: usize,
+  srcEnd: usize,
+  dstObj: usize,
+  dstOffset: usize = 0,
+): usize {
+  if (JSON_MODE == JSONMode.SIMD) {
+    return deserializeUnsignedField_SIMD<T>(
+      srcStart,
+      srcEnd,
+      dstObj,
+      dstOffset,
+    );
+  } else if (JSON_MODE == JSONMode.NAIVE) {
+    return deserializeUnsignedField_NAIVE<T>(
+      srcStart,
+      srcEnd,
+      dstObj,
+      dstOffset,
+    );
+  } else {
+    return deserializeUnsignedField_SWAR<T>(
+      srcStart,
+      srcEnd,
+      dstObj,
+      dstOffset,
+    );
+  }
+}

package/assembly/deserialize/index.ts

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

package/assembly/deserialize/{simple → naive}/array/arbitrary.ts

@@ -1,10 +1,27 @@
-import { BACK_SLASH, BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BRACKET_RIGHT, CHAR_F, CHAR_N, CHAR_T, COMMA, QUOTE } from "../../../custom/chars";
+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";
 
-export function deserializeArbitraryArray(srcStart: usize, srcEnd: usize, dst: usize): JSON.Value[] {
-  const out = changetype<JSON.Value[]>(dst || changetype<usize>(instantiate<JSON.Value[]>()));
+export function deserializeArbitraryArray(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): JSON.Value[] {
+  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)
@@ -31,7 +48,8 @@ export function deserializeArbitraryArray(srcStart: usize, srcEnd: usize, dst: u
     } else if (code == QUOTE) {
       lastIndex = srcStart;
       srcStart = scanStringEnd(srcStart, srcEnd);
-      if (srcStart >= srcEnd) throw new Error("Unterminated string in JSON array");
+      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;
@@ -78,7 +96,8 @@ export function deserializeArbitraryArray(srcStart: usize, srcEnd: usize, dst: u
         const code = load<u16>(srcStart);
         if (code == QUOTE) {
           srcStart = scanStringEnd(srcStart, srcEnd);
-          if (srcStart >= srcEnd) throw new Error("Unterminated string in JSON array");
+          if (srcStart >= srcEnd)
+            throw new Error("Unterminated string in JSON array");
         } else if (code == BRACKET_RIGHT) {
           if (--depth == 0) {
             // @ts-ignore: type

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

@@ -1,8 +1,14 @@
 import { BRACKET_LEFT, BRACKET_RIGHT } from "../../../custom/chars";
 import { JSON } from "../../../";
 
-export function deserializeArrayArray<T extends unknown[][]>(srcStart: usize, srcEnd: usize, dst: usize): T {
-  const out = changetype<nonnull<T>>(dst || changetype<usize>(instantiate<T>()));
+export function deserializeArrayArray<T extends unknown[][]>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): T {
+  const out = changetype<nonnull<T>>(
+    dst || changetype<usize>(instantiate<T>()),
+  );
   let lastIndex: usize = 0;
   let depth: u32 = 0;
   srcStart += 2;