json-as 1.3.9 → 1.4.0

package/assembly/index.ts

@@ -40,6 +40,7 @@ import {
   deserializeTypedArray,
 } from "./deserialize";
 import {
+  BACK_SLASH,
   BRACE_LEFT,
   BRACE_RIGHT,
   BRACKET_LEFT,
@@ -58,14 +59,102 @@ import {
 } from "./util/dragonbox";
 import { ptrToStr } from "./util/ptrToStr";
 import { atoi, bytes, scanStringEnd } from "./util";
+import { scanValueEnd_SIMD } from "./util/scanValueEndSimd";
+import { scanValueEnd_SWAR } from "./util/scanValueEndSwar";
 
-/**
- * Offset of the 'storage' property in the JSON.Value class.
- */
+// --- NaN-boxing encoding for JSON.Value ----------------------------------
+// JSON.Value packs its type tag and payload into a single 8-byte word.
+// Real f64 values are stored as their raw IEEE-754 bits; every other type is
+// encoded inside a quiet-NaN ("boxed") word: a 5-bit tag (the JSON.Types id,
+// or Struct for @json classes) plus a 45-bit payload holding a 32-bit pointer
+// or a small scalar. 64-bit ints that don't fit the payload are spilled to a
+// heap StaticArray<u64> referenced by the payload pointer and flagged in the
+// sign bit. Only quiet-NaN doubles whose top two mantissa bits are both set
+// collide with the box signature; hardware NaN is 0x7FF8.. so finite/Inf/NaN
+// doubles all pass through untouched.
+//
+// The managed reference packed into the word is traced by JSON.Value.__visit;
+// AssemblyScript only wires that hook for library-declared classes, so the
+// json-as transform marks this source as a library source (see afterParse).
+// @ts-expect-error: Decorator valid here
+@inline const VAL_QNAN: u64 = 0x7ffc000000000000; // boxed signature (quiet NaN)
+// @ts-expect-error: Decorator valid here
+@inline const VAL_TAG_SHIFT: u8 = 45;
+// @ts-expect-error: Decorator valid here
+@inline const VAL_PAYLOAD_MASK: u64 = 0x00001fffffffffff; // low 45 bits
+// @ts-expect-error: Decorator valid here
+@inline const VAL_PTR_MASK: u64 = 0xffffffff; // wasm32 pointer
+// @ts-expect-error: Decorator valid here
+@inline const VAL_BOX64: u64 = 0x8000000000000000; // sign bit: 64-bit int spilled to heap
+// @ts-expect-error: Decorator valid here
+@inline const VAL_NULL: u64 = VAL_QNAN; // tag 0 (Null), payload 0
+// @ts-expect-error: Decorator valid here
+@inline const VAL_I64_LIMIT: i64 = 17592186044416; // 2^44 — inline range is [-2^44, 2^44)
+// @ts-expect-error: Decorator valid here
+@inline const VAL_U64_LIMIT: u64 = 35184372088832; // 2^45 — inline range is [0, 2^45)
+
+// @ts-expect-error: Decorator valid here
+@inline function valBoxed(w: u64): bool {
+  return (w & VAL_QNAN) == VAL_QNAN;
+}
+// @ts-expect-error: Decorator valid here
+@inline function valTag(w: u64): u32 {
+  return <u32>((w >> VAL_TAG_SHIFT) & 0x1f);
+}
+// @ts-expect-error: Decorator valid here
+@inline function valPayload(w: u64): u64 {
+  return w & VAL_PAYLOAD_MASK;
+}
+// @ts-expect-error: Decorator valid here
+@inline function valPtr(w: u64): usize {
+  return <usize>(w & VAL_PTR_MASK);
+}
 // @ts-expect-error: Decorator valid here
-@inline const STORAGE = offsetof<JSON.Value>("storage");
+@inline function valBox(tag: u32, payload: u64): u64 {
+  return (
+    VAL_QNAN | ((<u64>tag) << VAL_TAG_SHIFT) | (payload & VAL_PAYLOAD_MASK)
+  );
+}
+// @ts-expect-error: Decorator valid here
+@inline function valIntTag<T>(): u32 {
+  if (sizeof<T>() == 1) return isSigned<T>() ? JSON.Types.I8 : JSON.Types.U8;
+  if (sizeof<T>() == 2) return isSigned<T>() ? JSON.Types.I16 : JSON.Types.U16;
+  if (sizeof<T>() == 4) return isSigned<T>() ? JSON.Types.I32 : JSON.Types.U32;
+  return isSigned<T>() ? JSON.Types.I64 : JSON.Types.U64;
+}
+
+// Shared zero-length sentinel for JSON.Obj's key buffer, so an empty object
+// allocates no key storage until its first key is inserted. Never mutated.
+// @ts-expect-error: Decorator valid here
+@lazy const EMPTY_KEYS: StaticArray<u16> = new StaticArray<u16>(0);
 
 export namespace JSON {
+  /**
+   * On-demand field marker. `JSON.Lazy<T>` is structurally just `T` (a no-op
+   * type alias), so a field declared `JSON.Lazy<T>` is typed and accessed
+   * exactly like `T`. The transform detects the annotation and defers that
+   * field: its raw JSON slice is stored at parse time and parsed into `T` on
+   * first access (a generated get accessor).
+   */
+  export type Lazy<T> = T;
+
+  /**
+   * Whether a lazy slot's value is JSON null — for `@omitnull` on lazy fields,
+   * without forcing materialization. The slot encodes the state: `u64.MAX_VALUE`
+   * = materialized (null iff the value pointer is 0), `0` = absent (null), any
+   * other value = a not-yet-parsed slice range (null iff it is literally `null`).
+   * @param valPtr pointer of the materialized value (0 when null)
+   * @param lz    the packed slot
+   */
+  // @ts-expect-error: inline
+  @inline export function __lazyIsNull(valPtr: usize, lz: u64): bool {
+    if (lz == u64.MAX_VALUE) return valPtr == 0;
+    if (lz == 0) return true;
+    const hi = <usize>(lz >>> 32);
+    // raw slice of length 4 (8 bytes) equal to the UTF-16 word "null"
+    return <usize>(<u32>lz) - hi == 8 && load<u64>(hi) == 0x006c006c0075006e;
+  }
+
   /**
    * Memory management utilities for the JSON serialization buffer.
    */
@@ -153,17 +242,17 @@ export namespace JSON {
       return NULL_WORD;
     } else if (isString<nonnull<T>>()) {
       serializeString(data as string);
-      return bs.out<string>();
+      return out ? bs.outTo<string>(changetype<usize>(out)) : bs.out<string>();
       // @ts-expect-error: Defined by transform
     } else if (isDefined(data.__SERIALIZE_CUSTOM)) {
       // @ts-expect-error: Defined by transform
       data.__SERIALIZE_CUSTOM();
-      return bs.out<string>();
+      return out ? bs.outTo<string>(changetype<usize>(out)) : bs.out<string>();
       // @ts-expect-error: Defined by transform
     } else if (isDefined(data.__SERIALIZE)) {
       // @ts-expect-error: Defined by transform
-      inline.always(data.__SERIALIZE(changetype<usize>(data)));
-      return bs.out<string>();
+      data.__SERIALIZE(changetype<usize>(data));
+      return out ? bs.outTo<string>(changetype<usize>(out)) : bs.out<string>();
     } else if (data instanceof Date) {
       out = out
         ? changetype<string>(__renew(changetype<usize>(out), 52))
@@ -179,7 +268,7 @@ export namespace JSON {
       return changetype<string>(out);
     } else {
       serializeReference<T>(data);
-      return bs.out<string>();
+      return out ? bs.outTo<string>(changetype<usize>(out)) : bs.out<string>();
     }
   }
 
@@ -188,11 +277,27 @@ export namespace JSON {
    * ```js
    * JSON.parse<T>(data)
    * ```
+   * Pass an existing object as `out` to deserialize into it, reusing its
+   * allocations (symmetric with `stringify<T>(data, out)`). On the fast path the
+   * per-field reuse logic (nested structs reused as `dst`, strings `__renew`d in
+   * place when sizes match, arrays keeping capacity) makes a steady-state
+   * re-parse of the same shape allocate ~nothing after the first call.
    * @param data string
+   * @param out optional existing object to reuse (structs/composites only)
    * @returns T
    */
+  // A type-correct "zero" for any T: null pointer for references, 0/false for
+  // value types. `changetype<T>(0)` alone fails for bool/f64 (size mismatch),
+  // so branch on isReference at compile time.
+  // @ts-ignore: inline
+  @inline function __zero<T>(): T {
+    // @ts-ignore: compile-time intrinsic
+    if (isReference<T>() || isManaged<T>()) return changetype<T>(0);
+    return <T>0;
+  }
+
   // @ts-expect-error: inline
-  @inline export function parse<T>(data: string): T {
+  @inline export function parse<T>(data: string, out: T = __zero<T>()): T {
     let dataPtr = changetype<usize>(data);
     const dataEnd = dataPtr + bytes(data);
     // Entry point skips leading whitespace: every deserialize handler may then
@@ -223,24 +328,27 @@ export namespace JSON {
       let type: nonnull<T> = changetype<nonnull<T>>(0);
       // @ts-expect-error: Defined by transform
       if (isDefined(type.__DESERIALIZE_CUSTOM)) {
-        const out = changetype<nonnull<T>>(0);
+        const obj = changetype<nonnull<T>>(0);
         // @ts-expect-error
-        return out.__DESERIALIZE_CUSTOM(data);
+        return obj.__DESERIALIZE_CUSTOM(data);
         // @ts-expect-error: Defined by transform
       } else if (
         isDefined(type.__DESERIALIZE_SLOW) ||
         isDefined(type.__DESERIALIZE_FAST)
       ) {
-        const out = changetype<nonnull<T>>(
-          __new(offsetof<nonnull<T>>(), idof<nonnull<T>>()),
-        );
+        // Reuse the caller-supplied `out` graph when given; otherwise allocate.
+        const obj = changetype<usize>(out)
+          ? changetype<nonnull<T>>(changetype<usize>(out))
+          : changetype<nonnull<T>>(
+              __new(offsetof<nonnull<T>>(), idof<nonnull<T>>()),
+            );
         // @ts-expect-error: Defined by transform
         if (isDefined(type.__DESERIALIZE_FAST)) {
           // @ts-expect-error: Defined by transform
-          const fastEnd = out.__DESERIALIZE_FAST(
+          const fastEnd = obj.__DESERIALIZE_FAST(
             dataPtr,
             dataPtr + dataSize,
-            out,
+            obj,
           );
           // A non-zero return means the fast path matched; accept it when only
           // trailing whitespace remains (pretty-printed input ends with a
@@ -249,31 +357,37 @@ export namespace JSON {
             fastEnd != 0 &&
             JSON.Util.skipWhitespace(fastEnd, dataPtr + dataSize) ==
               dataPtr + dataSize
-          )
-            return out;
+          ) {
+            // @ts-expect-error: Defined by transform for @lazy-field structs —
+            // pins the source so stored slice ranges stay valid.
+            if (isDefined(obj.__SET_SRC)) obj.__SET_SRC(data);
+            return obj;
+          }
         }
-        if (isDefined(type.__INITIALIZE)) out.__INITIALIZE();
+        if (isDefined(type.__INITIALIZE)) obj.__INITIALIZE();
         // @ts-expect-error: Defined by transform
         if (isDefined(type.__DESERIALIZE_SLOW)) {
           // @ts-expect-error: Defined by transform
-          out.__DESERIALIZE_SLOW(dataPtr, dataPtr + dataSize, out);
-          return out;
+          obj.__DESERIALIZE_SLOW(dataPtr, dataPtr + dataSize, obj);
+          // @ts-expect-error: Defined by transform for @lazy-field structs.
+          if (isDefined(obj.__SET_SRC)) obj.__SET_SRC(data);
+          return obj;
         }
         throw new Error(`No deserialize method defined for type ${type}`);
       }
       if (type instanceof StaticArray) {
         // @ts-expect-error
-        return inline.always(
-          deserializeStaticArray<nonnull<T>>(dataPtr, dataPtr + dataSize, 0),
+        return deserializeStaticArray<nonnull<T>>(
+          dataPtr,
+          dataPtr + dataSize,
+          0,
         );
       } else if (type instanceof Array) {
         // @ts-expect-error
-        return inline.always(
-          deserializeArray<nonnull<T>>(
-            dataPtr,
-            dataPtr + dataSize,
-            changetype<usize>(instantiate<T>()),
-          ),
+        return deserializeArray<nonnull<T>>(
+          dataPtr,
+          dataPtr + dataSize,
+          changetype<usize>(instantiate<T>()),
         );
       } else if (
         type instanceof Int8Array ||
@@ -297,14 +411,10 @@ export namespace JSON {
         return deserializeArrayBuffer(dataPtr, dataPtr + dataSize, 0) as T;
       } else if (type instanceof Set) {
         // @ts-expect-error
-        return inline.always(
-          deserializeSet<nonnull<T>>(dataPtr, dataPtr + dataSize, 0),
-        );
+        return deserializeSet<nonnull<T>>(dataPtr, dataPtr + dataSize, 0);
       } else if (type instanceof Map) {
         // @ts-expect-error
-        return inline.always(
-          deserializeMap<nonnull<T>>(dataPtr, dataPtr + dataSize, 0),
-        );
+        return deserializeMap<nonnull<T>>(dataPtr, dataPtr + dataSize, 0);
       } else if (type instanceof Date) {
         // @ts-expect-error
         return deserializeDate(dataPtr, dataPtr + dataSize);
@@ -313,12 +423,10 @@ export namespace JSON {
         return deserializeRaw(dataPtr, dataPtr + dataSize);
       } else if (type instanceof JSON.Value) {
         // @ts-expect-error
-        return inline.always(
-          deserializeArbitrary(dataPtr, dataPtr + dataSize, 0),
-        );
+        return deserializeArbitrary(dataPtr, dataPtr + dataSize, 0);
       } else if (type instanceof JSON.Obj) {
         // @ts-expect-error
-        return inline.always(deserializeObject(dataPtr, dataPtr + dataSize, 0));
+        return deserializeObject(dataPtr, dataPtr + dataSize, 0);
       } else if (type instanceof JSON.Box) {
         // @ts-expect-error
         return new JSON.Box(parseBox(data, changetype<nonnull<T>>(0).value));
@@ -463,24 +571,39 @@ export namespace JSON {
     /** Map of struct type IDs to their serialization function indices */
     @lazy static METHODS: Map<u32, u32> = new Map<u32, u32>();
 
-    /** The runtime type identifier (see JSON.Types) */
-    public type: u16;
-
-    /** Internal storage for the value (8 bytes, can hold any primitive or pointer) */
-    private storage: u64;
+    /** NaN-boxed word holding both the type tag and the value (8 bytes). */
+    private bits: u64;
 
     private constructor() {
       unreachable();
     }
 
+    /**
+     * The runtime type identifier (see JSON.Types), decoded from the boxed word.
+     * Struct values report `idof<T>() + JSON.Types.Struct`, recovered from the
+     * stored object's runtime header.
+     */
+    get type(): u16 {
+      const w = this.bits;
+      if (!valBoxed(w)) return JSON.Types.F64;
+      const tag = valTag(w);
+      if (tag == JSON.Types.Struct) {
+        const rtId = changetype<OBJECT>(valPtr(w) - TOTAL_OVERHEAD).rtId;
+        return <u16>rtId + JSON.Types.Struct;
+      }
+      return <u16>tag;
+    }
+
     /**
      * Creates an JSON.Value instance with no set value.
      * @returns An instance of JSON.Value.
      */
     @inline static empty(): JSON.Value {
-      return changetype<JSON.Value>(
+      const out = changetype<JSON.Value>(
         __new(offsetof<JSON.Value>(), idof<JSON.Value>()),
       );
+      out.bits = VAL_NULL;
+      return out;
     }
 
     /**
@@ -556,35 +679,37 @@ export namespace JSON {
      * @param value - The value to be set.
      */
     @inline set<T>(value: T): void {
-      this.type = this.getType<T>(value);
-
-      if (value instanceof JSON.Box) this.set(value.value);
-      else if (isBoolean<T>())
-        store<T>(changetype<usize>(this), value, STORAGE);
-      else if (
-        isInteger<T>() &&
-        !isSigned<T>() &&
-        changetype<usize>(value) == 0 &&
-        nameof<T>() == "usize"
-      )
-        store<usize>(changetype<usize>(this), 0, STORAGE);
-      else if (isInteger<T>() || isFloat<T>())
-        store<T>(changetype<usize>(this), value, STORAGE);
-      else if (isNullable<T>() && changetype<usize>(value) === 0)
-        store<usize>(changetype<usize>(this), 0, STORAGE);
-      else if (isString<T>()) store<T>(changetype<usize>(this), value, STORAGE);
-      else if (value instanceof JSON.Raw)
-        store<T>(changetype<usize>(this), value, STORAGE);
-      // @ts-expect-error: supplied by transform
-      else if (isDefined(value.__SERIALIZE) && isManaged<T>(value)) {
+      if (value instanceof JSON.Box) {
+        this.set(value.value);
+      } else if (isBoolean<T>()) {
+        this.bits = valBox(JSON.Types.Bool, value ? 1 : 0);
+      } else if (isInteger<T>() && nameof<T>() == "usize") {
+        // A `usize` of 0 is the null sentinel (see deserializeArbitrary);
+        // any other usize is an ordinary 32-bit unsigned integer.
+        this.bits = value ? valBox(valIntTag<T>(), <u64>value) : VAL_NULL;
+      } else if (isFloat<T>()) {
+        if (sizeof<T>() == 4) {
+          this.bits = valBox(JSON.Types.F32, <u64>reinterpret<u32>(<f32>value));
+        } else {
+          const f = <f64>value;
+          // Canonicalize NaN so it never collides with the box signature.
+          this.bits = isNaN(f) ? 0x7ff8000000000000 : reinterpret<u64>(f);
+        }
+      } else if (isInteger<T>()) {
+        if (sizeof<T>() == 8) this.setWide<T>(value);
+        else this.bits = valBox(valIntTag<T>(), <u64>value);
+      } else if (isNullable<T>() && changetype<usize>(value) === 0) {
+        this.bits = VAL_NULL;
+      } else if (isString<T>()) {
+        this.bits = valBox(JSON.Types.String, <u64>changetype<usize>(value));
+      } else if (value instanceof JSON.Raw) {
+        this.bits = valBox(JSON.Types.Raw, <u64>changetype<usize>(value));
+        // @ts-expect-error: supplied by transform
+      } else if (isDefined(value.__SERIALIZE) && isManaged<T>(value)) {
         // @ts-expect-error
         if (!JSON.Value.METHODS.has(idof<T>()))
           JSON.Value.METHODS.set(idof<T>(), value.__SERIALIZE.index);
-        store<usize>(
-          changetype<usize>(this),
-          changetype<usize>(value),
-          STORAGE,
-        );
+        this.bits = valBox(JSON.Types.Struct, <u64>changetype<usize>(value));
       } else if (
         value instanceof Int8Array ||
         value instanceof Uint8Array ||
@@ -596,20 +721,52 @@ export namespace JSON {
         value instanceof Int64Array ||
         value instanceof Uint64Array ||
         value instanceof Float32Array ||
-        value instanceof Float64Array ||
-        value instanceof ArrayBuffer
-      )
-        store<T>(changetype<usize>(this), value, STORAGE);
-      else if (value instanceof Map) {
+        value instanceof Float64Array
+      ) {
+        this.bits = valBox(
+          JSON.Types.TypedArray,
+          <u64>changetype<usize>(value),
+        );
+      } else if (value instanceof ArrayBuffer) {
+        this.bits = valBox(
+          JSON.Types.ArrayBuffer,
+          <u64>changetype<usize>(value),
+        );
+      } else if (value instanceof Map) {
         if (idof<T>() !== idof<Map<string, JSON.Value>>()) {
           abort("Maps must be of type Map<string, JSON.Value>!");
         }
-        store<T>(changetype<usize>(this), value, STORAGE);
+        this.bits = valBox(JSON.Types.Map, <u64>changetype<usize>(value));
       } else if (value instanceof JSON.Obj) {
-        store<T>(changetype<usize>(this), value, STORAGE);
+        this.bits = valBox(JSON.Types.Object, <u64>changetype<usize>(value));
         // @ts-expect-error
       } else if (isArray<T>() && idof<valueof<T>>() == idof<JSON.Value>()) {
-        store<T>(changetype<usize>(this), value, STORAGE);
+        this.bits = valBox(JSON.Types.Array, <u64>changetype<usize>(value));
+      }
+    }
+
+    /** Encodes a 64-bit integer, spilling to the heap when it exceeds the payload. */
+    private setWide<T>(value: T): void {
+      if (isSigned<T>()) {
+        const v = <i64>value;
+        if (v >= -VAL_I64_LIMIT && v < VAL_I64_LIMIT) {
+          this.bits = valBox(JSON.Types.I64, <u64>v);
+        } else {
+          const box = new StaticArray<u64>(1);
+          unchecked((box[0] = <u64>v));
+          this.bits =
+            valBox(JSON.Types.I64, <u64>changetype<usize>(box)) | VAL_BOX64;
+        }
+      } else {
+        const v = <u64>value;
+        if (v < VAL_U64_LIMIT) {
+          this.bits = valBox(JSON.Types.U64, v);
+        } else {
+          const box = new StaticArray<u64>(1);
+          unchecked((box[0] = v));
+          this.bits =
+            valBox(JSON.Types.U64, <u64>changetype<usize>(box)) | VAL_BOX64;
+        }
       }
     }
 
@@ -618,7 +775,23 @@ export namespace JSON {
      * @returns The encapsulated value.
      */
     @inline get<T>(): T {
-      return load<T>(changetype<usize>(this), STORAGE);
+      const w = this.bits;
+      if (isFloat<T>()) {
+        if (sizeof<T>() == 4) return <T>reinterpret<f32>(<u32>valPayload(w));
+        return <T>reinterpret<f64>(w);
+      } else if (isInteger<T>()) {
+        if (sizeof<T>() == 8) {
+          if (w & VAL_BOX64) return load<T>(valPtr(w));
+          if (isSigned<T>()) return <T>((<i64>(valPayload(w) << 19)) >> 19);
+          return <T>valPayload(w);
+        }
+        return <T>valPayload(w);
+      } else if (isBoolean<T>()) {
+        return <T>valPayload(w);
+      } else if (isReference<T>()) {
+        return changetype<T>(valPtr(w));
+      }
+      return unreachable();
     }
 
     /**
@@ -627,7 +800,7 @@ export namespace JSON {
      * @returns The encapsulated value.
      */
     @inline as<T>(): T {
-      return load<T>(changetype<usize>(this), STORAGE);
+      return this.get<T>();
     }
 
     /**
@@ -709,8 +882,18 @@ export namespace JSON {
 
 
     @unsafe private __visit(cookie: u32): void {
-      if (this.type >= JSON.Types.String) {
-        __visit(load<usize>(changetype<usize>(this), STORAGE), cookie);
+      const w = this.bits;
+      if (!valBoxed(w)) return; // raw f64 holds no reference
+      const tag = valTag(w);
+      // String(13)..ArrayBuffer(19) and Struct all carry a managed pointer;
+      // Raw(1) is intentionally not traced (matches prior behavior).
+      if (tag >= JSON.Types.String) {
+        __visit(valPtr(w), cookie);
+      } else if (
+        (tag == JSON.Types.U64 || tag == JSON.Types.I64) &&
+        w & VAL_BOX64
+      ) {
+        __visit(valPtr(w), cookie); // heap-spilled 64-bit int
       }
     }
   }
@@ -735,8 +918,16 @@ export namespace JSON {
    * ```
    */
   export class Obj {
-    /** Internal storage map */
-    storage: Map<string, JSON.Value> = new Map<string, JSON.Value>();
+    // Keys are packed into one growable buffer, each prefixed by a u16 length
+    // (UTF-16 code units), instead of allocating a heap string per key. Values
+    // are a parallel array. A key -> position index is built lazily on the
+    // first keyed access (never during parsing). Per-object allocation count
+    // matches the previous Map-based storage, while deserialization avoids the
+    // per-key string allocation and hashing entirely.
+    _kbuf: StaticArray<u16> = EMPTY_KEYS;
+    _kused: i32 = 0;
+    _vals: JSON.Value[] = [];
+    private _index: Map<string, i32> | null = null;
 
     constructor() {}
 
@@ -744,16 +935,106 @@ export namespace JSON {
      * Gets the number of key-value pairs in the object.
      */
     @inline get size(): i32 {
-      return this.storage.size;
+      return this._vals.length;
+    }
+
+    /** Grows the key buffer to hold at least `need` code units. */
+    private ensureKeyCap(need: i32): void {
+      const cap = this._kbuf.length;
+      if (cap >= need) return;
+      let n = cap ? cap : 16;
+      while (n < need) n <<= 1;
+      const nb = new StaticArray<u16>(n);
+      if (this._kused)
+        memory.copy(
+          changetype<usize>(nb),
+          changetype<usize>(this._kbuf),
+          (<usize>this._kused) << 1,
+        );
+      this._kbuf = nb;
+    }
+
+    /** Appends a length-prefixed key (from a source memory range). */
+    private pushKeyBytes(keyStart: usize, keyEnd: usize): void {
+      const len = <i32>((keyEnd - keyStart) >> 1);
+      const pos = this._kused;
+      this.ensureKeyCap(pos + 1 + len);
+      const buf = changetype<usize>(this._kbuf);
+      store<u16>(buf + ((<usize>pos) << 1), <u16>len);
+      if (len)
+        memory.copy(
+          buf + ((<usize>(pos + 1)) << 1),
+          keyStart,
+          (<usize>len) << 1,
+        );
+      this._kused = pos + 1 + len;
+    }
+
+    /** Materializes a key string from `len` code units starting at slot `at`. */
+    private makeKey(at: i32, len: i32): string {
+      const out = changetype<string>(__new((<usize>len) << 1, idof<string>()));
+      if (len)
+        memory.copy(
+          changetype<usize>(out),
+          changetype<usize>(this._kbuf) + ((<usize>at) << 1),
+          (<usize>len) << 1,
+        );
+      return out;
     }
 
     /**
-     * Sets a key-value pair in the object.
+     * Appends a key (from a source memory range) and value without a
+     * duplicate-key check. Used by the deserializer — no per-key string
+     * allocation, no hashing.
+     */
+    appendRaw<T>(keyStart: usize, keyEnd: usize, value: T): void {
+      this.pushKeyBytes(keyStart, keyEnd);
+      this._vals.push(JSON.Value.from<T>(value));
+      const idx = this._index;
+      if (idx !== null) {
+        const len = <i32>((keyEnd - keyStart) >> 1);
+        const k = changetype<string>(__new((<usize>len) << 1, idof<string>()));
+        if (len) memory.copy(changetype<usize>(k), keyStart, (<usize>len) << 1);
+        idx.set(k, this._vals.length - 1);
+      }
+    }
+
+    /** Builds (once) and returns the lazy key -> position index. */
+    private buildIndex(): Map<string, i32> {
+      let idx = this._index;
+      if (idx === null) {
+        idx = new Map<string, i32>();
+        const buf = changetype<usize>(this._kbuf);
+        const used = this._kused;
+        let pos = 0;
+        let i = 0;
+        while (pos < used) {
+          const len = <i32>load<u16>(buf + ((<usize>pos) << 1));
+          idx.set(this.makeKey(pos + 1, len), i++);
+          pos += 1 + len;
+        }
+        this._index = idx;
+      }
+      return idx;
+    }
+
+    /**
+     * Sets a key-value pair in the object, overwriting any existing value.
      * @param key - The string key
      * @param value - The value (will be wrapped in JSON.Value)
      */
-    @inline set<T>(key: string, value: T): void {
-      this.storage.set(key, JSON.Value.from<T>(value));
+    set<T>(key: string, value: T): void {
+      const idx = this.buildIndex();
+      if (idx.has(key)) {
+        unchecked((this._vals[idx.get(key)] = JSON.Value.from<T>(value)));
+      } else {
+        this.pushKeyBytes(
+          changetype<usize>(key),
+          changetype<usize>(key) + ((<usize>key.length) << 1),
+        );
+        this._vals.push(JSON.Value.from<T>(value));
+        idx.set(key, this._vals.length - 1);
+      }
     }
 
     /**
@@ -762,8 +1043,8 @@ export namespace JSON {
      * @returns The JSON.Value or null if not found
      */
     @inline get(key: string): JSON.Value | null {
-      if (!this.storage.has(key)) return null;
-      return this.storage.get(key);
+      const idx = this.buildIndex();
+      return idx.has(key) ? unchecked(this._vals[idx.get(key)]) : null;
     }
 
     /**
@@ -772,7 +1053,7 @@ export namespace JSON {
      * @returns true if the key exists
      */
     @inline has(key: string): bool {
-      return this.storage.has(key);
+      return this.buildIndex().has(key);
     }
 
     /**
@@ -780,24 +1061,53 @@ export namespace JSON {
      * @param key - The key to delete
      * @returns true if the key was found and deleted
      */
-    @inline delete(key: string): bool {
-      return this.storage.delete(key);
+    delete(key: string): bool {
+      const idx = this.buildIndex();
+      if (!idx.has(key)) return false;
+      const removed = idx.get(key);
+      const keys = this.keys();
+      const vals = this._vals;
+      this._kbuf = EMPTY_KEYS;
+      this._kused = 0;
+      const newVals = new Array<JSON.Value>();
+      for (let j = 0; j < keys.length; j++) {
+        if (j == removed) continue;
+        const k = unchecked(keys[j]);
+        this.pushKeyBytes(
+          changetype<usize>(k),
+          changetype<usize>(k) + ((<usize>k.length) << 1),
+        );
+        newVals.push(unchecked(vals[j]));
+      }
+      this._vals = newVals;
+      this._index = null;
+      return true;
     }
 
     /**
      * Gets all keys in the object.
-     * @returns Array of string keys
+     * @returns Array of string keys (in insertion order)
      */
-    @inline keys(): string[] {
-      return this.storage.keys();
+    keys(): string[] {
+      const out = new Array<string>(this._vals.length);
+      const buf = changetype<usize>(this._kbuf);
+      const used = this._kused;
+      let pos = 0;
+      let i = 0;
+      while (pos < used) {
+        const len = <i32>load<u16>(buf + ((<usize>pos) << 1));
+        unchecked((out[i++] = this.makeKey(pos + 1, len)));
+        pos += 1 + len;
+      }
+      return out;
     }
 
     /**
      * Gets all values in the object.
-     * @returns Array of JSON.Value instances
+     * @returns Array of JSON.Value instances (in insertion order)
      */
     @inline values(): JSON.Value[] {
-      return this.storage.values();
+      return this._vals.slice();
     }
 
     /**
@@ -813,7 +1123,7 @@ export namespace JSON {
      * @param value - The value to convert
      * @returns A new JSON.Obj instance
      */
-    @inline static from<T>(value: T): JSON.Obj {
+    static from<T>(value: T): JSON.Obj {
       if (value instanceof JSON.Obj) return value;
       if (value instanceof Map) {
         const out = new JSON.Obj();
@@ -933,7 +1243,7 @@ export namespace JSON {
       serializeStruct(changetype<nonnull<T>>(data));
     } else if (data instanceof Date) {
       // @ts-expect-error
-      inline.always(serializeDate(changetype<nonnull<T>>(data)));
+      serializeDate(changetype<nonnull<T>>(data));
     } else {
       serializeReference<T>(data);
     }
@@ -1085,55 +1395,71 @@ export namespace JSON {
       return srcStart;
     }
     // @ts-expect-error: decorator
-    @inline export function scanValueEnd(
-      srcStart: usize,
-      srcEnd: usize,
-    ): usize {
-      if (srcStart >= srcEnd) return 0;
-      let ptr = srcStart;
-      while (ptr < srcEnd && isSpace(load<u16>(ptr))) ptr += 2;
-      if (ptr >= srcEnd) return 0;
-      const first = load<u16>(ptr);
-
-      if (first == QUOTE) {
-        const endQuote = scanStringEnd(ptr, srcEnd);
-        return endQuote >= srcEnd ? 0 : endQuote + 2;
-      }
-
-      if (first == BRACE_LEFT || first == BRACKET_LEFT) {
-        let depth: i32 = 1;
-        ptr += 2;
-        while (ptr < srcEnd) {
-          const code = load<u16>(ptr);
-          if (code == QUOTE) {
-            const endQuote = scanStringEnd(ptr, srcEnd);
-            if (endQuote >= srcEnd) return 0;
-            ptr = endQuote + 2;
-            continue;
-          }
-          if (code == BRACE_LEFT || code == BRACKET_LEFT) {
-            depth++;
-          } else if (code == BRACE_RIGHT || code == BRACKET_RIGHT) {
-            if (--depth == 0) return ptr + 2;
-          }
-          ptr += 2;
-        }
-        return 0;
-      }
-
+    @inline function scanQuotedValueEnd(srcStart: usize, srcEnd: usize): usize {
+      const endQuote = scanStringEnd(srcStart, srcEnd);
+      return endQuote >= srcEnd ? 0 : endQuote + 2;
+    }
+    function scanCompositeValueEnd(srcStart: usize, srcEnd: usize): usize {
+      let depth: i32 = 1;
+      let ptr = srcStart + 2;
       while (ptr < srcEnd) {
         const code = load<u16>(ptr);
+        if (code == QUOTE) {
+          ptr = scanQuotedValueEnd(ptr, srcEnd);
+          if (!ptr) return 0;
+          continue;
+        }
+        if (code == BRACE_LEFT || code == BRACKET_LEFT) {
+          depth++;
+        } else if (code == BRACE_RIGHT || code == BRACKET_RIGHT) {
+          if (--depth == 0) return ptr + 2;
+        }
+        ptr += 2;
+      }
+      return 0;
+    }
+    function scanScalarValueEnd(srcStart: usize, srcEnd: usize): usize {
+      while (srcStart < srcEnd) {
+        const code = load<u16>(srcStart);
         if (
           code == COMMA ||
           code == BRACKET_RIGHT ||
           code == BRACE_RIGHT ||
           isSpace(code)
         )
-          return ptr;
-        ptr += 2;
+          return srcStart;
+        srcStart += 2;
       }
 
-      return ptr;
+      return srcStart;
+    }
+    // @ts-expect-error: decorator
+    @inline export function scanValueEnd<T = JSON.Value>(
+      srcStart: usize,
+      srcEnd: usize,
+    ): usize {
+      if (srcStart >= srcEnd) return 0;
+      let ptr = skipWhitespace(srcStart, srcEnd);
+      if (ptr >= srcEnd) return 0;
+
+      if (ASC_FEATURE_SIMD) return scanValueEnd_SIMD<T>(ptr, srcEnd);
+      if (JSON_MODE == JSONMode.SWAR) return scanValueEnd_SWAR<T>(ptr, srcEnd);
+
+      const first = load<u16>(ptr);
+      if (isString<nonnull<T>>() && first == QUOTE)
+        return scanQuotedValueEnd(ptr, srcEnd);
+      if (isArray<nonnull<T>>() && first == BRACKET_LEFT)
+        return scanCompositeValueEnd(ptr, srcEnd);
+      if (
+        (isManaged<nonnull<T>>() || isReference<nonnull<T>>()) &&
+        first == BRACE_LEFT
+      )
+        return scanCompositeValueEnd(ptr, srcEnd);
+
+      if (first == QUOTE) return scanQuotedValueEnd(ptr, srcEnd);
+      if (first == BRACE_LEFT || first == BRACKET_LEFT)
+        return scanCompositeValueEnd(ptr, srcEnd);
+      return scanScalarValueEnd(ptr, srcEnd);
     }
     // @ts-expect-error: decorator
     @inline export function ptrToStr(start: usize, end: usize): string {
@@ -1154,11 +1480,7 @@ export namespace JSON {
      * @param out - string | null
      * @returns - string
      */
-    // @ts-expect-error: inline
-    @inline export function stringify<T>(
-      data: T,
-      out: string | null = null,
-    ): string {
+    export function stringify<T>(data: T, out: string | null = null): string {
       bs.saveState();
       JSON.__serialize<T>(data);
       const result = bs.cpyOut<string>();