json-as 1.3.1 → 1.3.3

package/CHANGELOG.md

@@ -2,32 +2,15 @@
 
 ## Unreleased
 
-- feat: allow `JSON.Value` to store and re-serialize built-in typed arrays and `ArrayBuffer`
-- feat: support `JSON.stringify<ArrayBuffer>(...)` directly without a dedicated helper
-- 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 escaped string deserializers use local `bs` slices so nested parse/custom flows do not clobber active buffer state
-- fix: allow nested `@json` fields that use decorator-based custom deserializers to deserialize correctly from string-valued object properties
-- fix: restore correct object-value end pointers in generated field deserializers so nested maps and custom string-backed fields both deserialize correctly
-- 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: resolve stdlib and `--lib` base classes during transform inheritance so `@json` subclasses of built-ins like `Uint8Array` include inherited fields instead of collapsing to empty objects
-- fix: stop preloading transform imports through `parser.parseFile(...)`, so repeated `asc()` calls in the same process no longer poison parser state or trip `lookupForeignFile` assertions
-- fix: rewrite nested `JSON.parse(...)` calls inside custom serializers and deserializers to `JSON.internal.parse(...)`, matching the existing internal stringify rewrite and documented behavior
-- docs: clarify that custom serializers and deserializers must always produce and consume valid JSON
-- docs: document how subclassing built-in container types behaves, including when `@json` custom overrides take effect
-- 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
-- tests: expand custom serializer/deserializer coverage for nullable fields, multiple custom fields, escaped content, whitespace, and repeated round-trips
-- tests: add a repeated large string-heavy struct parse regression that exercises the naive deserialization scratch path
-- tests: add override coverage for plain and custom subclasses of `Array`, `Map`, `Set`, and typed arrays
-- tests: add `JSON.Value` regressions for undecorated and decorated typed-array subclasses
-- tests: add regression coverage for generated `@json` subclasses inheriting stdlib typed-array fields
-- chore: restrict published package contents to the runtime, declarations, built transform output, and top-level metadata files
-- 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
-- tests: add dedicated SWAR hex helper coverage, including exhaustive full-range round-trip validation
-- bench: add SWAR hex and SWAR string serializer head-to-head microbenchmarks
+## 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
 

package/README.md

