json-as 1.3.7 → 1.3.8

package/CHANGELOG.md

@@ -1,5 +1,37 @@
 # 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`

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/index/arbitrary.ts

@@ -1,7 +1,7 @@
 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";
@@ -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<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,18 +1,20 @@
 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,
@@ -25,7 +27,16 @@ export function deserializeArray<T extends unknown[]>(
   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>>()) {
@@ -40,7 +51,11 @@ export function deserializeArray<T extends unknown[]>(
       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>>()) {

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,8 +1,8 @@
 import { JSONMode } from "../..";
 import {
-  deserializeInteger as deserializeInteger_NAIVE,
-  deserializeIntegerField as deserializeIntegerField_NAIVE,
-} from "../simple/integer";
+  deserializeInteger_NAIVE,
+  deserializeIntegerField_NAIVE,
+} from "../naive/integer";
 import {
   deserializeInteger_SWAR,
   deserializeIntegerField_SWAR,

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,7 +1,16 @@
 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(
@@ -16,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,25 +1,35 @@
-import { bytes } from "../../util";
-export {
-  deserializeArrayBuffer,
-  deserializeTypedArray,
-} from "../simple/typedarray";
+import { JSONMode } from "../..";
 import {
-  deserializeArrayBuffer,
-  deserializeTypedArray,
-} from "../simple/typedarray";
+  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(
+export function deserializeArrayBuffer(
   srcStart: usize,
   srcEnd: usize,
   dst: usize = 0,
 ): ArrayBuffer {
-  return deserializeArrayBuffer(srcStart, srcEnd, dst);
+  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,8 +1,8 @@
 import { JSONMode } from "../..";
 import {
-  deserializeUnsigned as deserializeUnsigned_NAIVE,
-  deserializeUnsignedField as deserializeUnsignedField_NAIVE,
-} from "../simple/unsigned";
+  deserializeUnsigned_NAIVE,
+  deserializeUnsignedField_NAIVE,
+} from "../naive/unsigned";
 import {
   deserializeUnsigned_SWAR,
   deserializeUnsignedField_SWAR,

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/naive/array/bool.ts

@@ -0,0 +1,68 @@
+import { isSpace } from "../../../util";
+import {
+  COMMA,
+  BRACKET_LEFT,
+  BRACKET_RIGHT,
+  FALSE_WORD_U64,
+  TRUE_WORD_U64,
+} from "../../../custom/chars";
+
+/**
+ * Strict boolean-array deserializer (`bool[]`, every JSON_MODE).
+ *
+ * Enforces RFC 8259 array structure: `[`-framed, single-comma separated, no
+ * leading / trailing / doubled commas, and each element must be exactly the
+ * literal `true` or `false`. Throws on any deviation.
+ *
+ * The token check is SWAR-shaped: one `u64` load matches all four chars of
+ * `true`; `false` adds one `u16` load to confirm the trailing `e`.
+ */
+export function deserializeBooleanArray<T extends boolean[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): T {
+  const out = changetype<nonnull<T>>(
+    dst || changetype<usize>(instantiate<T>()),
+  );
+  out.length = 0; // dst may arrive pre-sized; re-parse from empty via push
+
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
+  if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT)
+    throw new Error("Invalid JSON array: expected '['");
+  if (load<u16>(srcEnd - 2) != BRACKET_RIGHT)
+    throw new Error("Invalid JSON array: expected ']'");
+  srcStart += 2; // past '['
+  srcEnd -= 2; // before ']'
+
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  if (srcStart >= srcEnd) return out;
+
+  while (true) {
+    if (srcStart + 8 <= srcEnd && load<u64>(srcStart) == TRUE_WORD_U64) {
+      out.push(true);
+      srcStart += 8;
+    } else if (
+      srcStart + 10 <= srcEnd &&
+      load<u64>(srcStart) == FALSE_WORD_U64 &&
+      load<u16>(srcStart, 8) == 101
+    ) {
+      out.push(false);
+      srcStart += 10;
+    } else {
+      throw new Error("Invalid JSON array: expected 'true' or 'false'");
+    }
+
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+    if (srcStart >= srcEnd) break;
+    if (load<u16>(srcStart) != COMMA)
+      throw new Error("Invalid JSON array: expected ',' or ']'");
+    srcStart += 2;
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+    if (srcStart >= srcEnd)
+      throw new Error("Invalid JSON array: trailing comma");
+  }
+
+  return out;
+}

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

@@ -0,0 +1,63 @@
+import { isSpace } from "../../../util";
+import { COMMA, BRACKET_LEFT, BRACKET_RIGHT } from "../../../custom/chars";
+import { JSON } from "../../..";
+
+/**
+ * Strict float-array deserializer (`f64[]` / `f32[]`).
+ *
+ * Enforces RFC 8259 array structure: `[`-framed, single-comma separated, no
+ * leading / trailing / doubled commas, and no garbage between values. Each
+ * element token is validated by `deserializeFloat_NAIVE` (via `JSON.__deserialize`),
+ * so malformed numbers like `0e` / `-01` / `1.` are rejected here too. Throws on
+ * any deviation.
+ */
+export function deserializeFloatArray_NAIVE<T extends number[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): T {
+  const out = changetype<nonnull<T>>(
+    dst || changetype<usize>(instantiate<T>()),
+  );
+  // `dst` may arrive pre-sized (e.g. the SWAR fast path presizes then falls
+  // back here); we re-parse from scratch via push, so start from empty.
+  out.length = 0;
+
+  // Trim surrounding whitespace and require the enclosing brackets.
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
+  if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT)
+    throw new Error("Invalid JSON array: expected '['");
+  if (load<u16>(srcEnd - 2) != BRACKET_RIGHT)
+    throw new Error("Invalid JSON array: expected ']'");
+  srcStart += 2; // past '['
+  srcEnd -= 2; // before ']'
+
+  // skip whitespace; an empty body is a valid empty array
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  if (srcStart >= srcEnd) return out;
+
+  while (true) {
+    // value token: runs until whitespace or a comma
+    const tokenStart = srcStart;
+    while (srcStart < srcEnd) {
+      const c = load<u16>(srcStart);
+      if (c == COMMA || isSpace(c)) break;
+      srcStart += 2;
+    }
+    if (srcStart == tokenStart)
+      throw new Error("Invalid JSON array: missing value");
+    out.push(JSON.__deserialize<valueof<T>>(tokenStart, srcStart));
+
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+    if (srcStart >= srcEnd) break; // end of array body
+    if (load<u16>(srcStart) != COMMA)
+      throw new Error("Invalid JSON array: expected ',' or ']'");
+    srcStart += 2; // past ','
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+    if (srcStart >= srcEnd)
+      throw new Error("Invalid JSON array: trailing comma");
+  }
+
+  return out;
+}

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

@@ -1,7 +1,7 @@
 import { JSON } from "../../..";
 import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
 import { isSpace } from "../../../util";
-import { scanValueEnd } from "../../swar/array/shared";
+import { scanValueEnd } from "../../../util/scanValueEnd";
 
 export function deserializeGenericArray<T extends unknown[]>(
   srcStart: usize,
@@ -13,7 +13,6 @@ export function deserializeGenericArray<T extends unknown[]>(
   );
   out.length = 0;
 
-  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
 
   if (srcStart >= srcEnd)

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

@@ -0,0 +1,86 @@
+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,
+// exponent, or trailing garbage. Throws otherwise.
+// @ts-ignore: inline
+@inline 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");
+    ptr += 2;
+  }
+  if (ptr >= end) throw new Error("Invalid JSON number: expected digit");
+  const first = load<u16>(ptr);
+  if (first == 48) {
+    ptr += 2;
+    if (ptr < end && <u32>(load<u16>(ptr) - 48) <= 9)
+      throw new Error("Invalid JSON number: leading zero");
+  } else if (<u32>(first - 48) <= 9) {
+    ptr += 2;
+    while (ptr < end && <u32>(load<u16>(ptr) - 48) <= 9) ptr += 2;
+  } else {
+    throw new Error("Invalid JSON number: expected digit");
+  }
+  if (ptr != end) throw new Error("Invalid JSON number: not an integer");
+}
+
+/**
+ * Strict integer-array deserializer (`i8[]`..`i64[]`, `u8[]`..`u64[]`).
+ *
+ * Enforces RFC 8259 array structure: `[`-framed, single-comma separated, no
+ * leading / trailing / doubled commas, and each element must be a valid JSON
+ * integer (no leading zeros, fraction, or exponent). Throws on any deviation.
+ */
+export function deserializeIntegerArray_NAIVE<T extends number[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): T {
+  const out = changetype<nonnull<T>>(
+    dst || changetype<usize>(instantiate<T>()),
+  );
+  out.length = 0; // dst may arrive pre-sized; re-parse from empty via push
+
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
+  if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT)
+    throw new Error("Invalid JSON array: expected '['");
+  if (load<u16>(srcEnd - 2) != BRACKET_RIGHT)
+    throw new Error("Invalid JSON array: expected ']'");
+  srcStart += 2; // past '['
+  srcEnd -= 2; // before ']'
+
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  if (srcStart >= srcEnd) return out;
+
+  const signed = isSigned<valueof<T>>();
+  while (true) {
+    const tokenStart = srcStart;
+    while (srcStart < srcEnd) {
+      const c = load<u16>(srcStart);
+      if (c == COMMA || isSpace(c)) break;
+      srcStart += 2;
+    }
+    if (srcStart == tokenStart)
+      throw new Error("Invalid JSON array: missing value");
+    validateJSONInteger(tokenStart, srcStart, signed);
+    out.push(atoi<valueof<T>>(tokenStart, srcStart));
+
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+    if (srcStart >= srcEnd) break;
+    if (load<u16>(srcStart) != COMMA)
+      throw new Error("Invalid JSON array: expected ',' or ']'");
+    srcStart += 2;
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+    if (srcStart >= srcEnd)
+      throw new Error("Invalid JSON array: trailing comma");
+  }
+
+  return out;
+}

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

@@ -18,7 +18,6 @@ export function deserializeMapArray<T extends Map<any, any>[]>(
   let lastIndex: usize = 0;
   let depth: u32 = 0;
 
-  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
 
   if (srcStart - srcEnd == 0)

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

@@ -18,7 +18,6 @@ export function deserializeObjectArray<T extends unknown[]>(
   let lastIndex: usize = 0;
   let depth: u32 = 0;
 
-  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
 
   if (srcStart - srcEnd == 0)