json-as 1.2.2 → 1.2.4

package/assembly/serialize/simd/string.ts

@@ -1,14 +1,26 @@
+import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
 import { bs, sc } from "../../../lib/as-bs";
 import { BACK_SLASH } from "../../custom/chars";
 import { SERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
-import { bytes } from "../../util";
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const U00_MARKER = 13511005048209500;
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const U_MARKER = 7667804;
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_0022 = i16x8.splat(0x0022); // "
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_005C = i16x8.splat(0x005C); // \
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_0020 = i16x8.splat(0x0020); // space and control check
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_FFD8 = i16x8.splat(i16(0xD7FE));
 
 /**
  * Serializes strings into their JSON counterparts using SIMD operations
  */
 export function serializeString_SIMD(src: string): void {
   let srcStart = changetype<usize>(src);
-if (isDefined(JSON_CACHE)) {
+  if (isDefined(JSON_CACHE)) {
     // check cache
     const e = unchecked(sc.entries[(srcStart >> 4) & sc.CACHE_MASK]);
     if (e.key == srcStart) {
@@ -19,55 +31,98 @@ if (isDefined(JSON_CACHE)) {
       return;
     }
   }
-  const U00_MARKER = 13511005048209500;
-  const SPLAT_34 = i16x8.splat(34); /* " */
-  const SPLAT_92 = i16x8.splat(92); /* \ */
 
-  const SPLAT_32 = i16x8.splat(32); /* [ESC] */
-
-  const srcSize = bytes(src);
+  const srcSize = changetype<OBJECT>(srcStart - TOTAL_OVERHEAD).rtSize
   const srcEnd = srcStart + srcSize;
   const srcEnd16 = srcEnd - 16;
 
   bs.proposeSize(srcSize + 4);
-
-  store<u8>(bs.offset, 34); // "
+  store<u16>(bs.offset, 34); // "
   bs.offset += 2;
 
-  while (srcStart <= srcEnd16) {
-    const block = v128.load(srcStart);
+  while (srcStart < srcEnd16) {
+    const block = load<v128>(srcStart);
+    store<v128>(bs.offset, block);
 
-    v128.store(bs.offset, block);
+    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);
+    // console.log("\nblock  : " + mask_to_string_v128(block));
+    // console.log("eq22   : " + mask_to_string_v128(eq22) + " -> " + mask_to_string_v128(SPLAT_0022));
+    // console.log("eq5C   : " + mask_to_string_v128(eq5C) + " -> " + mask_to_string_v128(SPLAT_005C));
+    // console.log("lt20   : " + mask_to_string_v128(lt20) + " -> " + mask_to_string_v128(SPLAT_0020));
+    // console.log("gteD8  : " + mask_to_string_v128(gteD8) + " -> " + mask_to_string_v128(SPLAT_FFD8));
 
-    const backslash_indices = i16x8.eq(block, SPLAT_92);
-    const quote_indices = i16x8.eq(block, SPLAT_34);
-    const escape_indices = i16x8.lt_u(block, SPLAT_32);
-    const sieve = v128.or(v128.or(backslash_indices, quote_indices), escape_indices);
+    const sieve = v128.or(eq22, v128.or(eq5C, v128.or(lt20, gteD8)));
+    // console.log("sieve  : " + mask_to_string_v128(sieve));
 
-    let mask = i16x8.bitmask(sieve);
+    if (!v128.any_true(sieve)) {
+        bs.offset += 16;
+        srcStart += 16;
+        continue;
+    }
+
+    let mask = i8x16.bitmask(sieve);
+
+      do {
+        const laneIdx = ctz(mask);
+        const srcIdx = srcStart + laneIdx;
+
+        mask &= mask - 1;
+        // Even (0 2 4 6 8 10 12 14) -> Confirmed ASCII Escape
+        // Odd (1 3 5 7 9 11 13 15) -> Possibly a Unicode code unit or surrogate
+
+        if ((laneIdx & 1) === 0) {
+          const code = load<u16>(srcIdx);
+          const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + (code << 2));
+
+          if ((escaped & 0xffff) != BACK_SLASH) {
+            bs.growSize(10);
+            const dstIdx = bs.offset + laneIdx;
+            store<u64>(dstIdx, U00_MARKER);
+            store<u32>(dstIdx, escaped, 8);
+            // memory.copy(dstIdx + 12, srcIdx + 2, 14 - laneIdx);
+            store<v128>(dstIdx, load<v128>(srcIdx, 2), 12); // unsafe. can overflow here
+            bs.offset += 10;
+          } else {
+            bs.growSize(2);
+            const dstIdx = bs.offset + laneIdx;
+            store<u32>(dstIdx, escaped);
+            store<v128>(dstIdx, load<v128>(srcIdx, 2), 4);
+            // memory.copy(dstIdx + 4, srcIdx + 2, 14 - laneIdx);
+            bs.offset += 2;
+          }
+          continue;
+        }
+
+        const code = load<u16>(srcIdx - 1);
+        // console.log("\nb->" + mask_to_string_v128(block));
+        // console.log("h->" + mask_to_string_v128(sieve));
+        // console.log("z->" + mask_to_string_v128(i8x16.ge_u(block,SPLAT_FFD8)));
+        // console.log("m->" + mask.toString(2));
+        // console.log("l->" + laneIdx.toString());
+        // console.log("c->" + code.toString(16));
+        if (code < 0xD800 || code > 0xDFFF) continue;
+
+        if (code <= 0xDBFF && srcIdx + 1 <= srcEnd - 2) {
+          const next = load<u16>(srcIdx, 1);
+          if (next >= 0xDC00 && next <= 0xDFFF) {
+            // paired surrogate
+            mask &= mask - 1;
+            continue;
+          }
+        }
 
-    while (mask != 0) {
-      const lane_index = ctz(mask) << 1; // 0 2 4 6 8 10 12 14
-      // console.log("lane: "  + (lane_index >= 8 ? (lane_index - 8).toString():lane_index.toString()));
-      const src_offset = srcStart + lane_index;
-      const code = load<u16>(src_offset) << 2;
-      const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + code);
-      mask &= mask - 1;
-      if ((escaped & 0xffff) != BACK_SLASH) {
         bs.growSize(10);
-        const dst_offset = bs.offset + lane_index;
-        store<u64>(dst_offset, U00_MARKER);
-        store<u32>(dst_offset, escaped, 8);
-        v128.store(dst_offset, v128.load(src_offset, 2), 12);
+        // unpaired high/low surrogate
+        const dstIdx = bs.offset + laneIdx - 1;
+        store<u32>(dstIdx, U_MARKER); // \u
+        store<u64>(dstIdx, load<u64>(changetype<usize>(code.toString(16))), 4);
+        // memory.copy(dstIdx + 12, srcIdx + 1, 15 - laneIdx);
+        store<v128>(dstIdx, load<v128>(srcIdx, 1), 12);
         bs.offset += 10;
-      } else {
-        bs.growSize(2);
-        const dst_offset = bs.offset + lane_index;
-        store<u32>(dst_offset, escaped);
-        v128.store(dst_offset, v128.load(src_offset, 2), 4);
-        bs.offset += 2;
-      }
-    }
+      } while (mask !== 0);
 
     srcStart += 16;
     bs.offset += 16;
@@ -87,15 +142,54 @@ if (isDefined(JSON_CACHE)) {
         store<u32>(bs.offset, escaped);
         bs.offset += 4;
       }
-    } else {
+      srcStart += 2;
+      continue;
+    }
+
+    if (code < 0xD800 || code > 0xDFFF) {
       store<u16>(bs.offset, code);
       bs.offset += 2;
+      srcStart += 2;
+      continue;
     }
+
+    if (code <= 0xDBFF && srcStart + 2 <= srcEnd - 2) {
+      const next = load<u16>(srcStart, 2);
+      if (next >= 0xDC00 && next <= 0xDFFF) {
+        // valid surrogate pair
+        store<u16>(bs.offset, code);
+        store<u16>(bs.offset + 2, next);
+        bs.offset += 4;
+        srcStart += 4;
+        continue;
+      }
+    }
+
+    // unpaired high/low surrogate
+    write_u_escape(code);
     srcStart += 2;
+    continue;
   }
 
-  store<u8>(bs.offset, 34); /* " */
+  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
+@inline function write_u_escape(code: u16): void {
+  bs.growSize(10);
+  store<u32>(bs.offset, U_MARKER); // "\u"
+  // write hex digits (lowercase, matches tests)
+  store<u16>(bs.offset + 4, hexNibble((code >> 12) & 0xF));
+  store<u16>(bs.offset + 6, hexNibble((code >> 8) & 0xF));
+  store<u16>(bs.offset + 8, hexNibble((code >> 4) & 0xF));
+  store<u16>(bs.offset + 10, hexNibble(code & 0xF));
+  bs.offset += 12;
+}
+
+// @ts-expect-error: @inline is a valid decorator
+@inline function hexNibble(n: u16): u16 {
+  return n < 10 ? (48 + n) : (87 + n);
+}

package/assembly/serialize/simple/arbitrary.ts

@@ -4,21 +4,13 @@ import { serializeArray } from "./array";
 import { serializeBool } from "./bool";
 import { serializeFloat } from "./float";
 import { serializeInteger } from "./integer";
+import { serializeMap } from "./map";
 import { serializeObject } from "./object";
 import { serializeString } from "./string";
 
 export function serializeArbitrary(src: JSON.Value): void {
-  if (src.type < JSON.Types.Null) {
-    if (src.isNull) {
-      bs.proposeSize(8);
-      store<u64>(bs.offset, 30399761348886638);
-      bs.offset += 8;
-      return;
-    } else src.type = ~src.type + 1;
-  }
-
   switch (src.type) {
-    case JSON.Types.Null: 
+    case JSON.Types.Null:
       bs.proposeSize(8);
       store<u64>(bs.offset, 30399761348886638);
       bs.offset += 8;
@@ -35,6 +27,18 @@ export function serializeArbitrary(src: JSON.Value): void {
     case JSON.Types.U64:
       serializeInteger<u64>(src.get<u64>());
       break;
+    case JSON.Types.I8:
+      serializeInteger<i8>(src.get<i8>());
+      break;
+    case JSON.Types.I16:
+      serializeInteger<i16>(src.get<i16>());
+      break;
+    case JSON.Types.I32:
+      serializeInteger<i32>(src.get<i32>());
+      break;
+    case JSON.Types.I64:
+      serializeInteger<i64>(src.get<i64>());
+      break;
     case JSON.Types.F32:
       serializeFloat<f32>(src.get<f32>());
       break;
@@ -55,6 +59,10 @@ export function serializeArbitrary(src: JSON.Value): void {
       serializeObject(src.get<JSON.Obj>());
       break;
     }
+    case JSON.Types.Map: {
+      serializeMap(src.get<Map<string, JSON.Value>>());
+      break;
+    }
     default: {
       const fn = JSON.Value.METHODS.get(src.type - JSON.Types.Struct);
       const ptr = src.get<usize>();

package/assembly/serialize/simple/set.ts

@@ -0,0 +1,34 @@
+import { bs } from "../../../lib/as-bs";
+import { COMMA, BRACKET_RIGHT, BRACKET_LEFT } from "../../custom/chars";
+import { JSON } from "../..";
+
+export function serializeSet<T extends Set<any>>(src: T): void {
+  bs.proposeSize(4);
+  const srcSize = src.size;
+  if (srcSize == 0) {
+    store<u32>(bs.offset, 6094939); // []
+    bs.offset += 4;
+    return;
+  }
+
+  const values = src.values();
+  const end = srcSize - 1;
+
+  store<u16>(bs.offset, BRACKET_LEFT);
+  bs.offset += 2;
+
+  for (let i = 0; i < end; i++) {
+    const block = unchecked(values[i]);
+    // @ts-ignore: type
+    JSON.__serialize<indexof<T>>(block);
+    bs.growSize(2);
+    store<u16>(bs.offset, COMMA);
+    bs.offset += 2;
+  }
+
+  const lastBlock = unchecked(values[end]);
+  // @ts-ignore: type
+  JSON.__serialize<indexof<T>>(lastBlock);
+  store<u16>(bs.offset, BRACKET_RIGHT);
+  bs.offset += 2;
+}

package/assembly/serialize/simple/staticarray.ts

@@ -0,0 +1,30 @@
+import { bs } from "../../../lib/as-bs";
+import { COMMA, BRACKET_RIGHT, BRACKET_LEFT } from "../../custom/chars";
+import { JSON } from "../..";
+
+export function serializeStaticArray<T extends StaticArray<any>>(src: T): void {
+  bs.proposeSize(4);
+  const end = src.length - 1;
+  let i = 0;
+  if (end == -1) {
+    store<u32>(bs.offset, 6094939); // []
+    bs.offset += 4;
+    return;
+  }
+
+  store<u16>(bs.offset, BRACKET_LEFT);
+  bs.offset += 2;
+
+  while (i < end) {
+    const block = unchecked(src[i++]);
+    JSON.__serialize<valueof<T>>(block);
+    bs.growSize(2);
+    store<u16>(bs.offset, COMMA);
+    bs.offset += 2;
+  }
+
+  const lastBlock = unchecked(src[end]);
+  JSON.__serialize<valueof<T>>(lastBlock);
+  store<u16>(bs.offset, BRACKET_RIGHT);
+  bs.offset += 2;
+}

package/assembly/serialize/simple/string.ts

@@ -3,6 +3,12 @@ import { _intTo16 } from "../../custom/util";
 import { bytes } from "../../util/bytes";
 import { BACK_SLASH, QUOTE } from "../../custom/chars";
 import { SERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
+import { serializeStruct } from "./struct";
+
+// @ts-ignore: decorator allowed
+@lazy const U00_MARKER = 13511005048209500;
+// @ts-ignore: decorator allowed
+@lazy const U_MARKER = 7667804;
 
 /**
  * Serializes valid strings into their JSON counterpart
@@ -22,14 +28,16 @@ import { SERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
   let lastPtr: usize = srcPtr;
   while (srcPtr < srcEnd) {
     const code = load<u16>(srcPtr);
+    srcPtr += 2;
+
     if (code == 34 || code == 92 || code < 32) {
-      const remBytes = srcPtr - lastPtr;
+      const remBytes = srcPtr - lastPtr - 2;
       memory.copy(bs.offset, lastPtr, remBytes);
       bs.offset += remBytes;
       const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + (code << 2));
       if ((escaped & 0xffff) != BACK_SLASH) {
         bs.growSize(10);
-        store<u64>(bs.offset, 13511005048209500, 0);
+        store<u64>(bs.offset, U00_MARKER, 0);
         store<u32>(bs.offset, escaped, 8);
         bs.offset += 12;
       } else {
@@ -37,9 +45,34 @@ import { SERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
         store<u32>(bs.offset, escaped, 0);
         bs.offset += 4;
       }
-      lastPtr = srcPtr + 2;
+      lastPtr = srcPtr;
+      continue;
     }
-    srcPtr += 2;
+    // srcPtr += 2;
+    if (code < 0xD800 || code > 0xDFFF) continue;
+
+    if (code <= 0xDBFF) {
+      if (srcPtr <= srcEnd - 2) {
+        const next = load<u16>(srcPtr);
+        if (next >= 0xDC00 && next <= 0xDFFF) {
+          srcPtr += 2;
+          continue;
+        }
+      }
+    }
+
+    const remBytes = srcPtr - lastPtr - 2;
+    memory.copy(bs.offset, lastPtr, remBytes);
+    bs.offset += remBytes;
+
+    // unpaired high/low surrogate
+    bs.growSize(10);
+    store<u32>(bs.offset, U_MARKER); // \u
+    store<u64>(bs.offset, load<u64>(changetype<usize>(code.toString(16))), 4);
+    bs.offset += 12;
+    lastPtr = srcPtr;
+    continue;
+
   }
   const remBytes = srcEnd - lastPtr;
   memory.copy(bs.offset, lastPtr, remBytes);
@@ -47,3 +80,20 @@ import { SERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
   store<u16>(bs.offset, QUOTE);
   bs.offset += 2;
 }
+
+// @ts-ignore: inline
+@inline function write_u_escape(code: u16): void {
+  bs.growSize(10);
+  store<u32>(bs.offset, U_MARKER); // "\u"
+  // write hex digits (lowercase, matches tests)
+  store<u16>(bs.offset + 4, hexNibble((code >> 12) & 0xF));
+  store<u16>(bs.offset + 6, hexNibble((code >> 8) & 0xF));
+  store<u16>(bs.offset + 8, hexNibble((code >> 4) & 0xF));
+  store<u16>(bs.offset + 10, hexNibble(code & 0xF));
+  bs.offset += 12;
+}
+
+// @ts-ignore: inline
+@inline function hexNibble(n: u16): u16 {
+  return n < 10 ? (48 + n) : (87 + n);
+}

package/assembly/serialize/swar/string.ts

@@ -3,33 +3,19 @@ import { BACK_SLASH } from "../../custom/chars";
 import { SERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
 import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
 
-
-// @ts-ignore: decorator allowed
-@lazy const LANE_MASK_HIGH = 0xFF00_FF00_FF00_FF00;
-// @ts-ignore: decorator allowed
-@lazy const ONES: u64 = 0x0101010101010101;
-// @ts-ignore: decorator allowed
-@lazy const LANE_MASK_LOW = 0x00FF_00FF_00FF_00FF;
-// @ts-ignore: decorator allowed
-@lazy const HIGHS = 0x8080808080808080;
-// @ts-ignore: decorator allowed
-@lazy const QUOTE_MASK = 0x0022_0022_0022_0022;
-// @ts-ignore: decorator allowed
-@lazy const BACKSLASH_MASK = 0x005C_005C_005C_005C;
-// @ts-ignore: decorator allowed
-@lazy const CONTROL_MASK = 0x0020_0020_0020_0020;
-// @ts-ignore: decorator allowed
+// @ts-expect-error: @lazy is a valid decorator
 @lazy const U00_MARKER = 13511005048209500;
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const U_MARKER = 7667804;
 
 export function serializeString_SWAR(src: string): void {
   let srcStart = changetype<usize>(src);
 
   if (isDefined(JSON_CACHE)) {
-    // check cache
     const e = unchecked(sc.entries[(srcStart >> 4) & sc.CACHE_MASK]);
     if (e.key == srcStart) {
-      // bs.offset += e.len;
-      // bs.stackSize += e.len;
+      bs.offset += e.len;
+      bs.stackSize += e.len;
       bs.cacheOutput = e.ptr;
       bs.cacheOutputLen = e.len;
       return;
@@ -44,38 +30,68 @@ export function serializeString_SWAR(src: string): void {
   store<u16>(bs.offset, 34); // "
   bs.offset += 2;
 
-  while (srcStart <= srcEnd8) {
-    const block = load<u64>(srcStart);
+  while (srcStart < srcEnd8) {
+    let block = load<u64>(srcStart);
     store<u64>(bs.offset, block);
 
-    let mask = v64x4_should_escape(block);
+    let mask = detect_escapable_u64_swar_unsafe(block);
 
-    while (mask != 0) {
-      const lane_index = usize(ctz(mask) >> 3); // 0 2 4 6
-      const src_offset = srcStart + lane_index;
-      // const dst_offset = bs.offset + lane_index;
-      const code = load<u16>(src_offset) << 2;
-      // console.log("lane: " + lane_index.toString())
-      const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + code);
+    if (mask === 0) {
+      srcStart += 8;
+      bs.offset += 8;
+      continue;
+    }
 
-      mask = mask & ~(0xFF << (lane_index << 3));
-      if ((escaped & 0xffff) != BACK_SLASH) {
-        bs.growSize(10);
-        const dst_offset = bs.offset + lane_index;
-        store<u64>(dst_offset, U00_MARKER);
-        store<u32>(dst_offset, escaped, 8);
-        store<u64>(dst_offset, load<u64>(src_offset, 2), 12); // unsafe. can overflow here
-        // memory.copy(dst_offset + 12, src_offset + 2, (4 - lane_index) << 1);
-        bs.offset += 10;
-      } else {
-        bs.growSize(2);
-        const dst_offset = bs.offset + lane_index;
-        store<u32>(dst_offset, escaped);
-        store<u64>(dst_offset, load<u64>(src_offset, 2), 4);
-        // memory.copy(dst_offset + 4, src_offset + 2, (4 - lane_index) << 1);
-        bs.offset += 2;
+    do {
+      const laneIdx = usize(ctz(mask) >> 3);
+      const srcIdx = srcStart + laneIdx;
+      // Even (0 2 4 6) -> Confirmed ASCII Escape
+      // Odd (1 3 5 7) -> Possibly a Unicode code unit or surrogate
+      if ((laneIdx & 1) === 0 && (mask & (0xFF << (laneIdx + 1 << 3))) === 0) {
+      mask &= ~(0xFFFF << (laneIdx << 3));
+        const code = load<u16>(srcIdx);
+        const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + (code << 2));
+
+        if ((escaped & 0xffff) != BACK_SLASH) {
+          bs.growSize(10);
+          const dstIdx = bs.offset + laneIdx;
+          store<u64>(dstIdx, U00_MARKER);
+          store<u32>(dstIdx, escaped, 8);
+          store<u64>(dstIdx, load<u64>(srcIdx, 2), 12);
+          bs.offset += 10;
+        } else {
+          bs.growSize(2);
+          const dstIdx = bs.offset + laneIdx;
+          store<u32>(dstIdx, escaped);
+          store<u64>(dstIdx, load<u64>(srcIdx, 2), 4);
+          bs.offset += 2;
+        }
+        continue;
+      }
+      mask &= ~(0xFFFF << (laneIdx << 3));
+
+      const code = load<u16>(srcIdx - 1);
+      if (code < 0xD800 || code > 0xDFFF) continue;
+
+      if (code <= 0xDBFF && srcIdx + 2 < srcEnd) {
+        const next = load<u16>(srcIdx, 1);
+        if (next >= 0xDC00 && next <= 0xDFFF) {
+          // paired surrogate
+          // mask &= ~(0xFF << ((laneIdx+2) << 3));
+          mask &= mask - 1;
+          continue;
+        }
       }
-    }
+
+      bs.growSize(10);
+
+      // unpaired high/low surrogate
+      const dstIdx = bs.offset + laneIdx - 1;
+      store<u32>(dstIdx, U_MARKER); // \u
+      store<u64>(dstIdx, load<u64>(changetype<usize>(code.toString(16))), 4);
+      store<u64>(dstIdx, load<u64>(srcIdx, 1), 12);
+      bs.offset += 10;
+    } while (mask !== 0);
 
     srcStart += 8;
     bs.offset += 8;
@@ -83,6 +99,7 @@ export function serializeString_SWAR(src: string): void {
 
   while (srcStart <= srcEnd - 2) {
     const code = load<u16>(srcStart);
+
     if (code == 92 || code == 34 || code < 32) {
       const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + (code << 2));
       if ((escaped & 0xffff) != BACK_SLASH) {
@@ -95,11 +112,33 @@ export function serializeString_SWAR(src: string): void {
         store<u32>(bs.offset, escaped);
         bs.offset += 4;
       }
-    } else {
+      srcStart += 2;
+      continue;
+    }
+
+    if (code < 0xD800 || code > 0xDFFF) {
       store<u16>(bs.offset, code);
       bs.offset += 2;
+      srcStart += 2;
+      continue;
     }
+
+    if (code <= 0xDBFF && srcStart + 2 <= srcEnd - 2) {
+      const next = load<u16>(srcStart, 2);
+      if (next >= 0xDC00 && next <= 0xDFFF) {
+        // valid surrogate pair
+        store<u16>(bs.offset, code);
+        store<u16>(bs.offset + 2, next);
+        bs.offset += 4;
+        srcStart += 4;
+        continue;
+      }
+    }
+
+    // unpaired high/low surrogate
+    write_u_escape(code);
     srcStart += 2;
+    continue;
   }
 
   store<u16>(bs.offset, 34); // "
@@ -108,28 +147,45 @@ export function serializeString_SWAR(src: string): void {
   if (isDefined(JSON_CACHE)) sc.insertCached(changetype<usize>(src), srcStart, srcSize);
 }
 
-// @ts-ignore: decorators allowed
-@inline function v64x4_should_escape(x: u64): u64 {
- // console.log("input:    " + mask_to_string(x));
-  const hi = x & 0xff00_ff00_ff00_ff00;
-  const lo = x & 0x00ff_00ff_00ff_00ff;
-  x &= 0x00ff_00ff_00ff_00ff;
-  // const is_cp = hi & 0x8080_8080_8080_8080;
-  const is_ascii = 0x0080_0080_0080_0080 & ~x; // lane remains 0x80 if ascii
-  const lt32 = (x - 0x0020_0020_0020_0020);
-  const sub34 = x ^ 0x0022_0022_0022_0022;
-  const eq34 = (sub34 - 0x0001_0001_0001_0001);
-  const sub92 = x ^ 0x005C_005C_005C_005C;
-  const eq92 = (sub92 - 0x0001_0001_0001_0001);
-  // console.log("low:      " + mask_to_string(lo));
-  // console.log("high:     " + mask_to_string(hi));
-  // console.log("is_cp:    " + mask_to_string(is_cp));
-  // console.log("is_ascii: " + mask_to_string(is_ascii));
-  // console.log("lt32:     " + mask_to_string(lt32));
-  // console.log("sub34:    " + mask_to_string(sub34));
-  // console.log("eq34:     " + mask_to_string(eq34));
-  // console.log("eq92:     " + mask_to_string(eq92));
-  // console.log("pre:      " + mask_to_string((lt32 | eq34 | eq92)));
-  // console.log("out:      " + mask_to_string((lt32 | eq34 | eq92) & is_ascii));
-  return ((lt32 | eq34 | eq92)& is_ascii);
-}
+// @ts-expect-error: @inline is a valid decorator
+@inline function write_u_escape(code: u16): void {
+  bs.growSize(10);
+  store<u32>(bs.offset, U_MARKER); // "\u"
+  // write hex digits (lowercase, matches tests)
+  store<u16>(bs.offset + 4, hexNibble((code >> 12) & 0xF));
+  store<u16>(bs.offset + 6, hexNibble((code >> 8) & 0xF));
+  store<u16>(bs.offset + 8, hexNibble((code >> 4) & 0xF));
+  store<u16>(bs.offset + 10, hexNibble(code & 0xF));
+  bs.offset += 12;
+}
+
+// @ts-expect-error: @inline is a valid decorator
+@inline function hexNibble(n: u16): u16 {
+  return n < 10 ? (48 + n) : (87 + n);
+}
+
+// @ts-expect-error: @inline is a valid decorator
+@inline export function detect_escapable_u64_swar(block: u64): u64 {
+  const lo = block & 0x00FF_00FF_00FF_00FF;
+  const ascii_mask = (
+    ((lo - 0x0020_0020_0020_0020) |
+      ((lo ^ 0x0022_0022_0022_0022) - 0x0001_0001_0001_0001) |
+      ((lo ^ 0x005C_005C_005C_005C) - 0x0001_0001_0001_0001))
+    & (0x0080_0080_0080_0080 & ~lo)
+  );
+  const hi_mask = ((block - 0x0100_0100_0100_0100) & ~block & 0x8000_8000_8000_8000) ^ 0x8000_8000_8000_8000;
+  return (ascii_mask & (~hi_mask >> 8)) | hi_mask;
+}
+
+// @ts-expect-error: @inline is a valid decorator
+@inline export function detect_escapable_u64_swar_unsafe(block: u64): u64 {
+  const lo = block & 0x00FF_00FF_00FF_00FF;
+  const ascii_mask = (
+    ((lo - 0x0020_0020_0020_0020) |
+      ((lo ^ 0x0022_0022_0022_0022) - 0x0001_0001_0001_0001) |
+      ((lo ^ 0x005C_005C_005C_005C) - 0x0001_0001_0001_0001))
+    & (0x0080_0080_0080_0080 & ~lo)
+  );
+  const hi = block & 0xFF00_FF00_FF00_FF00;
+  return ascii_mask | hi;
+}