json-as 1.3.2 → 1.3.4

package/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## Unreleased
 
+## 2026-04-28 - 1.3.3
+
+- perf: made deserialization 200% to 300% faster
+- chore: enable JSON_USE_FAST_PATH by default
+
 ## 2026-04-13 - 1.3.2
 
 - fix: remove the fast double parser dependency and return float deserialization to the local legacy parser path

package/README.md

@@ -542,13 +542,13 @@ The following charts compare JSON-AS (both SWAR and SIMD variants) against JavaS
 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. See [FAST_PATH_DESERIALIZE.md](./FAST_PATH_DESERIALIZE.md) for the current support matrix, known gaps, and dedicated test command.
+**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`
 
@@ -629,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/simd/string.ts

@@ -206,6 +206,26 @@ export function deserializeString_SIMD(srcStart: usize, srcEnd: usize): string {
   srcStart += 2;
   srcEnd -= 2;
   const payloadStart = srcStart;
+  do {
+    const srcEnd16Fast = srcEnd - 16;
+
+    while (srcStart < srcEnd16Fast) {
+      const block = load<v128>(srcStart);
+      if (i16x8.bitmask(i16x8.eq(block, SPLAT_5C)) != 0) break;
+      srcStart += 16;
+    }
+    if (srcStart < srcEnd16Fast) break;
+
+    while (srcStart < srcEnd) {
+      if (load<u16>(srcStart) == BACK_SLASH) break;
+      srcStart += 2;
+    }
+    if (srcStart < srcEnd) break;
+
+    return copyStringFromSource_SIMD(payloadStart, srcEnd - payloadStart);
+  } while (false);
+
+  srcStart = payloadStart;
   const srcEnd16 = srcEnd - 16;
 
   while (srcStart < srcEnd16) {

package/assembly/deserialize/simple/map.ts

@@ -170,6 +170,7 @@ 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();
 
@@ -209,6 +210,7 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
   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)) {

package/assembly/deserialize/simple/staticarray.ts

@@ -72,6 +72,7 @@ export function deserializeStaticArray<T extends StaticArray<any>>(srcStart: usi
   throw new Error("Could not parse static array of type " + nameof<T>() + "!");
 }
 
+
 @inline export function deserializeStaticArrayField<T extends StaticArray<any>>(srcStart: usize, srcEnd: usize, dstObj: usize, dstOffset: usize = 0): usize {
   const valueEnd = scanValueEnd(srcStart, srcEnd);
   if (!valueEnd) throw new Error("Failed to parse JSON!");

package/assembly/deserialize/simple/struct.ts

@@ -7,9 +7,11 @@ export function deserializeStruct<T>(srcStart: usize, srcEnd: usize, dst: usize)
   if (isDefined(out.__DESERIALIZE_FAST)) {
     // @ts-ignore: supplied by transform
     out.__DESERIALIZE_FAST(srcStart, srcEnd, out);
-  } else {
+  } else if (isDefined(out.__DESERIALIZE_SLOW)) {
     // @ts-ignore: supplied by transform
     out.__DESERIALIZE_SLOW(srcStart, srcEnd, out);
+  } else {
+    throw new Error("Missing __DESERIALIZE_FAST/__DESERIALIZE_SLOW");
   }
   return out;
 }

package/assembly/deserialize/swar/array/bool.ts

@@ -45,6 +45,7 @@ import { ensureArrayElementSlot, ensureArrayField } from "./shared";
   throw new Error("Failed to parse JSON!");
 }
 
+
 @inline export function deserializeBooleanArrayField<T extends boolean[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
   return deserializeBooleanArrayInto<T>(srcStart, srcEnd, ensureArrayField<T>(fieldPtr));
 }

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

@@ -2,8 +2,8 @@ import { JSON } from "../../..";
 import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
 import { ensureArrayElementSlot, ensureArrayField, scanValueEnd } from "./shared";
 
-@inline export function deserializeGenericArrayInto<T extends unknown[]>(srcStart: usize, srcEnd: usize, out: T): usize {
 
+@inline export function deserializeGenericArrayInto<T extends unknown[]>(srcStart: usize, srcEnd: usize, out: T): usize {
   if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) throw new Error("Failed to parse JSON!");
   srcStart += 2;
   if (srcStart >= srcEnd) throw new Error("Failed to parse JSON!");
@@ -35,6 +35,7 @@ import { ensureArrayElementSlot, ensureArrayField, scanValueEnd } from "./shared
   throw new Error("Failed to parse JSON!");
 }
 
+
 @inline export function deserializeGenericArrayField<T extends unknown[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
   return deserializeGenericArrayInto<T>(srcStart, srcEnd, ensureArrayField<T>(fieldPtr));
 }

package/assembly/deserialize/swar/array/integer.ts

@@ -459,6 +459,7 @@ export function deserializeIntegerArray_SWAR<T extends number[]>(srcStart: usize
   throw new Error("Failed to parse JSON!");
 }
 
+
 @inline export function deserializeIntegerArrayField<T extends number[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
   return deserializeIntegerArrayInto<T>(srcStart, srcEnd, ensureArrayField<T>(fieldPtr));
 }

package/assembly/deserialize/swar/array/object.ts

@@ -55,6 +55,7 @@ import { ensureArrayElementSlot, ensureArrayField } from "./shared";
   throw new Error("Failed to parse JSON!");
 }
 
+
 @inline export function deserializeObjectArrayField<T extends unknown[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
   return deserializeObjectArrayInto<T>(srcStart, srcEnd, ensureArrayField<T>(fieldPtr));
 }

package/assembly/deserialize/swar/array/shared.ts

@@ -1,4 +1,5 @@
 import { BACK_SLASH, BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BRACKET_RIGHT, COMMA, QUOTE } from "../../../custom/chars";
+import { isUnescapedQuote } from "../../../util";
 
 
 @inline export function ensureArrayField<T extends Array<any>>(fieldPtr: usize): T {
@@ -10,6 +11,7 @@ import { BACK_SLASH, BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BRACKET_RIGHT, COMMA
   return out;
 }
 
+
 @inline export function ensureArrayFieldAt<T extends Array<any>>(dstObj: usize, dstOffset: usize): T {
   let out = load<T>(dstObj, dstOffset);
   if (!changetype<usize>(out)) {
@@ -57,7 +59,10 @@ import { BACK_SLASH, BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BRACKET_RIGHT, COMMA
       mask &= mask - 1;
       const srcIdx = srcStart + laneIdx;
       const char = load<u16>(srcIdx);
-      if (char == QUOTE) return srcIdx + 2;
+      if (char == QUOTE) {
+        if (isUnescapedQuote(srcIdx)) return srcIdx + 2;
+        continue;
+      }
       if (char == BACK_SLASH) break;
     } while (mask !== 0);
 
@@ -66,7 +71,7 @@ import { BACK_SLASH, BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BRACKET_RIGHT, COMMA
 
   while (srcStart < srcEnd) {
     const char = load<u16>(srcStart);
-    if (char == QUOTE && load<u16>(srcStart - 2) != BACK_SLASH) return srcStart + 2;
+    if (char == QUOTE && isUnescapedQuote(srcStart)) return srcStart + 2;
     srcStart += 2;
   }
 
@@ -74,6 +79,16 @@ import { BACK_SLASH, BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BRACKET_RIGHT, COMMA
 }
 
 
+@inline function scanQuotedValueEndScalar(srcStart: usize, srcEnd: usize): usize {
+  srcStart += 2;
+  while (srcStart < srcEnd) {
+    if (load<u16>(srcStart) == QUOTE && isUnescapedQuote(srcStart)) return srcStart + 2;
+    srcStart += 2;
+  }
+  return 0;
+}
+
+
 @inline export function scanValueEnd(srcStart: usize, srcEnd: usize): usize {
   if (srcStart >= srcEnd) return 0;
   const first = load<u16>(srcStart);
@@ -86,7 +101,7 @@ import { BACK_SLASH, BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BRACKET_RIGHT, COMMA
     while (ptr < srcEnd) {
       const code = load<u16>(ptr);
       if (code == QUOTE) {
-        ptr = scanQuotedValueEnd_SWAR(ptr, srcEnd);
+        ptr = srcEnd - ptr < 256 ? scanQuotedValueEndScalar(ptr, srcEnd) : scanQuotedValueEnd_SWAR(ptr, srcEnd);
         if (!ptr) return 0;
         continue;
       }

package/assembly/deserialize/swar/array/string.ts

@@ -37,6 +37,7 @@ import { deserializeStringField_SWAR } from "../string";
   throw new Error("Failed to parse JSON!");
 }
 
+
 @inline export function deserializeStringArrayField<T extends string[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
   return deserializeStringArrayInto<T>(srcStart, srcEnd, ensureArrayField<T>(fieldPtr));
 }

package/assembly/deserialize/swar/array/struct.ts

@@ -55,6 +55,7 @@ import { ensureArrayElementSlot, ensureArrayField } from "./shared";
   throw new Error("Failed to parse JSON!");
 }
 
+
 @inline export function deserializeStructArrayField<T extends unknown[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
   return deserializeStructArrayInto<T>(srcStart, srcEnd, ensureArrayField<T>(fieldPtr));
 }

package/assembly/deserialize/swar/array.ts

@@ -62,6 +62,7 @@ import { deserializeStructArrayInto } from "./array/struct";
   }
 }
 
+
 @inline export function deserializeArrayInto_SWAR<T extends unknown[]>(srcStart: usize, srcEnd: usize, out: T): usize {
   if (isString<valueof<T>>()) {
     return deserializeStringArrayInto<T>(srcStart, srcEnd, out);

package/assembly/deserialize/swar/string.ts

@@ -149,6 +149,27 @@ export function deserializeString_SWAR(srcStart: usize, srcEnd: usize): string {
   srcStart += 2;
   srcEnd -= 2;
   const payloadStart = srcStart;
+  do {
+    const srcEnd16Fast = srcEnd - 16;
+
+    while (srcStart < srcEnd16Fast) {
+      const m0 = inline.always(backslash_mask_unsafe(load<u64>(srcStart)));
+      const m1 = inline.always(backslash_mask_unsafe(load<u64>(srcStart, 8)));
+      if ((m0 | m1) != 0) break;
+      srcStart += 16;
+    }
+    if (srcStart < srcEnd16Fast) break;
+
+    while (srcStart < srcEnd) {
+      if (load<u16>(srcStart) == BACK_SLASH) break;
+      srcStart += 2;
+    }
+    if (srcStart < srcEnd) break;
+
+    return copyStringFromSource(payloadStart, srcEnd - payloadStart);
+  } while (false);
+
+  srcStart = payloadStart;
   const srcEnd8 = srcEnd - 8;
 
   while (srcStart < srcEnd8) {
@@ -209,7 +230,6 @@ export function deserializeString_SWAR(srcStart: usize, srcEnd: usize): string {
   memory.copy(stringPtr, srcStart, byteLength);
 }
 
-
 // @ts-expect-error: @inline is a valid decorator
 @inline function deserializeEscapedStringContinuation_SWAR(lastPtr: usize, srcStart: usize, srcEnd: usize, dstFieldPtr: usize, outStart: usize): usize {
   const srcEnd8 = srcEnd - 8;
@@ -630,7 +650,6 @@ export function deserializeStringField_SWAR<T extends string | null>(srcStart: u
   return srcStart;
 }
 
-
 /**
  * Computes a per-byte mask identifying ASCII backslash or quote bytes.
  *

package/assembly/index.d.ts

@@ -52,3 +52,4 @@ declare enum JSONMode {
 
 declare const JSON_MODE: JSONMode;
 declare const JSON_CACHE: bool;
+declare const JSON_CACHE_SIZE: usize;

package/assembly/index.ts

@@ -17,18 +17,7 @@ import { serializeSet } from "./serialize/index/set";
 import { deserializeSet } from "./deserialize/index/set";
 import { serializeStaticArray } from "./serialize/index/staticarray";
 import { deserializeStaticArray } from "./deserialize/index/staticarray";
-import {
-  BRACE_LEFT,
-  BRACE_RIGHT,
-  BRACKET_LEFT,
-  BRACKET_RIGHT,
-  COMMA,
-  NULL_WORD,
-  QUOTE,
-  NULL_WORD_U64,
-  TRUE_WORD_U64,
-  FALSE_WORD_U64,
-} from "./custom/chars";
+import { BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BRACKET_RIGHT, COMMA, NULL_WORD, QUOTE, NULL_WORD_U64, TRUE_WORD_U64, FALSE_WORD_U64 } from "./custom/chars";
 import { itoa_buffered } from "util/number";
 import { serializeBool } from "./serialize/index/bool";
 import { serializeInteger } from "./serialize/index/integer";
@@ -36,7 +25,7 @@ import { serializeFloat, serializeFloat32, serializeFloat64 } from "./serialize/
 import { dragonbox_f32_buffered, dragonbox_f64_buffered } from "./util/dragonbox";
 import { serializeStruct } from "./serialize/index/struct";
 import { ptrToStr } from "./util/ptrToStr";
-import { atoi, bytes, scanStringEnd } from "./util";
+import { atoi, bytes, isUnescapedQuote as utilIsUnescapedQuote, scanStringEnd } from "./util";
 import { deserializeArbitrary } from "./deserialize/index/arbitrary";
 import { serializeObject } from "./serialize/index/object";
 import { deserializeObject } from "./deserialize/index/object";
@@ -244,14 +233,19 @@ export namespace JSON {
       } else if (isDefined(type.__DESERIALIZE_SLOW) || isDefined(type.__DESERIALIZE_FAST)) {
         const out = changetype<nonnull<T>>(__new(offsetof<nonnull<T>>(), idof<nonnull<T>>()));
         // @ts-expect-error: Defined by transform
-        if (isDefined(type.__INITIALIZE)) out.__INITIALIZE();
-        // @ts-expect-error: Defined by transform
         if (isDefined(type.__DESERIALIZE_FAST)) {
           // @ts-expect-error: Defined by transform
-          out.__DESERIALIZE_FAST(dataPtr, dataPtr + dataSize, out);
+          if (out.__DESERIALIZE_FAST(dataPtr, dataPtr + dataSize, out) == dataPtr + dataSize) return out;
           // @ts-expect-error: Defined by transform
-        } else out.__DESERIALIZE_SLOW(dataPtr, dataPtr + dataSize, out);
-        return out;
+        }
+        if (isDefined(type.__INITIALIZE)) out.__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;
+        }
+        throw new Error(`No deserialize method defined for type ${type}`);
       }
       if (type instanceof StaticArray) {
         // @ts-expect-error
@@ -956,12 +950,19 @@ export namespace JSON {
       } else if (isDefined(type.__DESERIALIZE_SLOW) || isDefined(type.__DESERIALIZE_FAST)) {
         const out = changetype<nonnull<T>>(dst || __new(offsetof<nonnull<T>>(), idof<nonnull<T>>()));
         // @ts-expect-error: Defined by transform
-        if (isDefined(type.__INITIALIZE)) out.__INITIALIZE();
+        if (isDefined(type.__DESERIALIZE_FAST)) {
+          // @ts-expect-error: Defined by transform
+          if (out.__DESERIALIZE_FAST(srcStart, srcEnd, out) == srcEnd) return out;
+        }
         // @ts-expect-error: Defined by transform
-        if (isDefined(type.__DESERIALIZE_FAST)) out.__DESERIALIZE_FAST(srcStart, srcEnd, out);
+        if (isDefined(type.__INITIALIZE)) out.__INITIALIZE();
         // @ts-expect-error: Defined by transform
-        else out.__DESERIALIZE_SLOW(srcStart, srcEnd, out);
-        return out;
+        if (isDefined(type.__DESERIALIZE_SLOW)) {
+          // @ts-expect-error: Defined by transform
+          out.__DESERIALIZE_SLOW(srcStart, srcEnd, out);
+          return out;
+        }
+        throw new Error(`No deserialize method defined for type ${type}`);
       }
       if (type instanceof StaticArray) {
         // @ts-expect-error: type
@@ -1025,6 +1026,10 @@ export namespace JSON {
       return code == 0x20 || code - 9 <= 4;
     }
     // @ts-expect-error: decorator
+    @inline export function isUnescapedQuote(ptr: usize): boolean {
+      return utilIsUnescapedQuote(ptr);
+    }
+    // @ts-expect-error: decorator
     @inline export function scanValueEnd(srcStart: usize, srcEnd: usize): usize {
       if (srcStart >= srcEnd) return 0;
       let ptr = srcStart;

package/assembly/serialize/simd/string.ts

@@ -1,5 +1,5 @@
 import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
-import { bs, sc } from "../../../lib/as-bs";
+import { bs } from "../../../lib/as-bs";
 import { BACK_SLASH } from "../../custom/chars";
 import { SERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
 import { u16_to_hex4_swar } from "../../util/swar";
@@ -21,20 +21,49 @@ import { u16_to_hex4_swar } from "../../util/swar";
  */
 export function serializeString_SIMD(src: string): void {
   let srcStart = changetype<usize>(src);
-  if (isDefined(JSON_CACHE)) {
-    // check cache
-    const e = unchecked(sc.entries[i32((srcStart >> 4) & sc.CACHE_MASK)]);
-    if (e.key == srcStart) {
-      // bs.offset += e.len;
-      // bs.stackSize += e.len;
-      bs.cacheOutput = e.ptr;
-      bs.cacheOutputLen = e.len;
-      return;
-    }
-  }
+  const srcInitial = srcStart;
 
   const srcSize = changetype<OBJECT>(srcStart - TOTAL_OVERHEAD).rtSize;
   const srcEnd = srcStart + srcSize;
+  do {
+    const srcEnd16Fast = srcEnd - 16;
+    bs.proposeSize(srcSize + 4);
+
+    const dstStart = bs.offset;
+    let dst = dstStart + 2;
+
+    while (srcStart < srcEnd16Fast) {
+      const block = load<v128>(srcStart);
+      const eq22 = i16x8.eq(block, SPLAT_0022);
+      const eq5C = i16x8.eq(block, SPLAT_005C);
+      const lt20 = i16x8.lt_u(block, SPLAT_0020);
+      const gteD8 = i8x16.gt_u(block, SPLAT_FFD8);
+
+      const mask = i8x16.bitmask(v128.or(eq22, v128.or(eq5C, v128.or(lt20, gteD8))));
+      if (mask != 0) break;
+
+      store<v128>(dst, block);
+      srcStart += 16;
+      dst += 16;
+    }
+    if (srcStart < srcEnd16Fast) break;
+
+    while (srcStart <= srcEnd - 2) {
+      const code = load<u16>(srcStart);
+      if (code > 0x7f || code == BACK_SLASH || code == 34 || code < 32) break;
+      store<u16>(dst, code);
+      srcStart += 2;
+      dst += 2;
+    }
+    if (srcStart <= srcEnd - 2) break;
+
+    store<u16>(dstStart, 34); // "
+    store<u16>(dst, 34); // "
+    bs.offset = dst + 2;
+    return;
+  } while (false);
+
+  srcStart = srcInitial;
   const srcEnd16 = srcEnd - 16;
 
   bs.proposeSize(srcSize + 4);
@@ -43,7 +72,6 @@ export function serializeString_SIMD(src: string): void {
 
   while (srcStart < srcEnd16) {
     const block = load<v128>(srcStart);
-    store<v128>(bs.offset, block);
 
     const eq22 = i16x8.eq(block, SPLAT_0022);
     const eq5C = i16x8.eq(block, SPLAT_005C);
@@ -58,12 +86,13 @@ export function serializeString_SIMD(src: string): void {
     let mask = i8x16.bitmask(v128.or(eq22, v128.or(eq5C, v128.or(lt20, gteD8))));
 
     if (mask == 0) {
+      store<v128>(bs.offset, block);
       bs.offset += 16;
       srcStart += 16;
       continue;
     }
 
-    bs.growSize(popcnt(mask) * 10 + 12);
+    store<v128>(bs.offset, block);
 
     do {
       const laneIdx = ctz(mask);
@@ -173,8 +202,6 @@ export function serializeString_SIMD(src: string): void {
 
   store<u16>(bs.offset, 34); // "
   bs.offset += 2;
-
-  if (isDefined(JSON_CACHE)) sc.insertCached(changetype<usize>(src), srcStart, srcSize);
 }
 
 // @ts-expect-error: @inline is a valid decorator

package/assembly/serialize/simple/array.ts

@@ -1,13 +1,53 @@
 import { bs } from "../../../lib/as-bs";
 import { COMMA, BRACKET_RIGHT, BRACKET_LEFT } from "../../custom/chars";
 import { JSON } from "../..";
-import { serializeFloat32, serializeFloat64 } from "./float";
+import { serializeBoolUnsafe } from "./bool";
+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 reservePrimitiveArray<T>(len: i32): void {
+  if (len <= 0) return;
+  if (isBoolean<T>()) {
+    bs.proposeSize(4 + <u32>len * 12);
+  } else if (isInteger<T>()) {
+    bs.proposeSize(4 + <u32>len * (maxIntegerBytes<T>() + 2));
+  } else if (isFloat<T>()) {
+    bs.proposeSize(4 + <u32>len * (sizeof<T>() == 4 ? 34 : 66));
+  } else {
+    bs.proposeSize(4 + <u32>(len - 1) * 2);
+  }
+}
+
 
 @inline
 function serializeArrayElement<T>(value: T): void {
+  if (isString<T>()) {
+    serializeString(value as string);
+    return;
+  }
+  if (isBoolean<T>()) {
+    serializeBoolUnsafe(<bool>value);
+    return;
+  }
+  if (isInteger<T>()) {
+    serializeIntegerUnsafe<T>(value);
+    return;
+  }
   if (isFloat<T>()) {
-    if (sizeof<T>() == 4) serializeFloat32(<f32>value);
-    else serializeFloat64(<f64>value);
+    if (sizeof<T>() == 4) serializeFloat32Unsafe(<f32>value);
+    else serializeFloat64Unsafe(<f64>value);
     return;
   }
   JSON.__serialize<T>(value);
@@ -23,9 +63,11 @@ export function serializeArray<T extends any[]>(src: T): void {
     bs.offset += 4;
     return;
   }
-  bs.proposeSize(4 + <u32>(len - 1) * 2);
-  // {} = 4
-  // xi, = n << 1
+  if (isBoolean<valueof<T>>() || isInteger<valueof<T>>() || isFloat<valueof<T>>() || isString<valueof<T>>()) {
+    reservePrimitiveArray<valueof<T>>(len);
+  } else {
+    bs.proposeSize(4 + <u32>(len - 1) * 2);
+  }
 
   store<u16>(bs.offset, BRACKET_LEFT);
   bs.offset += 2;

package/assembly/serialize/simple/bool.ts

@@ -4,6 +4,18 @@ 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);
+    bs.offset += 8;
+  } else {
+    store<u64>(bs.offset, 32370086184550502);
+    store<u64>(bs.offset, 101, 8);
+    bs.offset += 10;
+  }
+}
+
 export function serializeBool(data: bool): void {
   if (data === true) {
     bs.proposeSize(8);

package/assembly/serialize/simple/float.ts

@@ -1,6 +1,21 @@
 import { bs } from "../../../lib/as-bs";
 import { dragonbox_f32_buffered, dragonbox_f64_buffered } from "../../util/dragonbox";
 
+
+@inline
+export function serializeFloat32Unsafe(data: f32): void {
+  const size = dragonbox_f32_buffered(bs.offset, data) << 1;
+  bs.offset += size;
+}
+
+
+@inline
+export function serializeFloat64Unsafe(data: f64): void {
+  const size = dragonbox_f64_buffered(bs.offset, data) << 1;
+  bs.offset += size;
+}
+
+
 @inline
 export function serializeFloat32(data: f32): void {
   bs.ensureSize(64);
@@ -9,6 +24,7 @@ export function serializeFloat32(data: f32): void {
   bs.offset += size;
 }
 
+
 @inline
 export function serializeFloat64(data: f64): void {
   bs.ensureSize(64);

package/assembly/serialize/simple/integer.ts

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