release: v1.3.2

Author: JairusSW

CHANGELOG.md

@@ -2,22 +2,15 @@
 
 ## Unreleased
 
-- feat: support broad `Map<K,V>` key round-trips by encoding non-string keys as quoted JSON key strings and decoding keys back through typed parse
-- feat: allow `JSON.Value` to store and re-serialize built-in typed arrays and `ArrayBuffer`
-- feat: let explicit `__SERIALIZE_CUSTOM` / `__DESERIALIZE_CUSTOM` hooks override built-in typed-array and `ArrayBuffer` handling while keeping generated hooks last
-- feat: support optional JSON shape hints on `@serializer(...)` / `@deserializer(...)` decorators, defaulting to `any` and allowing nullable forms like `string | null`
-- fix: preserve `bs` state across `JSON.internal.stringify(...)` and `JSON.internal.parse(...)`
-- fix: make `JSON.Value` follow built-in subclass rules consistently for typed-array subclasses and custom `@json` subclasses
-- fix: make generated custom serializer wrappers use the provided `ptr` so indirect-call sites like `JSON.Value` serialize correctly
-- fix: stop preloading transform imports through `parser.parseFile(...)`, so repeated `asc()` calls in the same process no longer poison parser state or trip `lookupForeignFile` assertionsfect
-- fix: stop naive string deserialization scratch allocations from growing across repeated large payload parses by using local `ensureSize(...)` scratch capacity instead of serialization-style proposed growth
-- perf: reserve SIMD string serializer buffer growth once per hit block to reduce dense-escape overhead
-- perf: raise the serialization buffer minimum size to 1024 bytes and add adaptive `bs.shrink()`
-- perf: add a packed SWAR `u16_to_hex4_swar` helper for `\uXXXX` emission and use it across simple, SWAR, and SIMD string serializers
-- perf: rewrite float serialization to Dragonbox per-width writers and share them across arrays, typed arrays, `JSON.Value`, and `JSON.stringify`
-- perf: tune the Canada benchmark serialization pipeline with buffered estimates, delimiter helpers, and feature-segment concatenation to eliminate repeated `bs` growth
-- bench: add SWAR hex and SWAR string serializer head-to-head microbenchmarks
-- bench: add SIMD string serializer and SWAR escape/string variant head-to-head benchmarks
+## 2026-04-13 - 1.3.2
+
+- fix: remove the fast double parser dependency and return float deserialization to the local legacy parser path
+- fix: restrict string field destination reuse/renewal to heap-backed strings only and avoid writing into static literal storage
+- perf: reduce branching in string field write paths while preserving heap-backed reuse (`simple`, `swar`, `simd`, and shared `bs.toField`)
+- tests: add string-field regression coverage for literal defaults and heap-backed output pointers
+- tooling: fix d8 bench runner lint issues (`print` global and unused buffer id vars)
+- tooling: align `bench` script to use `charts:build`
+- docs: streamline README benchmark/docs sections and update benchmark chart command references
 
 ## 2026-03-19 - 1.3.0
 

README.md

@@ -552,73 +552,6 @@ Here's a short list:
 
 **JSON_WRITE** (default: "") - Select a series of files to output after transform and optimization passes have completed for easy inspection. Usage: `JSON_WRITE=.path-to-file-a.ts,./path-to-file-b.ts`
 
