json-as 1.3.3 → 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/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/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 {
@@ -58,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);
 
@@ -67,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;
   }
 
@@ -75,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);
@@ -87,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/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) {

package/assembly/index.ts

@@ -25,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";
@@ -1026,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,14 +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);
@@ -24,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

@@ -2,6 +2,20 @@ 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);

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);

package/assembly/serialize/simple/set.ts

@@ -1,6 +1,34 @@
 import { bs } from "../../../lib/as-bs";
 import { COMMA, BRACKET_RIGHT, BRACKET_LEFT } from "../../custom/chars";
 import { JSON } from "../..";
+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 reservePrimitiveSet<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);
+  }
+}
 
 export function serializeSet<T extends Set<any>>(src: T): void {
   const srcSize = src.size;
@@ -10,7 +38,11 @@ export function serializeSet<T extends Set<any>>(src: T): void {
     bs.offset += 4;
     return;
   }
-  bs.proposeSize(4 + <u32>(srcSize - 1) * 2);
+  if (isBoolean<indexof<T>>() || isInteger<indexof<T>>() || isFloat<indexof<T>>() || isString<indexof<T>>()) {
+    reservePrimitiveSet<indexof<T>>(srcSize);
+  } else {
+    bs.proposeSize(4 + <u32>(srcSize - 1) * 2);
+  }
 
   const values = src.values();
   store<u16>(bs.offset, BRACKET_LEFT);
@@ -19,15 +51,37 @@ export function serializeSet<T extends Set<any>>(src: T): void {
   const end = srcSize - 1;
   for (let i = 0; i < end; i++) {
     const block = unchecked(values[i]);
-    // @ts-ignore: type
-    JSON.__serialize<indexof<T>>(block);
+    if (isString<indexof<T>>()) {
+      serializeString(block as string);
+    } else if (isBoolean<indexof<T>>()) {
+      serializeBoolUnsafe(<bool>block);
+    } else if (isInteger<indexof<T>>()) {
+      serializeIntegerUnsafe<indexof<T>>(block);
+    } else if (isFloat<indexof<T>>()) {
+      if (sizeof<indexof<T>>() == 4) serializeFloat32Unsafe(<f32>block);
+      else serializeFloat64Unsafe(<f64>block);
+    } else {
+      // @ts-ignore: type
+      JSON.__serialize<indexof<T>>(block);
+    }
     store<u16>(bs.offset, COMMA);
     bs.offset += 2;
   }
 
   const lastBlock = unchecked(values[end]);
-  // @ts-ignore: type
-  JSON.__serialize<indexof<T>>(lastBlock);
+  if (isString<indexof<T>>()) {
+    serializeString(lastBlock as string);
+  } else if (isBoolean<indexof<T>>()) {
+    serializeBoolUnsafe(<bool>lastBlock);
+  } else if (isInteger<indexof<T>>()) {
+    serializeIntegerUnsafe<indexof<T>>(lastBlock);
+  } else if (isFloat<indexof<T>>()) {
+    if (sizeof<indexof<T>>() == 4) serializeFloat32Unsafe(<f32>lastBlock);
+    else serializeFloat64Unsafe(<f64>lastBlock);
+  } else {
+    // @ts-ignore: type
+    JSON.__serialize<indexof<T>>(lastBlock);
+  }
   store<u16>(bs.offset, BRACKET_RIGHT);
   bs.offset += 2;
 }

package/assembly/serialize/simple/staticarray.ts

@@ -1,6 +1,34 @@
 import { bs } from "../../../lib/as-bs";
 import { COMMA, BRACKET_RIGHT, BRACKET_LEFT } from "../../custom/chars";
 import { JSON } from "../..";
+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 reservePrimitiveStaticArray<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);
+  }
+}
 
 export function serializeStaticArray<T extends StaticArray<any>>(src: T): void {
   const len = src.length;
@@ -12,20 +40,46 @@ export function serializeStaticArray<T extends StaticArray<any>>(src: T): void {
     bs.offset += 4;
     return;
   }
-  bs.proposeSize(4 + <u32>(len - 1) * 2);
+  if (isBoolean<valueof<T>>() || isInteger<valueof<T>>() || isFloat<valueof<T>>() || isString<valueof<T>>()) {
+    reservePrimitiveStaticArray<valueof<T>>(len);
+  } else {
+    bs.proposeSize(4 + <u32>(len - 1) * 2);
+  }
 
   store<u16>(bs.offset, BRACKET_LEFT);
   bs.offset += 2;
 
   while (i < end) {
     const block = unchecked(src[i++]);
-    JSON.__serialize<valueof<T>>(block);
+    if (isString<valueof<T>>()) {
+      serializeString(block as string);
+    } else if (isBoolean<valueof<T>>()) {
+      serializeBoolUnsafe(<bool>block);
+    } else if (isInteger<valueof<T>>()) {
+      serializeIntegerUnsafe<valueof<T>>(block);
+    } else if (isFloat<valueof<T>>()) {
+      if (sizeof<valueof<T>>() == 4) serializeFloat32Unsafe(<f32>block);
+      else serializeFloat64Unsafe(<f64>block);
+    } else {
+      JSON.__serialize<valueof<T>>(block);
+    }
     store<u16>(bs.offset, COMMA);
     bs.offset += 2;
   }
 
   const lastBlock = unchecked(src[end]);
-  JSON.__serialize<valueof<T>>(lastBlock);
+  if (isString<valueof<T>>()) {
+    serializeString(lastBlock as string);
+  } else if (isBoolean<valueof<T>>()) {
+    serializeBoolUnsafe(<bool>lastBlock);
+  } else if (isInteger<valueof<T>>()) {
+    serializeIntegerUnsafe<valueof<T>>(lastBlock);
+  } else if (isFloat<valueof<T>>()) {
+    if (sizeof<valueof<T>>() == 4) serializeFloat32Unsafe(<f32>lastBlock);
+    else serializeFloat64Unsafe(<f64>lastBlock);
+  } else {
+    JSON.__serialize<valueof<T>>(lastBlock);
+  }
   store<u16>(bs.offset, BRACKET_RIGHT);
   bs.offset += 2;
 }