@@ -6,6 +6,7 @@
 <summary>Table of Contents</summary>
 
 - [Installation](#installation)
+- [Docs](#docs)
 - [Usage](#usage)
 - [Examples](#examples)
   - [Omitting Fields](#omitting-fields)
@@ -18,6 +19,8 @@
 - [Performance](#performance)
   - [Comparison to JavaScript](#comparison-to-javascript)
   - [Performance Tuning](#performance-tuning)
+  - [Fast-Path Compatibility Matrix](#fast-path-compatibility-matrix)
+  - [Container Compatibility Matrix](#container-compatibility-matrix)
   - [Running Benchmarks Locally](#running-benchmarks-locally)
 - [Debugging](#debugging)
 - [Architecture](#architecture)
@@ -58,6 +61,12 @@ Alternatively, add it to your `asconfig.json`
 
 If you'd like to see the code that the transform generates, run the build step with `DEBUG=true`
 
+## Docs
+
+Full documentation lives at:
+
+<https://docs.jairus.dev/json-as>
+
 ## Usage
 
 ```typescript
@@ -496,26 +505,50 @@ The following charts compare JSON-AS (both SWAR and SIMD variants) against JavaS
 
 <img src="https://raw.githubusercontent.com/JairusSW/json-as/refs/heads/docs/charts/chart02.svg" alt="Performance Chart 2">
 
+<details>
+<summary>String serialize charts (click to expand)</summary>
+
 <img src="https://raw.githubusercontent.com/JairusSW/json-as/refs/heads/docs/charts/chart03.png" alt="Performance Chart 3">
 
+<img src="https://raw.githubusercontent.com/JairusSW/json-as/refs/heads/docs/charts/chart07.png" alt="Performance Chart 7">
+</details>
+
+<details>
+<summary>String deserialize charts (click to expand)</summary>
+
 <img src="https://raw.githubusercontent.com/JairusSW/json-as/refs/heads/docs/charts/chart04.png" alt="Performance Chart 4">
 
+<img src="https://raw.githubusercontent.com/JairusSW/json-as/refs/heads/docs/charts/chart08.png" alt="Performance Chart 8">
+</details>
+
+<details>
+<summary>Object serialize charts (click to expand)</summary>
+
 <img src="https://raw.githubusercontent.com/JairusSW/json-as/refs/heads/docs/charts/chart05.png" alt="Performance Chart 5">
 
+<img src="https://raw.githubusercontent.com/JairusSW/json-as/refs/heads/docs/charts/chart09.png" alt="Performance Chart 9">
+</details>
+
+<details>
+<summary>Object deserialize charts (click to expand)</summary>
+
 <img src="https://raw.githubusercontent.com/JairusSW/json-as/refs/heads/docs/charts/chart06.png" alt="Performance Chart 6">
 
+<img src="https://raw.githubusercontent.com/JairusSW/json-as/refs/heads/docs/charts/chart10.png" alt="Performance Chart 10">
+</details>
+
 ### Performance Tuning
 
 Instead of using flags for setting options, `json-as` is configured by environmental variables.
 Here's a short list:
 
-**JSON_CACHE** (default: 0) - Enables caching costly strings based on hit frequency. May boost string serialization in excess of 22 GB/s.
+**JSON_CACHE** (default: 0) - Enables and sizes string cache. Supports `true|false`, raw bytes (`JSON_CACHE=1048576`), bits (`JSON_CACHE=512kb`, `2mb`, `1gb`), and bytes (`JSON_CACHE=64KB`, `2MB`, `1GB`). May boost string serialization in excess of 22 GB/s.
 
 **JSON_DEBUG** (default: 0) - Sets the debug level. May be within range `0-3`
 
 **JSON_MODE** (default: SWAR) - Selects which mode should be used. Can be `NAIVE,SWAR,SIMD`. Note that `--enable simd` may be required.
 
-**JSON_USE_FAST_PATH** (default: 0) - When set to `1`, the transform emits the fast `__DESERIALIZE` implementation for generated structs. When unset or `0`, it emits only the slow path.
+**JSON_USE_FAST_PATH** (default: 1) - The transform emits the fast `__DESERIALIZE` implementation for generated structs by default. Set to `0`, `false`, `off`, or `no` to force slow-path-only output. See [FAST_PATH_DESERIALIZE.md](./FAST_PATH_DESERIALIZE.md) for the current support matrix, known gaps, and dedicated test command.
 
 **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`
 
@@ -546,32 +579,20 @@ npm install
 4. Run either benchmark suite directly:
 
 ```bash
-./run-bench.as.sh
-./run-bench.js.sh
+npm run bench:as
+npm run bench:js
 ```
 
 5. Build charts from the latest local logs:
 
 ```bash
-./build-charts.sh
-```
-
-6. Publish benchmark charts to the `docs` branch:
-
-```bash
-./publish-benchmarks.sh
+npm run charts:build
 ```
 
-If you already have fresh logs and only want to rebuild charts and push them:
+Or run the full local benchmark flow in one step:
 
 ```bash
-./publish-benchmarks.sh --no-run
-```
-
-Or run the full local publish flow in one step:
-
-```bash
-npm run bench:publish
+npm run bench
 ```
 
 ## Debugging
@@ -584,6 +605,8 @@ npm run bench:publish
 
 For a deep dive into how json-as works internally, including the transform system, optimization modes (NAIVE, SWAR, SIMD), and buffer management, see [ARCHITECTURE.md](./ARCHITECTURE.md).
 
+For a code-oriented repository walkthrough that maps the runtime, transform, tests, and benchmark files to their concrete responsibilities, see [PROJECT_WALKTHROUGH.md](./PROJECT_WALKTHROUGH.md).
+
 ## Contributing
 
 We welcome contributions! Please see [CONTRIBUTING.md](./CONTRIBUTING.md) for guidelines on:
@@ -606,6 +629,7 @@ A few companies and open-source projects use json-as!
 | [Klave](https://klave.com) | Privacy-first platform |
 | [Bifrost](https://github.com/maximhq/bifrost) | Open source project by Maxim HQ |
 | [Massa Labs](https://github.com/massalabs) | Massa blockchain tooling |
+| [Seda Protocol](https://github.com/sedaprotocl) | Wasm-based blockchain VM |
 
 ## License
 

package/assembly/deserialize/index/arbitrary.ts

@@ -1,7 +1,7 @@
 import { JSON } from "../..";
 import { deserializeArray } from "./array";
 import { deserializeBoolean } from "./bool";
-import { deserializeFloat } from "./float";
+import { deserializeFloat } from "../simple/float";
 import { deserializeObject } from "./object";
 import { deserializeString } from "./string";
 import { BRACE_LEFT, BRACKET_LEFT, CHAR_N, QUOTE } from "../../custom/chars";

package/assembly/deserialize/index/array.ts

@@ -4,6 +4,7 @@ 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";
@@ -45,13 +46,17 @@ export function deserializeArray<T extends unknown[]>(srcStart: usize, srcEnd: u
       return deserializeObjectArray<T>(srcStart, srcEnd, dst);
     } else if (type instanceof JSON.Raw) {
       return deserializeRawArray(srcStart, srcEnd, dst) as T;
+    } else if (type instanceof Date) {
+      return deserializeGenericArray<T>(srcStart, srcEnd, dst);
+    } else if (type instanceof Set) {
+      return deserializeGenericArray<T>(srcStart, srcEnd, dst);
     } else if (type instanceof Map) {
       return deserializeMapArray<T>(srcStart, srcEnd, dst);
       // @ts-ignore: defined by transform
     } else if (isDefined(type.__DESERIALIZE_CUSTOM)) {
       return deserializeStructArray<T>(srcStart, srcEnd, dst);
       // @ts-ignore: defined by transform
-    } else if (isDefined(type.__DESERIALIZE)) {
+    } 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/float.ts

@@ -1 +1 @@
-export { deserializeFloat } from "../float";
+export { deserializeFloat } from "../simple/float";

package/assembly/deserialize/index/integer.ts

@@ -1 +1 @@
-export { deserializeInteger } from "../integer";
+export { deserializeInteger } from "../simple/integer";

package/assembly/deserialize/index/unsigned.ts

@@ -1 +1 @@
-export { deserializeUnsigned } from "../unsigned";
+export { deserializeUnsigned } from "../simple/unsigned";

package/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);
@@ -93,6 +96,8 @@ import { deserializeStringField_SWAR } from "../swar/string";
   memory.copy(stringPtr, srcStart, byteLength);
 }
 
+// @ts-expect-error: @inline is a valid decorator
+
 // todo: optimize and stuff. it works, its not pretty. ideally, i'd like this to be (nearly) branchless
 // @ts-expect-error: @inline is a valid decorator
 @inline function deserializeEscapedString_SIMD(payloadStart: usize, escapeStart: usize, srcEnd: usize): string {
@@ -111,16 +116,14 @@ import { deserializeStringField_SWAR } from "../swar/string";
     store<v128>(bs.offset, block);
 
     const eq5C = i16x8.eq(block, SPLAT_5C);
+    let mask = i16x8.bitmask(eq5C);
 
-    // Early exit
-    if (!v128.any_true(eq5C)) {
+    if (mask == 0) {
       srcStart += 16;
       bs.offset += 16;
       continue;
     }
 
-    let mask = i16x8.bitmask(eq5C);
-
     let srcChg: usize = 0;
     let lastLane: usize = 0;
     do {
@@ -207,14 +210,14 @@ export function deserializeString_SIMD(srcStart: usize, srcEnd: usize): string {
 
   while (srcStart < srcEnd16) {
     const block = load<v128>(srcStart);
-    const eq5C = i16x8.eq(block, SPLAT_5C);
+    const mask = i16x8.bitmask(i16x8.eq(block, SPLAT_5C));
 
-    if (!v128.any_true(eq5C)) {
+    if (mask == 0) {
       srcStart += 16;
       continue;
     }
 
-    const laneIdx = usize(ctz(i16x8.bitmask(eq5C)) << 1);
+    const laneIdx = usize(ctz(mask) << 1);
     return inline.always(deserializeEscapedString_SIMD(payloadStart, srcStart + laneIdx, srcEnd));
   }
 
@@ -229,7 +232,8 @@ export function deserializeString_SIMD(srcStart: usize, srcEnd: usize): string {
 }
 
 // @ts-expect-error: @inline is a valid decorator
-@inline export function deserializeStringField_SIMD<T extends string | null>(srcStart: usize, srcEnd: usize, dstFieldPtr: usize): usize {
+@inline export function deserializeStringField_SIMD<T extends string | null>(srcStart: usize, srcEnd: usize, dstObj: usize, dstOffset: usize = 0): usize {
+  const dstFieldPtr = dstObj + dstOffset;
   if (srcStart + 2 > srcEnd || load<u16>(srcStart) != QUOTE) abort("Expected leading quote");
 
   const quotedStart = srcStart;

package/assembly/deserialize/simple/arbitrary.ts

@@ -1,7 +1,7 @@
 import { JSON } from "../..";
 import { deserializeArray } from "./array";
 import { deserializeBoolean } from "./bool";
-import { deserializeFloat } from "../float";
+import { deserializeFloat } from "./float";
 import { deserializeString } from "./string";
 import { deserializeObject } from "./object";
 import { BRACE_LEFT, BRACKET_LEFT, CHAR_N, QUOTE } from "../../custom/chars";

package/assembly/deserialize/simple/array/generic.ts

@@ -0,0 +1,42 @@
+import { JSON } from "../../..";
+import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
+import { isSpace } from "../../../util";
+import { scanValueEnd } from "../../swar/array/shared";
+
+export function deserializeGenericArray<T extends unknown[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
+  const out = changetype<nonnull<T>>(dst || changetype<usize>(instantiate<T>()));
+  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) throw new Error("Input string had zero length or was all whitespace");
+  if (load<u16>(srcStart) != BRACKET_LEFT) throw new Error("Expected '[' at start of array");
+  srcStart += 2;
+
+  while (srcStart < srcEnd) {
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+    if (srcStart >= srcEnd) break;
+
+    if (load<u16>(srcStart) == BRACKET_RIGHT) return out;
+
+    const valueEnd = scanValueEnd(srcStart, srcEnd);
+    if (!valueEnd || valueEnd <= srcStart) break;
+
+    out.push(JSON.__deserialize<valueof<T>>(srcStart, valueEnd));
+    srcStart = valueEnd;
+
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+    if (srcStart >= srcEnd) break;
+
+    const code = load<u16>(srcStart);
+    if (code == COMMA) {
+      srcStart += 2;
+      continue;
+    }
+    if (code == BRACKET_RIGHT) return out;
+    break;
+  }
+
+  throw new Error("Failed to parse JSON!");
+}

package/assembly/deserialize/simple/array.ts

@@ -3,6 +3,7 @@ import { deserializeArbitraryArray } from "./array/arbitrary";
 import { deserializeArrayArray } from "./array/array";
 import { deserializeBooleanArray } from "./array/bool";
 import { deserializeFloatArray } from "./array/float";
+import { deserializeGenericArray } from "./array/generic";
 import { deserializeIntegerArray } from "./array/integer";
 import { deserializeMapArray } from "./array/map";
 import { deserializeStructArray } from "./array/struct";
@@ -42,6 +43,12 @@ export function deserializeArray<T extends unknown[]>(srcStart: usize, srcEnd: u
     } else if (type instanceof JSON.Raw) {
       // @ts-ignore: type
       return deserializeRawArray(srcStart, srcEnd, dst);
+    } else if (type instanceof Date) {
+      // @ts-ignore: type
+      return deserializeGenericArray<T>(srcStart, srcEnd, dst);
+    } else if (type instanceof Set) {
+      // @ts-ignore: type
+      return deserializeGenericArray<T>(srcStart, srcEnd, dst);
     } else if (type instanceof Map) {
       // @ts-ignore: type
       return deserializeMapArray<T>(srcStart, srcEnd, dst);
@@ -49,7 +56,7 @@ 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)) {
+    } 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/{float.ts → simple/float.ts}

@@ -1,7 +1,26 @@
-import { ptrToStr } from "../util/ptrToStr";
+import { ptrToStr } from "../../util/ptrToStr";
 
 // @ts-ignore: inline
 @inline function pow10Fast(exponent: u32): f64 {
+  if (exponent == 0) return 1.0;
+  if (exponent == 1) return 10.0;
+  if (exponent == 2) return 100.0;
+  if (exponent == 3) return 1e3;
+  if (exponent == 4) return 1e4;
+  if (exponent == 5) return 1e5;
+  if (exponent == 6) return 1e6;
+  if (exponent == 7) return 1e7;
+  if (exponent == 8) return 1e8;
+  if (exponent == 9) return 1e9;
+  if (exponent == 10) return 1e10;
+  if (exponent == 11) return 1e11;
+  if (exponent == 12) return 1e12;
+  if (exponent == 13) return 1e13;
+  if (exponent == 14) return 1e14;
+  if (exponent == 15) return 1e15;
+  if (exponent == 16) return 1e16;
+  if (exponent == 17) return 1e17;
+  if (exponent == 18) return 1e18;
   let result = 1.0;
   if (exponent & 1) result *= 1e1;
   if (exponent & 2) result *= 1e2;
@@ -100,7 +119,8 @@ import { ptrToStr } from "../util/ptrToStr";
 }
 
 // @ts-ignore: inline
-@inline export function deserializeFloatField<T extends number>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+@inline export function deserializeFloatField<T extends number>(srcStart: usize, srcEnd: usize, dstObj: usize, dstOffset: usize = 0): usize {
+  const fieldPtr = dstObj + dstOffset;
   let negative = false;
   if (load<u16>(srcStart) == 45) {
     negative = true;

package/assembly/deserialize/{integer.ts → simple/integer.ts}

@@ -1,4 +1,4 @@
-import { atoi } from "../util/atoi";
+import { atoi } from "../../util/atoi";
 
 // @ts-ignore: inline
 @inline export function deserializeInteger<T>(srcStart: usize, srcEnd: usize): T {
@@ -6,7 +6,8 @@ import { atoi } from "../util/atoi";
 }
 
 // @ts-ignore: inline
-@inline export function deserializeIntegerField<T extends number>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+@inline export function deserializeIntegerField<T extends number>(srcStart: usize, srcEnd: usize, dstObj: usize, dstOffset: usize = 0): usize {
+  const fieldPtr = dstObj + dstOffset;
   let negative = false;
   if (load<u16>(srcStart) == 45) {
     negative = true;

package/assembly/deserialize/simple/map.ts

@@ -1,17 +1,17 @@
 import { JSON } from "../..";
 import { BACK_SLASH, COMMA, CHAR_F, BRACE_LEFT, BRACKET_LEFT, CHAR_N, QUOTE, BRACE_RIGHT, BRACKET_RIGHT, CHAR_T, COLON } from "../../custom/chars";
 import { isSpace, isUnescapedQuote, scanStringEnd } from "../../util";
+import { scanValueEnd } from "../swar/array/shared";
 
 // @ts-ignore: Decorator is valid here
-@inline function normalizeQuotes<T>(start: usize, end: usize): T {
-  if (isString<T>()) return JSON.__deserialize<T>(start - 2, end + 2);
-  return JSON.__deserialize<T>(start, end);
+@inline function deserializeMapKey<T>(start: usize, end: usize): T {
+  const keyText = JSON.__deserialize<string>(start - 2, end + 2);
+  if (isString<T>()) return changetype<T>(keyText);
+  return JSON.parse<T>(keyText);
 }
 
 export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd: usize, dst: usize): T {
   const out = changetype<nonnull<T>>(dst || changetype<usize>(instantiate<T>()));
-  // @ts-ignore: type
-  if (!isString<indexof<T>>() && !isInteger<indexof<T>>() && !isFloat<indexof<T>>()) throw new Error("Map key must also be a valid JSON key!");
 
   let keyStart: usize = 0;
   let keyEnd: usize = 0;
@@ -53,7 +53,7 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
         srcStart = scanStringEnd(srcStart, srcEnd);
         if (srcStart >= srcEnd) throw new Error("Unterminated string in JSON object");
         // @ts-ignore: type
-        out.set(normalizeQuotes<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(lastIndex, srcStart + 2));
+        out.set(deserializeMapKey<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(lastIndex, srcStart + 2));
         srcStart += 2;
         keyStart = 0;
         continue;
@@ -65,7 +65,7 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
           if (code == COMMA || code == BRACE_RIGHT || isSpace(code)) {
             // console.log("Value (number): " + ptrToStr(lastIndex, srcStart));
             // @ts-ignore: type
-            out.set(normalizeQuotes<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
+            out.set(deserializeMapKey<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
             // while (isSpace(load<u16>((srcStart += 2)))) {
             //   /* empty */
             // }
@@ -89,7 +89,7 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
             if (--depth == 0) {
               // console.log("Value (object): " + ptrToStr(lastIndex, srcStart + 2));
               // @ts-ignore: type
-              out.set(normalizeQuotes<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 2)));
+              out.set(deserializeMapKey<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 2)));
               // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
               keyStart = 0;
               // while (isSpace(load<u16>(srcStart))) {
@@ -113,7 +113,7 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
             if (--depth == 0) {
               // console.log("Value (array): " + ptrToStr(lastIndex, srcStart + 2));
               // @ts-ignore: type
-              out.set(normalizeQuotes<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 2)));
+              out.set(deserializeMapKey<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 2)));
               // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
               keyStart = 0;
               // while (isSpace(load<u16>((srcStart += 2)))) {
@@ -128,7 +128,7 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
         if (load<u64>(srcStart) == 28429475166421108) {
           // console.log("Value (bool): " + ptrToStr(srcStart, srcStart + 8));
           // @ts-ignore: type
-          out.set(normalizeQuotes<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(srcStart, (srcStart += 8)));
+          out.set(deserializeMapKey<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(srcStart, (srcStart += 8)));
           // while (isSpace(load<u16>((srcStart += 2)))) {
           //   /* empty */
           // }
@@ -140,7 +140,7 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
         if (load<u64>(srcStart, 2) == 28429466576093281) {
           // console.log("Value (bool): " + ptrToStr(srcStart, srcStart + 10));
           // @ts-ignore: type
-          out.set(normalizeQuotes<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(srcStart, (srcStart += 10)));
+          out.set(deserializeMapKey<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(srcStart, (srcStart += 10)));
           // while (isSpace(load<u16>((srcStart += 2)))) {
           //   /* empty */
           // }
@@ -152,7 +152,7 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
         if (load<u64>(srcStart) == 30399761348886638) {
           // console.log("Value (null): " + ptrToStr(srcStart, srcStart + 8));
           // @ts-ignore: type
-          out.set(normalizeQuotes<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(srcStart, (srcStart += 8)));
+          out.set(deserializeMapKey<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(srcStart, (srcStart += 8)));
           // while (isSpace(load<u16>((srcStart += 2)))) {
           /* empty */
           // }
@@ -169,3 +169,53 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
   }
   return out;
 }
+
+
+@inline export function deserializeMapInto<T extends Map<any, any>>(srcStart: usize, srcEnd: usize, out: T): usize {
+  changetype<nonnull<T>>(out).clear();
+
+  if (srcStart >= srcEnd || load<u16>(srcStart) != BRACE_LEFT) throw new Error("Failed to parse JSON!");
+  srcStart += 2;
+  if (srcStart >= srcEnd) throw new Error("Failed to parse JSON!");
+  if (load<u16>(srcStart) == BRACE_RIGHT) return srcStart + 2;
+
+  while (srcStart < srcEnd) {
+    if (load<u16>(srcStart) != QUOTE) break;
+
+    const keyStart = srcStart + 2;
+    const keyEnd = scanStringEnd(srcStart, srcEnd);
+    if (keyEnd >= srcEnd) break;
+
+    srcStart = keyEnd + 2;
+    if (srcStart >= srcEnd || load<u16>(srcStart) != COLON) break;
+    srcStart += 2;
+
+    const valueEnd = scanValueEnd(srcStart, srcEnd);
+    if (!valueEnd || valueEnd <= srcStart) break;
+
+    // @ts-ignore: type
+    changetype<nonnull<T>>(out).set(deserializeMapKey<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(srcStart, valueEnd));
+    srcStart = valueEnd;
+
+    if (srcStart >= srcEnd) break;
+    const code = load<u16>(srcStart);
+    if (code == COMMA) {
+      srcStart += 2;
+      continue;
+    }
+    if (code == BRACE_RIGHT) return srcStart + 2;
+    break;
+  }
+
+  throw new Error("Failed to parse JSON!");
+}
+
+
+@inline export function deserializeMapField<T extends Map<any, any>>(srcStart: usize, srcEnd: usize, dstObj: usize, dstOffset: usize = 0): usize {
+  let out = load<T>(dstObj, dstOffset);
+  if (!changetype<usize>(out)) {
+    out = changetype<T>(instantiate<T>());
+    store<T>(dstObj, out, dstOffset);
+  }
+  return deserializeMapInto<T>(srcStart, srcEnd, out);
+}

package/assembly/deserialize/simple/object.ts

@@ -7,7 +7,7 @@ import { deserializeString_SWAR } from "../swar/string";
 import { deserializeArbitrary } from "./arbitrary";
 import { deserializeArray } from "./array";
 import { deserializeBoolean } from "./bool";
-import { deserializeFloat } from "../float";
+import { deserializeFloat } from "./float";
 import { deserializeString } from "./string";
 
 export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): JSON.Obj {