-### Fast-Path Compatibility Matrix
-
-Fast path applies to generated struct deserialization only (`JSON_USE_FAST_PATH=1`, `JSON_MODE=SWAR|SIMD`).
-
-| Area | Status | Notes |
-| --- | --- | --- |
-| `JSON_MODE=NAIVE` | Not supported | Fast path is only emitted for `SWAR` / `SIMD`. |
-| Canonical minified object layout | Required | No whitespace, canonical generated key order, no extra/missing keys. |
-| Class-level `@deserializer` | Not supported | Custom deserializer takes over. |
-| Class-level `@serializer` | Supported | Does not block fast-path deserialization. |
-| `@alias` fields | Supported | Fast path matches the aliased key names directly. |
-| `@omitnull` fields | Supported | Optional field keys can be absent in canonical order. |
-| `@omitif` fields | Supported | Optional field keys can be absent in canonical order. |
-| Mixed `@omitnull` + `@omitif` | Supported | Supported in fast-path tests. |
-| `@omit` fields | Supported (serialize-side) | Omitted fields are not part of the parse contract. |
-
-Field-type support in fast path:
-
-| Field category | Status | Implementation |
-| --- | --- | --- |
-| Integers / floats / bool | Supported | Direct field parsers. |
-| `string` / nullable string | Supported | SWAR/SIMD string field parser. |
-| Nested generated struct | Supported | Direct nested `__DESERIALIZE` call. |
-| `Array<string>` / `Array<@json class>` | Supported | Specialized direct array paths. |
-| Other `Array<T>` | Supported | Delegated field helper. |
-| `Set<T>` | Supported | Field helper. |
-| `Map<K,V>` | Supported | Field helper (`scanValueEnd` + typed value parse). |
-| `StaticArray<T>` | Supported | Field helper (`scanValueEnd` + static array parse). |
-| `JSON.Raw` | Supported | Direct field path. |
-| `JSON.Value` / `JSON.Obj` | Supported | `scanValueEnd` + `JSON.__deserialize<T>`. |
-| Enums | Supported | `scanValueEnd` + `JSON.__deserialize<Enum>`. |
-| `JSON.Box<T>` | Supported | Direct box-aware field path. |
-| `Date` | Supported | Direct date field path. |
-
-For the detailed evolving list of optimizations and known gaps, see [FAST_PATH_DESERIALIZE.md](./FAST_PATH_DESERIALIZE.md).
-
-### Container Compatibility Matrix
-
-This matrix describes the current **main parser/runtime** behavior (not just fast-path struct parsing).
-
-| Container | Serialization | Deserialization | Notes |
-| --- | --- | --- | --- |
-| `Array<T>` | Broad (`JSON.__serialize<valueof<T>>`) | Selective dispatch by element type | Deserialization supports primitives, nested arrays, `JSON.Value`, `JSON.Box`, `JSON.Obj`, `JSON.Raw`, `Date`, `Set`, `Map`, and `@json`/custom struct types. |
-| `Map<K,V>` | Broad values and broad key types | Broad key types | Non-string keys are encoded as JSON text and then written as JSON object keys (quoted strings). Deserialization decodes key strings back with typed parsing. |
-| `Set<T>` | Broad (`JSON.__serialize<indexof<T>>`) | Broad, element-scan + `JSON.__deserialize<indexof<T>>` for managed/reference types | Primitive element fast branches exist; managed/reference elements are delegated to generic typed deserialization. |
-
-Container-type examples inferred from current code paths:
-
-| Type | Serialize | Deserialize |
-| --- | --- | --- |
-| `Array<JSON.Raw>` | Yes | Yes |
-| `Array<Map<string, i32>>` | Yes | Yes |
-| `Array<Date>` | Yes | Yes |
-| `Array<Set<string>>` | Yes | Yes |
-| `Map<string, Date>` | Yes | Yes |
-| `Map<bool, i32>` | Yes | Yes |
-| `Map<Date, i32>` | Yes | Yes |
-| `Map<@json class, i32>` | Yes | Yes |
-| `Map<i32[], string>` | Yes | Yes |
-| `Set<Date>` | Yes | Yes |
-
-TODO (container coverage):
-
-- decide and document whether array dispatch should also include typed-array/ArrayBuffer element types
-- decide whether to keep broad `Map<K,V>` key support or provide a strict JSON-object-key mode (`string` only)
-- add explicit tests for each matrix row above so support status is locked by CI
-
 ### Running Benchmarks Locally
 
 Benchmarks are run directly on top of `v8` for tighter control over the engine configuration.
