json-as 1.3.5 → 1.3.7

package/CHANGELOG.md

@@ -1,6 +1,22 @@
 # Changelog
 
-## Unreleased
+## 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
+- tooling: fix `bun run bench -- <suite>` argument forwarding so the suite name reaches `run-bench.as.sh` (and `run-bench.js.sh` for non-custom suites) instead of only being passed to `charts:build`
 
 ## 2026-05-08 - 1.3.5
 

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

@@ -6,7 +6,11 @@ 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));

package/assembly/deserialize/index/array.ts

@@ -14,9 +14,16 @@ import { deserializeStructArray } from "../simple/array/struct";
 import { deserializeIntegerArray_SIMD } from "../simd/array/integer";
 import { deserializeIntegerArray_SWAR } from "../swar/array/integer";
 
-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);
   } else if (isBoolean<valueof<T>>()) {
@@ -56,7 +63,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/integer.ts

@@ -1 +1,68 @@
-export { deserializeInteger } from "../simple/integer";
+import { JSONMode } from "../..";
+import {
+  deserializeInteger as deserializeInteger_NAIVE,
+  deserializeIntegerField as deserializeIntegerField_NAIVE,
+} from "../simple/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/string.ts

@@ -4,7 +4,10 @@ import { deserializeString_SIMD } from "../simd/string";
 import { deserializeString_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) {

package/assembly/deserialize/index/typedarray.ts

@@ -1,6 +1,12 @@
 import { bytes } from "../../util";
-export { deserializeArrayBuffer, deserializeTypedArray } from "../simple/typedarray";
-import { deserializeArrayBuffer, deserializeTypedArray } from "../simple/typedarray";
+export {
+  deserializeArrayBuffer,
+  deserializeTypedArray,
+} from "../simple/typedarray";
+import {
+  deserializeArrayBuffer,
+  deserializeTypedArray,
+} from "../simple/typedarray";
 
 
 @inline export function parseArrayBuffer(data: string): ArrayBuffer {
@@ -10,6 +16,10 @@ import { deserializeArrayBuffer, deserializeTypedArray } from "../simple/typedar
 }
 
 
-@inline export function __deserializeArrayBuffer(srcStart: usize, srcEnd: usize, dst: usize = 0): ArrayBuffer {
+@inline export function __deserializeArrayBuffer(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize = 0,
+): ArrayBuffer {
   return deserializeArrayBuffer(srcStart, srcEnd, dst);
 }

package/assembly/deserialize/index/unsigned.ts

@@ -1 +1,78 @@
-export { deserializeUnsigned } from "../simple/unsigned";
+import { JSONMode } from "../..";
+import {
+  deserializeUnsigned as deserializeUnsigned_NAIVE,
+  deserializeUnsignedField as deserializeUnsignedField_NAIVE,
+} from "../simple/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,
+    );
+  }
+}