json-as 1.4.0 → 1.6.0

package/assembly/serialize/index/arbitrary.ts

@@ -1,21 +1,77 @@
 import { JSON } from "../..";
 import { bs } from "../../../lib/as-bs";
-import { serializeArray } from "./array";
+import { bytes } from "../../util/bytes";
+import { QUOTE } from "../../custom/chars";
 import { serializeBool } from "./bool";
 import { serializeFloat32, serializeFloat64 } from "./float";
 import { serializeInteger } from "./integer";
+import { serializeJsonArray } from "./jsonarray";
 import { serializeMap } from "./map";
 import { serializeObject } from "./object";
+import { serializeRaw } from "../naive/raw";
 import { serializeString } from "./string";
 import { serializeDynamic } from "./typedarray";
 
+// True if any code unit would need JSON-escaping on serialize: a quote,
+// backslash, control char (< 0x20), or a surrogate (handled conservatively -
+// even valid pairs route to the full path, since they can't be bulk-copied as a
+// plain run). A clean string is none of these, so it emits as a verbatim memcpy.
+// @ts-ignore: decorator
+@inline function stringNeedsEscape(src: string): bool {
+  let ptr = changetype<usize>(src);
+  const end = ptr + <usize>bytes(src);
+  while (ptr < end) {
+    const code = load<u16>(ptr);
+    if (
+      code == 0x22 ||
+      code == 0x5c ||
+      code < 0x20 ||
+      (code >= 0xd800 && code <= 0xdfff)
+    )
+      return true;
+    ptr += 2;
+  }
+  return false;
+}
+
+// Fast path for a string already known to need no escaping: quote + a single
+// bulk copy of the UTF-16 bytes + quote. Skips the per-char escape scan that
+// serializeString would otherwise do (and its trailing second pass).
+function serializeStringClean(src: string): void {
+  const size = <usize>bytes(src);
+  bs.proposeSize(size + 4);
+  store<u16>(bs.offset, QUOTE);
+  bs.offset += 2;
+  memory.copy(bs.offset, changetype<usize>(src), size);
+  bs.offset += size;
+  store<u16>(bs.offset, QUOTE);
+  bs.offset += 2;
+}
+
 export function serializeArbitrary(src: JSON.Value): void {
+  // Verbatim passthrough: an untouched (still-deferred) value emits its original
+  // source bytes directly - no materialization, no re-encoding. Peek the slice
+  // without reading `src.type` (which would force materialization).
+  const lz = src.__lazySlice();
+  if (lz != 0) {
+    const start = <usize>(lz >>> 32);
+    const size = <usize>(<u32>lz) - start;
+    bs.proposeSize(size);
+    memory.copy(bs.offset, start, size);
+    bs.offset += size;
+    return;
+  }
   switch (src.type) {
     case JSON.Types.Null:
       bs.proposeSize(8);
       store<u64>(bs.offset, 30399761348886638);
       bs.offset += 8;
       break;
+    case JSON.Types.Raw:
+      // A materialized JSON.Raw value (e.g. set into a JSON.Obj/Arr) emits its
+      // pre-formatted bytes as-is - without this it fell into the struct default.
+      serializeRaw(src.get<JSON.Raw>());
+      break;
     case JSON.Types.U8:
       serializeInteger<u8>(src.get<u8>());
       break;
@@ -46,14 +102,24 @@ export function serializeArbitrary(src: JSON.Value): void {
     case JSON.Types.F64:
       serializeFloat64(src.get<f64>());
       break;
-    case JSON.Types.String:
-      serializeString(src.get<string>());
+    case JSON.Types.String: {
+      const str = src.get<string>();
+      // Reuse the cached escape class; classify once on first serialize. Clean
+      // strings (the common case) then emit as a single memcpy on every reuse.
+      let cls = src.__strClass();
+      if (cls == 0) {
+        cls = stringNeedsEscape(str) ? 2 : 1;
+        src.__setStrClass(cls);
+      }
+      if (cls == 1) serializeStringClean(str);
+      else serializeString(str);
       break;
+    }
     case JSON.Types.Bool:
       serializeBool(src.get<bool>());
       break;
     case JSON.Types.Array:
-      serializeArray(src.get<JSON.Value[]>());
+      serializeJsonArray(src.get<JSON.Arr>());
       break;
     case JSON.Types.Object:
       serializeObject(src.get<JSON.Obj>());

package/assembly/serialize/index/bool.ts

@@ -1 +1 @@
-export { serializeBool } from "../naive/bool";
+export { serializeBool, serializeBoolUnsafe } from "../naive/bool";

package/assembly/serialize/index/float.ts

@@ -1,5 +1 @@
-export {
-  serializeFloat,
-  serializeFloat32,
-  serializeFloat64,
-} from "../naive/float";
+export { serializeFloat32, serializeFloat64 } from "../naive/float";

package/assembly/serialize/index/integer.ts

@@ -1 +1 @@
-export { serializeInteger } from "../naive/integer";
+export { serializeInteger, serializeIntegerUnsafe } from "../naive/integer";

package/assembly/serialize/index/jsonarray.ts

@@ -0,0 +1,51 @@
+import { bs } from "../../../lib/as-bs";
+import { JSON } from "../..";
+import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../custom/chars";
+import { serializeArbitrary } from "./arbitrary";
+
+export function serializeJsonArray(src: JSON.Arr): void {
+  const n = src.length;
+
+  if (n == 0) {
+    bs.proposeSize(4);
+    store<u32>(bs.offset, 6094939); // "[]"
+    bs.offset += 4;
+    return;
+  }
+
+  const vals = src._vals;
+  // Source base + upper bound for resolving a deferred slot's value range.
+  const srcBase = changetype<usize>(src._src);
+  const srcEnd = srcBase + ((<usize>src._src.length) << 1);
+
+  bs.proposeSize(4 + <u32>(n - 1) * 2);
+  store<u16>(bs.offset, BRACKET_LEFT);
+  bs.offset += 2;
+
+  // A still-deferred slot is copied out verbatim from the source; an
+  // eager/materialized slot is serialized from its boxed bits.
+  for (let i = 0; i < n; i++) {
+    if (i != 0) {
+      store<u16>(bs.offset, COMMA);
+      bs.offset += 2;
+    }
+    const slot = unchecked(vals[i]);
+    if (JSON.Value.slotIsLazy(slot)) {
+      const start = JSON.Value.slotPtr(slot, srcBase);
+      const end = JSON.Value.slotEnd(slot, srcBase, srcEnd);
+      const size = end - start;
+      bs.proposeSize(size);
+      memory.copy(bs.offset, start, size);
+      bs.offset += size;
+    } else {
+      const v = JSON.Value.fromBits(slot);
+      serializeArbitrary(v);
+      // Persist a cached String escape-class back into the slot (see object.ts).
+      const nb = v.__bits();
+      if (nb != slot) unchecked((vals[i] = nb));
+    }
+  }
+
+  store<u16>(bs.offset, BRACKET_RIGHT);
+  bs.offset += 2;
+}

package/assembly/serialize/index/object.ts

@@ -5,6 +5,23 @@ import { serializeArbitrary } from "./arbitrary";
 import { serializeStringRange } from "../naive/string";
 
 export function serializeObject(src: JSON.Obj): void {
+  const rawStart = src._rawStart;
+  if (rawStart != 0) {
+    const rawSize = src._rawEnd - rawStart;
+    // At top level, `bs.out` can copy the anchored source slice straight into
+    // the returned string. Nested objects already have parent bytes in the
+    // staging buffer and therefore keep the regular append path below.
+    if (bs.offset == bs.buffer && bs.cacheOutput == 0) {
+      bs.cacheOutput = rawStart;
+      bs.cacheOutputLen = rawSize;
+      return;
+    }
+    bs.proposeSize(rawSize);
+    memory.copy(bs.offset, rawStart, rawSize);
+    bs.offset += rawSize;
+    return;
+  }
+
   const srcSize = src.size;
 
   if (srcSize == 0) {
@@ -17,13 +34,18 @@ export function serializeObject(src: JSON.Obj): void {
   const vals = src._vals;
   const kbuf = changetype<usize>(src._kbuf);
   const kused = src._kused;
+  // Source base + upper bound for resolving a deferred slot's value range.
+  const srcBase = changetype<usize>(src._src);
+  const srcEnd = srcBase + ((<usize>src._src.length) << 1);
 
   bs.proposeSize(4 + <u32>(srcSize - 1) * 2 + <u32>srcSize * 2);
   store<u16>(bs.offset, BRACE_LEFT);
   bs.offset += 2;
 
-  // Walk the length-prefixed key buffer in lockstep with the values, emitting
-  // each key straight from its slice (no per-key string materialization).
+  // Walk the length-prefixed key buffer in lockstep with the value slots,
+  // emitting each key straight from its slice (no per-key string
+  // materialization). A still-deferred slot is copied out verbatim from the
+  // source; an eager/materialized slot is serialized from its boxed bits.
   let pos = 0;
   let i = 0;
   while (pos < kused) {
@@ -35,7 +57,24 @@ export function serializeObject(src: JSON.Obj): void {
     serializeStringRange(kbuf + ((<usize>(pos + 1)) << 1), (<usize>len) << 1);
     store<u16>(bs.offset, COLON);
     bs.offset += 2;
-    serializeArbitrary(unchecked(vals[i]));
+
+    const slot = unchecked(vals[i]);
+    if (JSON.Value.slotIsLazy(slot)) {
+      const start = JSON.Value.slotPtr(slot, srcBase);
+      const end = JSON.Value.slotEnd(slot, srcBase, srcEnd);
+      const size = end - start;
+      bs.proposeSize(size);
+      memory.copy(bs.offset, start, size);
+      bs.offset += size;
+    } else {
+      const v = JSON.Value.fromBits(slot);
+      serializeArbitrary(v);
+      // Persist any escape-class the serializer cached on a materialized String
+      // slot back into the flat slot, so re-serializing this object reuses it
+      // (the memcpy fast path) instead of re-scanning. No-op for other types.
+      const nb = v.__bits();
+      if (nb != slot) unchecked((vals[i] = nb));
+    }
     pos += 1 + len;
     i++;
   }

package/assembly/serialize/index/string.ts

@@ -3,8 +3,7 @@ import { serializeString_NAIVE } from "../naive/string";
 import { serializeString_SIMD } from "../simd/string";
 import { serializeString_SWAR } from "../swar/string";
 
-
-@inline export function serializeString(src: string): void {
+export function serializeString(src: string): void {
   if (JSON_MODE == JSONMode.SIMD) {
     serializeString_SIMD(src);
   } else if (JSON_MODE == JSONMode.NAIVE) {

package/assembly/serialize/index/typedarray.ts

@@ -9,8 +9,7 @@ import {
   serializeTypedArray,
 } from "../naive/typedarray";
 
-
-@inline export function serializeDynamic(type: u16, data: usize): void {
+export function serializeDynamic(type: u16, data: usize): void {
   if (type == JSON.Types.ArrayBuffer) {
     serializeArrayBufferUnsafe(
       data,

package/assembly/serialize/index.ts

@@ -4,6 +4,7 @@ export * from "./index/bool";
 export * from "./index/date";
 export * from "./index/float";
 export * from "./index/integer";
+export * from "./index/jsonarray";
 export * from "./index/map";
 export * from "./index/object";
 export * from "./index/raw";

package/assembly/serialize/naive/array.ts

@@ -5,13 +5,9 @@ import { serializeBoolUnsafe } from "./bool";
 import { serializeFloat32Unsafe, serializeFloat64Unsafe } from "./float";
 import { serializeIntegerUnsafe } from "./integer";
 import { serializeString } from "../index/string";
-import {
-  dragonbox_f32_buffered,
-  dragonbox_f64_buffered,
-} from "../../util/dragonbox";
+import { ensureItoaPairs, itoaFast } from "../../util/itoa-fast";
+import { dtoa_buffered, ftoa_buffered } from "xjb-as";
 
-
-@inline
 function maxIntegerBytes<T extends number>(): u32 {
   if (sizeof<T>() == 1) return isSigned<T>() ? 8 : 6;
   if (sizeof<T>() == 2) return isSigned<T>() ? 12 : 10;
@@ -19,8 +15,6 @@ function maxIntegerBytes<T extends number>(): u32 {
   return isSigned<T>() ? 42 : 40;
 }
 
-
-@inline
 function reservePrimitiveArray<T>(len: i32): void {
   if (len <= 0) return;
   if (isBoolean<T>()) {
@@ -34,8 +28,6 @@ function reservePrimitiveArray<T>(len: i32): void {
   }
 }
 
-
-@inline
 function serializeArrayElement<T>(value: T): void {
   if (isString<T>()) {
     serializeString(value as string);
@@ -78,15 +70,13 @@ function serializeArrayElement<T>(value: T): void {
 // comma-store + advance per element that the generic `serializeArray` does.
 
 // `"true,"` packed UTF-16: `t,r,u,e,,` lanes 0..4 = bytes 0..9.
-@inline const TRUE_COMMA_LO: u64 = 0x0065_0075_0072_0074;
+const TRUE_COMMA_LO: u64 = 0x0065_0075_0072_0074;
 
-
-@inline const TRUE_COMMA_HI: u16 = 0x002c;
+const TRUE_COMMA_HI: u16 = 0x002c;
 // `"false,"` packed UTF-16: `f,a,l,s,e,,` lanes 0..5 = bytes 0..11.
-@inline const FALSE_COMMA_LO: u64 = 0x0073_006c_0061_0066;
-
+const FALSE_COMMA_LO: u64 = 0x0073_006c_0061_0066;
 
-@inline const FALSE_COMMA_HI: u32 = 0x002c_0065;
+const FALSE_COMMA_HI: u32 = 0x002c_0065;
 
 function serializeBoolArrayFast(src: bool[]): void {
   const len = src.length;
@@ -152,8 +142,7 @@ function initU8Lut(): void {
   _u8LutInited = true;
 }
 
-
-@inline function ensureU8Lut(): void {
+function ensureU8Lut(): void {
   if (!_u8LutInited) initU8Lut();
 }
 
@@ -181,20 +170,20 @@ function serializeU8ArrayFast(src: u8[]): void {
   store<u16>(bs.offset - 2, BRACKET_RIGHT);
 }
 
-// Specialized float-array serializer: dragonbox + trailing comma in a
+// Specialized float-array serializer: xjb writer + trailing comma in a
 // uniform per-iteration body, then overwrite the final comma with `]`. The
 // generic dispatcher splits the loop into "N-1 elements with comma, then
-// last element without, then `]`" — the branch on each `i < end` check
+// last element without, then `]`" - the branch on each `i < end` check
 // stalls the loop's tight bs.offset advance pattern. This variant runs the
-// same number of stores per iteration (dragonbox output + COMMA), but the
+// same number of stores per iteration (xjb output + COMMA), but the
 // uniform loop body inlines better and the trailing `]` is a single fixed
 // overwrite outside the loop.
 function serializeF64ArrayFast(src: f64[]): void {
   const len = src.length;
-  // Worst case per element: ~24 chars for f64 + comma = 50 bytes.
-  // Slight over-reserve (66) matches the existing `reservePrimitiveArray`
-  // budget and keeps a safety margin for any NaN/Inf spelling.
-  bs.proposeSize(4 + <u32>len * 66);
+  // Worst case per element: a 21-char fixed integer (e.g. 1e20) or a ~24-char
+  // exponent form, + comma = ~52 bytes; plus the writer's SIMD stores can
+  // overshoot the logical end by up to 16 bytes. 80 covers both comfortably.
+  bs.proposeSize(4 + <u32>len * 80);
   store<u16>(bs.offset, BRACKET_LEFT);
   bs.offset += 2;
   if (len == 0) {
@@ -210,9 +199,9 @@ function serializeF64ArrayFast(src: f64[]): void {
   let offset = bs.offset;
   for (let i: i32 = 0; i < len; i++) {
     const v = load<f64>(dataStart + ((<usize>i) << 3));
-    const size = dragonbox_f64_buffered(offset, v) << 1;
-    store<u16>(offset + size, COMMA);
-    offset += size + 2;
+    offset += dtoa_buffered(offset, v) << 1;
+    store<u16>(offset, COMMA);
+    offset += 2;
   }
   // Overwrite the final trailing comma with `]`.
   store<u16>(offset - 2, BRACKET_RIGHT);
@@ -221,9 +210,10 @@ function serializeF64ArrayFast(src: f64[]): void {
 
 function serializeF32ArrayFast(src: f32[]): void {
   const len = src.length;
-  // Worst case for f32 is ~16 chars + comma = ~34 bytes; mirror the budget
-  // used by `reservePrimitiveArray`.
-  bs.proposeSize(4 + <u32>len * 34);
+  // Worst case for f32 is a 21-char fixed integer (e.g. 1e20 rounds to a
+  // 21-digit value), + comma = ~44 bytes, plus up to 16 bytes of SIMD store
+  // overshoot. 64 covers it.
+  bs.proposeSize(4 + <u32>len * 64);
   store<u16>(bs.offset, BRACKET_LEFT);
   bs.offset += 2;
   if (len == 0) {
@@ -236,9 +226,9 @@ function serializeF32ArrayFast(src: f32[]): void {
   let offset = bs.offset;
   for (let i: i32 = 0; i < len; i++) {
     const v = load<f32>(dataStart + ((<usize>i) << 2));
-    const size = dragonbox_f32_buffered(offset, v) << 1;
-    store<u16>(offset + size, COMMA);
-    offset += size + 2;
+    offset += ftoa_buffered(offset, v) << 1;
+    store<u16>(offset, COMMA);
+    offset += 2;
   }
   store<u16>(offset - 2, BRACKET_RIGHT);
   bs.offset = offset;
@@ -276,6 +266,59 @@ function serializeI8ArrayFast(src: i8[]): void {
   store<u16>(bs.offset - 2, BRACKET_RIGHT);
 }
 
+// Integer arrays wider than one byte use the same uniform trailing-comma
+// layout as the specialized float paths. Keeping the output cursor local
+// avoids two global `bs.offset` accesses per value, while reading dataStart
+// directly removes the Array.__uget call left in the generic array loop.
+function serializeIntegerArrayFast<T extends number[]>(src: T): void {
+  const len = src.length;
+  bs.proposeSize(4 + <u32>len * (maxIntegerBytes<valueof<T>>() + 2));
+  store<u16>(bs.offset, BRACKET_LEFT);
+  bs.offset += 2;
+  if (len == 0) {
+    store<u16>(bs.offset, BRACKET_RIGHT);
+    bs.offset += 2;
+    return;
+  }
+
+  ensureItoaPairs();
+  const dataStart = src.dataStart;
+  const stride = sizeof<valueof<T>>();
+  let offset = bs.offset;
+  for (let i: i32 = 0; i < len; i++) {
+    const value = load<valueof<T>>(dataStart + <usize>i * stride);
+    offset += (<usize>itoaFast<valueof<T>>(offset, value)) << 1;
+    store<u16>(offset, COMMA);
+    offset += 2;
+  }
+  store<u16>(offset - 2, BRACKET_RIGHT);
+  bs.offset = offset;
+}
+
+function serializeStringArrayFast(src: string[]): void {
+  const len = src.length;
+  // String serialization reserves its own payload; reserve delimiters here.
+  bs.proposeSize(4 + (len > 0 ? <u32>(len - 1) * 2 : 0));
+  store<u16>(bs.offset, BRACKET_LEFT);
+  bs.offset += 2;
+  if (len == 0) {
+    store<u16>(bs.offset, BRACKET_RIGHT);
+    bs.offset += 2;
+    return;
+  }
+
+  const dataStart = src.dataStart;
+  for (let i: i32 = 0; i < len; i++) {
+    const value = changetype<string>(
+      load<usize>(dataStart + ((<usize>i) << 2)),
+    );
+    serializeString(value);
+    store<u16>(bs.offset, COMMA);
+    bs.offset += 2;
+  }
+  store<u16>(bs.offset - 2, BRACKET_RIGHT);
+}
+
 export function serializeArray<T extends any[]>(src: T): void {
   // Specialized fast paths fold the per-element comma into the element write,
   // saving one `store<u16>` + advance per iteration. AS folds the type checks
@@ -303,6 +346,16 @@ export function serializeArray<T extends any[]>(src: T): void {
     serializeI8ArrayFast(changetype<i8[]>(src));
     return;
   }
+  if (isInteger<valueof<T>>()) {
+    // u8[] and i8[] returned through their lookup-table paths above.
+    serializeIntegerArrayFast<T>(src);
+    return;
+  }
+  if (isString<valueof<T>>()) {
+    // @ts-expect-error: T is string[]
+    serializeStringArrayFast(changetype<string[]>(src));
+    return;
+  }
   if (isFloat<valueof<T>>() && sizeof<valueof<T>>() == 8) {
     // @ts-expect-error: T is f64[]
     serializeF64ArrayFast(changetype<f64[]>(src));

package/assembly/serialize/naive/bool.ts

@@ -4,7 +4,6 @@ import { bs } from "../../../lib/as-bs";
  * @param data data to serialize
  * @returns void
  */
-@inline
 export function serializeBoolUnsafe(data: bool): void {
   if (data === true) {
     store<u64>(bs.offset, 28429475166421108);

package/assembly/serialize/naive/float.ts

@@ -1,43 +1,29 @@
 import { bs } from "../../../lib/as-bs";
-import {
-  dragonbox_f32_buffered,
-  dragonbox_f64_buffered,
-} from "../../util/dragonbox";
+import { dtoa_buffered, ftoa_buffered } from "xjb-as";
 
+// Float serialization is backed by xjb-as (a Schubfach/xjb shortest-decimal
+// writer with SWAR + WASM-SIMD digit kernels). The *_buffered writers emit
+// UTF-16 straight into the `bs` buffer and return the number of characters
+// written, so advancing the offset is `count << 1` bytes.
 
-@inline
 export function serializeFloat32Unsafe(data: f32): void {
-  const size = dragonbox_f32_buffered(bs.offset, data) << 1;
-  bs.offset += size;
+  bs.offset += ftoa_buffered(bs.offset, data) << 1;
 }
 
-
-@inline
 export function serializeFloat64Unsafe(data: f64): void {
-  const size = dragonbox_f64_buffered(bs.offset, data) << 1;
-  bs.offset += size;
+  bs.offset += dtoa_buffered(bs.offset, data) << 1;
 }
 
-
-@inline
 export function serializeFloat32(data: f32): void {
-  bs.ensureSize(64);
-  const size = dragonbox_f32_buffered(bs.offset, data) << 1;
-  bs.stackSize += size;
-  bs.offset += size;
+  bs.ensureSize(128);
+  const bytes = ftoa_buffered(bs.offset, data) << 1;
+  bs.stackSize += bytes;
+  bs.offset += bytes;
 }
 
-
-@inline
 export function serializeFloat64(data: f64): void {
-  bs.ensureSize(64);
-  const size = dragonbox_f64_buffered(bs.offset, data) << 1;
-  bs.stackSize += size;
-  bs.offset += size;
-}
-
-// @ts-ignore: inline
-@inline export function serializeFloat<T extends number>(data: T): void {
-  if (sizeof<T>() == 4) serializeFloat32(<f32>data);
-  else serializeFloat64(<f64>data);
+  bs.ensureSize(128);
+  const bytes = dtoa_buffered(bs.offset, data) << 1;
+  bs.stackSize += bytes;
+  bs.offset += bytes;
 }

package/assembly/serialize/naive/integer.ts

@@ -1,16 +1,12 @@
 import { bs } from "../../../lib/as-bs";
 import { ensureItoaPairs, itoaFast } from "../../util/itoa-fast";
 
-
-@inline
 export function serializeIntegerUnsafe<T extends number>(data: T): void {
   ensureItoaPairs();
   const charsWritten = itoaFast<T>(bs.offset, data);
   bs.offset += (<usize>charsWritten) << 1;
 }
-
-// @ts-ignore: inline
-@inline export function serializeInteger<T extends number>(data: T): void {
+export function serializeInteger<T extends number>(data: T): void {
   ensureItoaPairs();
   bs.ensureSize(sizeof<T>() << 3);
   const charsWritten = itoaFast<T>(bs.offset, data);

package/assembly/serialize/naive/map.ts

@@ -1,6 +1,34 @@
 import { bs } from "../../../lib/as-bs";
 import { JSON } from "../..";
 import { BRACE_LEFT, BRACE_RIGHT, COLON, COMMA } from "../../custom/chars";
+import { serializeString } from "../index/string";
+import { serializeRaw } from "./raw";
+
+function serializeRawMapFast<T extends Map<any, any>>(
+  keys: Array<indexof<T>>,
+  values: Array<valueof<T>>,
+): void {
+  const len = keys.length;
+  bs.proposeSize(4 + <u32>len * 4);
+  store<u16>(bs.offset, BRACE_LEFT);
+  bs.offset += 2;
+
+  const keyData = keys.dataStart;
+  const valueData = values.dataStart;
+  for (let i = 0; i < len; i++) {
+    const key = changetype<string>(load<usize>(keyData + ((<usize>i) << 2)));
+    const value = changetype<JSON.Raw>(
+      load<usize>(valueData + ((<usize>i) << 2)),
+    );
+    serializeString(key);
+    store<u16>(bs.offset, COLON);
+    bs.offset += 2;
+    serializeRaw(value);
+    store<u16>(bs.offset, COMMA);
+    bs.offset += 2;
+  }
+  store<u16>(bs.offset - 2, BRACE_RIGHT);
+}
 
 export function serializeMap<T extends Map<any, any>>(src: T): void {
   const srcSize = src.size;
@@ -17,6 +45,15 @@ export function serializeMap<T extends Map<any, any>>(src: T): void {
   let values = src.values();
   const keyIsString = isString<indexof<T>>();
 
+  if (keyIsString && isReference<valueof<T>>()) {
+    const valueType = changetype<nonnull<valueof<T>>>(0);
+    // @ts-ignore: instanceof on the reference value type
+    if (valueType instanceof JSON.Raw) {
+      serializeRawMapFast<T>(keys, values);
+      return;
+    }
+  }
+
   bs.proposeSize(4 + <u32>(srcSize - 1) * 2 + <u32>srcSize * 2);
 
   store<u16>(bs.offset, BRACE_LEFT);

package/assembly/serialize/naive/raw.ts

@@ -7,8 +7,7 @@ import { bytes } from "../../util";
  * @param data data to serialize
  * @returns void
  */
-// @ts-ignore: inline
-@inline export function serializeRaw(data: JSON.Raw): void {
+export function serializeRaw(data: JSON.Raw): void {
   const dataSize = bytes(data.data);
   bs.proposeSize(dataSize);
   memory.copy(

package/assembly/serialize/naive/set.ts

@@ -6,8 +6,6 @@ import { serializeFloat32Unsafe, serializeFloat64Unsafe } from "./float";
 import { serializeIntegerUnsafe } from "./integer";
 import { serializeString } from "../index/string";
 
-
-@inline
 function maxIntegerBytes<T extends number>(): u32 {
   if (sizeof<T>() == 1) return isSigned<T>() ? 8 : 6;
   if (sizeof<T>() == 2) return isSigned<T>() ? 12 : 10;
@@ -15,10 +13,7 @@ function maxIntegerBytes<T extends number>(): u32 {
   return isSigned<T>() ? 42 : 40;
 }
 
-
-@inline
 function reservePrimitiveSet<T>(len: i32): void {
-  if (len <= 0) return;
   if (isBoolean<T>()) {
     bs.proposeSize(4 + <u32>len * 12);
   } else if (isInteger<T>()) {

package/assembly/serialize/naive/staticarray.ts

@@ -6,19 +6,13 @@ import { serializeFloat32Unsafe, serializeFloat64Unsafe } from "./float";
 import { serializeIntegerUnsafe } from "./integer";
 import { serializeString } from "../index/string";
 
-
-@inline
 function maxIntegerBytes<T extends number>(): u32 {
   if (sizeof<T>() == 1) return isSigned<T>() ? 8 : 6;
   if (sizeof<T>() == 2) return isSigned<T>() ? 12 : 10;
   if (sizeof<T>() == 4) return isSigned<T>() ? 22 : 20;
   return isSigned<T>() ? 42 : 40;
 }
-
-
-@inline
 function reservePrimitiveStaticArray<T>(len: i32): void {
-  if (len <= 0) return;
   if (isBoolean<T>()) {
     bs.proposeSize(4 + <u32>len * 12);
   } else if (isInteger<T>()) {