package/assembly/serialize/simple/typedarray.ts

@@ -1,16 +1,36 @@
 import { bs } from "../../../lib/as-bs";
 import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../custom/chars";
-import { serializeFloat32, serializeFloat64 } from "./float";
-import { serializeInteger } from "./integer";
+import { serializeFloat32Unsafe, serializeFloat64Unsafe } from "./float";
+import { serializeIntegerUnsafe } from "./integer";
+
+
+@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 reserveTypedArray<T extends ArrayLike<number>>(len: i32): void {
+  if (len <= 0) return;
+  if (isFloat<valueof<T>>()) {
+    bs.proposeSize(4 + <u32>len * (sizeof<valueof<T>>() == 4 ? 34 : 66));
+  } else {
+    bs.proposeSize(4 + <u32>len * (maxIntegerBytes<valueof<T>>() + 2));
+  }
+}
 
 
 @inline
 function serializeTypedArrayElement<T extends ArrayLike<number>>(src: T, index: i32): void {
   if (isFloat<valueof<T>>()) {
-    if (sizeof<valueof<T>>() == 4) serializeFloat32(<f32>unchecked(src[index]));
-    else serializeFloat64(<f64>unchecked(src[index]));
+    if (sizeof<valueof<T>>() == 4) serializeFloat32Unsafe(<f32>unchecked(src[index]));
+    else serializeFloat64Unsafe(<f64>unchecked(src[index]));
   } else {
-    serializeInteger<valueof<T>>(unchecked(src[index]));
+    serializeIntegerUnsafe<valueof<T>>(unchecked(src[index]));
   }
 }
 
@@ -23,7 +43,7 @@ export function serializeTypedArray<T extends ArrayLike<number>>(src: T): void {
     bs.offset += 4;
     return;
   }
-  bs.proposeSize(4 + <u32>(len - 1) * 2);
+  reserveTypedArray<T>(len);
 
   store<u16>(bs.offset, BRACKET_LEFT);
   bs.offset += 2;
@@ -48,18 +68,18 @@ export function serializeArrayBufferUnsafe(srcStart: usize, byteLength: i32): vo
     bs.offset += 4;
     return;
   }
-  bs.proposeSize(4 + <u32>end * 2);
+  bs.proposeSize(4 + <u32>byteLength * 8);
 
   store<u16>(bs.offset, BRACKET_LEFT);
   bs.offset += 2;
 
   for (let i = 0; i < end; i++) {
-    serializeInteger<u8>(load<u8>(srcStart + <usize>i));
+    serializeIntegerUnsafe<u8>(load<u8>(srcStart + <usize>i));
     store<u16>(bs.offset, COMMA);
     bs.offset += 2;
   }
 
-  serializeInteger<u8>(load<u8>(srcStart + <usize>end));
+  serializeIntegerUnsafe<u8>(load<u8>(srcStart + <usize>end));
   store<u16>(bs.offset, BRACKET_RIGHT);
   bs.offset += 2;
 }