@@ -653,19 +586,7 @@ npm run bench:js
 5. Build charts from the latest local logs:
 
 ```bash
-npm run build:charts
-```
-
-6. Publish benchmark charts to the `docs` branch:
-
-```bash
-npm run bench:publish
-```
-
-If you already have fresh logs and only want to rebuild charts and push them:
-
-```bash
-npm run bench:publish -- --no-run
+npm run charts:build
 ```
 
 Or run the full local benchmark flow in one step:

assembly/__tests__/string.spec.ts

@@ -1,5 +1,11 @@
 import { JSON } from "..";
 import { describe, expect } from "as-test";
+import { __heap_base } from "memory";
+
+@json
+class LiteralStringFieldBox {
+  value: string = "alpha";
+}
 
 describe("Should serialize strings - Basic", () => {
   expect(JSON.stringify("abcdefg")).toBe('"abcdefg"');
@@ -230,6 +236,19 @@ describe("Should deserialize strings - Roundtrip", () => {
   }
 });
 
+describe("Should deserialize string fields without mutating literal defaults", () => {
+  const originalLiteral = "alpha";
+  const box = JSON.parse<LiteralStringFieldBox>('{"value":"omega"}');
+  const fresh = new LiteralStringFieldBox();
+
+  expect((changetype<usize>(fresh.value) < __heap_base).toString()).toBe("true");
+  expect((changetype<usize>(box.value) >= __heap_base).toString()).toBe("true");
+  expect(box.value).toBe("omega");
+  expect(originalLiteral).toBe("alpha");
+  expect(fresh.value).toBe("alpha");
+  expect((originalLiteral == box.value).toString()).toBe("false");
+});
+
 describe("Additional regression coverage - primitives and arrays", () => {
   expect(JSON.stringify(JSON.parse<string>('"regression"'))).toBe('"regression"');
   expect(JSON.stringify(JSON.parse<i32>("-42"))).toBe("-42");

assembly/deserialize/simd/string.ts

@@ -1,5 +1,6 @@
 import { bs } from "../../../lib/as-bs";
 import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
+import { __heap_base } from "memory";
 import { QUOTE } from "../../custom/chars";
 import { BACK_SLASH } from "../../custom/chars";
 import { DESERIALIZE_ESCAPE_TABLE, ESCAPE_HEX_TABLE } from "../../globals/tables";
@@ -81,11 +82,13 @@ import { deserializeStringField_SWAR } from "../swar/string";
 
   const current = load<usize>(dstFieldPtr);
   let stringPtr: usize;
-  if (current != 0 && changetype<OBJECT>(current - TOTAL_OVERHEAD).rtSize == byteLength) {
-    stringPtr = current;
-  } else if (current != 0 && current != changetype<usize>("")) {
-    stringPtr = __renew(current, byteLength);
-    store<usize>(dstFieldPtr, stringPtr);
+  if (current >= __heap_base) {
+    if (changetype<OBJECT>(current - TOTAL_OVERHEAD).rtSize == byteLength) {
+      stringPtr = current;
+    } else {
+      stringPtr = __renew(current, byteLength);
+      store<usize>(dstFieldPtr, stringPtr);
+    }
   } else {
     stringPtr = __new(byteLength, idof<string>());
     store<usize>(dstFieldPtr, stringPtr);

assembly/deserialize/simple/float.ts

@@ -1,7 +1,4 @@
 import { ptrToStr } from "../../util/ptrToStr";
-import { fastDoubleParse } from "../../util/fast-double-parser";
-
-const FAST_DOUBLE_SCRATCH = memory.data(8);
 
 // @ts-ignore: inline
 @inline function pow10Fast(exponent: u32): f64 {
@@ -39,17 +36,6 @@ const FAST_DOUBLE_SCRATCH = memory.data(8);
 
 // @ts-ignore: inline
 @inline export function deserializeFloat<T>(srcStart: usize, srcEnd: usize): T {
-  const fastEnd = fastDoubleParse(srcStart, srcEnd, FAST_DOUBLE_SCRATCH);
-  if (fastEnd != 0) {
-    const value = load<f64>(FAST_DOUBLE_SCRATCH);
-    // @ts-ignore
-    const type: T = 0;
-    // @ts-ignore
-    if (type instanceof f64) return <T>value;
-    // @ts-ignore
-    return <T>(<f32>value);
-  }
-
   let negative = false;
   if (load<u16>(srcStart) == 45) {
     negative = true;
@@ -135,17 +121,6 @@ const FAST_DOUBLE_SCRATCH = memory.data(8);
 // @ts-ignore: inline
 @inline export function deserializeFloatField<T extends number>(srcStart: usize, srcEnd: usize, dstObj: usize, dstOffset: usize = 0): usize {
   const fieldPtr = dstObj + dstOffset;
-  const fastEnd = fastDoubleParse(srcStart, srcEnd, FAST_DOUBLE_SCRATCH);
-  if (fastEnd != 0) {
-    const value = load<f64>(FAST_DOUBLE_SCRATCH);
-    if (sizeof<T>() == sizeof<f32>()) {
-      store<f32>(fieldPtr, <f32>value);
-    } else {
-      store<f64>(fieldPtr, value);
-    }
-    return fastEnd;
-  }
-
   let negative = false;
   if (load<u16>(srcStart) == 45) {
     negative = true;

assembly/deserialize/simple/string.ts

@@ -1,4 +1,5 @@
 import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
+import { __heap_base } from "memory";
 import { bs } from "../../../lib/as-bs";
 import { BACK_SLASH, QUOTE } from "../../custom/chars";
 import { DESERIALIZE_ESCAPE_TABLE, ESCAPE_HEX_TABLE } from "../../globals/tables";
@@ -13,11 +14,13 @@ import { hex4_to_u16_swar } from "../../util/swar";
 
   const current = load<usize>(dstFieldPtr);
   let stringPtr: usize;
-  if (current != 0 && changetype<OBJECT>(current - TOTAL_OVERHEAD).rtSize == byteLength) {
-    stringPtr = current;
-  } else if (current != 0 && current != changetype<usize>("")) {
-    stringPtr = __renew(current, byteLength);
-    store<usize>(dstFieldPtr, stringPtr);
+  if (current >= __heap_base) {
+    if (changetype<OBJECT>(current - TOTAL_OVERHEAD).rtSize == byteLength) {
+      stringPtr = current;
+    } else {
+      stringPtr = __renew(current, byteLength);
+      store<usize>(dstFieldPtr, stringPtr);
+    }
   } else {
     stringPtr = __new(byteLength, idof<string>());
     store<usize>(dstFieldPtr, stringPtr);

assembly/deserialize/swar/string.ts

@@ -1,5 +1,6 @@
 import { bs } from "../../../lib/as-bs";
 import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
+import { __heap_base } from "memory";
 import { BACK_SLASH, QUOTE } from "../../custom/chars";
 import { DESERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
 import { hex4_to_u16_swar } from "../../util/swar";
@@ -194,11 +195,13 @@ export function deserializeString_SWAR(srcStart: usize, srcEnd: usize): string {
 
   const current = load<usize>(dstFieldPtr);
   let stringPtr: usize;
-  if (current != 0 && changetype<OBJECT>(current - TOTAL_OVERHEAD).rtSize == byteLength) {
-    stringPtr = current;
-  } else if (current != 0 && current != changetype<usize>("")) {
-    stringPtr = __renew(current, byteLength);
-    store<usize>(dstFieldPtr, stringPtr);
+  if (current >= __heap_base) {
+    if (changetype<OBJECT>(current - TOTAL_OVERHEAD).rtSize == byteLength) {
+      stringPtr = current;
+    } else {
+      stringPtr = __renew(current, byteLength);
+      store<usize>(dstFieldPtr, stringPtr);
+    }
   } else {
     stringPtr = __new(byteLength, idof<string>());
     store<usize>(dstFieldPtr, stringPtr);