json-as 1.3.0 → 1.3.2

package/assembly/deserialize/swar/string.ts

@@ -1,5 +1,6 @@
 import { bs } from "../../../lib/as-bs";
 import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
+import { __heap_base } from "memory";
 import { BACK_SLASH, QUOTE } from "../../custom/chars";
 import { DESERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
 import { hex4_to_u16_swar } from "../../util/swar";
@@ -43,7 +44,6 @@ import { hex4_to_u16_swar } from "../../util/swar";
 // @ts-expect-error: @inline is a valid decorator
 @inline function copyStringFromSource(srcStart: usize, byteLength: usize): string {
   if (byteLength == 0) return changetype<string>("");
-  // @ts-expect-error: __new is a runtime builtin
   const out = __new(byteLength, idof<string>());
   memory.copy(out, srcStart, byteLength);
   return changetype<string>(out);
@@ -53,10 +53,10 @@ import { hex4_to_u16_swar } from "../../util/swar";
 @inline function deserializeEscapedString_SWAR(payloadStart: usize, escapeStart: usize, srcEnd: usize): string {
   const srcEnd8 = srcEnd - 8;
   const prefixLen = <u32>(escapeStart - payloadStart);
-  bs.offset = bs.buffer;
+  const outStart = bs.offset - bs.buffer;
   bs.ensureSize(<u32>(srcEnd - payloadStart));
   if (prefixLen != 0) {
-    memory.copy(bs.buffer, payloadStart, prefixLen);
+    memory.copy(bs.offset, payloadStart, prefixLen);
     bs.offset += prefixLen;
   }
 
@@ -141,7 +141,7 @@ import { hex4_to_u16_swar } from "../../util/swar";
 
     bs.offset += 2;
   }
-  return bs.out<string>();
+  return bs.sliceOut<string>(outStart);
 }
 
 export function deserializeString_SWAR(srcStart: usize, srcEnd: usize): string {
@@ -185,106 +185,7 @@ export function deserializeString_SWAR(srcStart: usize, srcEnd: usize): string {
   return copyStringFromSource(payloadStart, srcEnd - payloadStart);
 }
 
-// /**
-//  * Deserializes a quoted JSON string into a reused/renewed destination string buffer.
-//  * @param srcStart pointer to opening quote
-//  * @param srcEnd pointer to closing quote
-//  * @param outPtr existing destination string pointer (or 0)
-//  * @returns next unread source pointer
-//  */
-// export function deserializeString_SWAR_TO(srcStart: usize, srcEnd: usize, outPtr: usize): usize {
-//   srcStart += 2;
-//   let dst = outPtr;
-//   const srcEnd8 = srcEnd - 8;
-//   const byteSize = srcEnd - srcStart;
-//   if (!dst) {
-//     dst = __new(byteSize, idof<string>());
-//   } else if (changetype<OBJECT>(dst - TOTAL_OVERHEAD).rtSize < <u32>byteSize) {
-//     dst = __renew(dst, byteSize);
-//   }
-//   let offset = dst;
-
-//   while (srcStart < srcEnd8) {
-//     const block = load<u64>(srcStart);
-//     store<u64>(offset, block);
-
-//     let mask = inline.always(backslash_mask_unsafe(block));
-
-//     if (mask === 0) {
-//       srcStart += 8;
-//       offset += 8;
-//       continue;
-//     }
-
-//     do {
-//       const laneIdx = usize(ctz(mask) >> 3); // 0 2 4 6
-//       mask &= mask - 1;
-//       const srcIdx = srcStart + laneIdx;
-//       const dstIdx = offset + laneIdx;
-//       const header = load<u32>(srcIdx);
-//       const code = <u16>(header >> 16);
-
-//       if ((header & 0xffff) !== 0x5c) continue;
-
-//       if (code !== 0x75) {
-//         const escaped = load<u16>(DESERIALIZE_ESCAPE_TABLE + code);
-//         mask &= mask - usize(escaped === 0x5c);
-//         store<u16>(dstIdx, escaped);
-//         const copyStart = srcIdx + 4;
-//         if (copyStart < srcEnd) {
-//           const copyBytes = min<usize>(4, srcEnd - copyStart);
-//           memory.copy(dstIdx + 2, copyStart, copyBytes);
-//         }
-
-//         const l6 = usize(laneIdx === 6);
-//         offset -= (1 - l6) << 1;
-//         srcStart += l6 << 1;
-//         continue;
-//       }
-
-//       const block = load<u64>(srcIdx, 4); // XXXX
-//       const escaped = hex4_to_u16_swar(block);
-//       store<u16>(dstIdx, escaped);
-//       srcStart += 4 + laneIdx;
-//       offset -= 6 - laneIdx;
-//     } while (mask !== 0);
-
-//     offset += 8;
-//     srcStart += 8;
-//   }
-
-//   while (srcStart < srcEnd) {
-//     const block = load<u16>(srcStart);
-//     store<u16>(offset, block);
-//     srcStart += 2;
-
-//     if (block !== 0x5c) {
-//       offset += 2;
-//       continue;
-//     }
-
-//     const code = load<u16>(srcStart);
-//     if (code !== 0x75) {
-//       const block = load<u16>(srcStart);
-//       const escape = load<u16>(DESERIALIZE_ESCAPE_TABLE + block);
-//       store<u16>(offset, escape);
-//       srcStart += 2;
-//     } else {
-//       const block = load<u64>(srcStart, 2); // XXXX
-//       const escaped = hex4_to_u16_swar(block);
-//       store<u16>(offset, escaped);
-//       srcStart += 10;
-//     }
-
-//     offset += 2;
-//   }
-//   if (offset - dst != byteSize) {
-//     dst = __renew(dst, offset - dst);
-//   }
-//   return srcEnd + 2;
-// }
-
-// Scans a quoted string value, writes into the destination field, and returns next unread src pointer.
+// Writes into the destination field, reusing or resizing the backing string.
 // @ts-expect-error: @inline is a valid decorator
 @inline function writeStringToField(dstFieldPtr: usize, srcStart: usize, byteLength: u32): void {
   if (byteLength == 0) {
@@ -294,11 +195,13 @@ export function deserializeString_SWAR(srcStart: usize, srcEnd: usize): string {
 
   const current = load<usize>(dstFieldPtr);
   let stringPtr: usize;
-  if (current != 0 && changetype<OBJECT>(current - TOTAL_OVERHEAD).rtSize == byteLength) {
-    stringPtr = current;
-  } else if (current != 0 && current != changetype<usize>("")) {
-    stringPtr = __renew(current, byteLength);
-    store<usize>(dstFieldPtr, stringPtr);
+  if (current >= __heap_base) {
+    if (changetype<OBJECT>(current - TOTAL_OVERHEAD).rtSize == byteLength) {
+      stringPtr = current;
+    } else {
+      stringPtr = __renew(current, byteLength);
+      store<usize>(dstFieldPtr, stringPtr);
+    }
   } else {
     stringPtr = __new(byteLength, idof<string>());
     store<usize>(dstFieldPtr, stringPtr);
@@ -306,17 +209,14 @@ export function deserializeString_SWAR(srcStart: usize, srcEnd: usize): string {
   memory.copy(stringPtr, srcStart, byteLength);
 }
 
-/*
-export function deserializeStringField_SWAR<T extends string | null>(srcStart: usize, srcEnd: usize, dstFieldPtr: usize): usize {
-  if (srcStart + 2 > srcEnd || load<u16>(srcStart) != QUOTE) abort("Expected leading quote");
 
-  const payloadStart = srcStart + 2;
-  const srcEnd8 = srcEnd >= 8 ? srcEnd - 8 : 0;
-  srcStart = payloadStart;
+// @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;
 
   while (srcStart <= srcEnd8) {
+    const blockStart = srcStart;
     let mask = inline.always(backslash_or_quote_mask(load<u64>(srcStart)));
-
     if (mask === 0) {
       srcStart += 8;
       continue;
@@ -324,290 +224,89 @@ export function deserializeStringField_SWAR<T extends string | null>(srcStart: u
 
     do {
       const laneIdx = usize(ctz(mask) >> 3);
-      mask &= ~(0xffff << (laneIdx << 3));
-      // since we clear the entire byte, we can guarentee that any discovered lane where char == QUOTE is unescaped and a terminator.
+      mask &= mask - 1;
       const srcIdx = srcStart + laneIdx;
       const char = load<u16>(srcIdx);
-
       if (char == QUOTE) {
-        writeStringToField(dstFieldPtr, payloadStart, <u32>(srcIdx - payloadStart));
+        const runLen = <u32>(srcIdx - lastPtr);
+        if (runLen != 0) {
+          memory.copy(bs.offset, lastPtr, runLen);
+          bs.offset += runLen;
+        }
+        bs.toField(outStart, dstFieldPtr);
         return srcIdx + 2;
       }
       if (char != BACK_SLASH) continue;
 
-      bs.offset = bs.buffer;
-      bs.ensureSize(<u32>(srcEnd - payloadStart));
-      const prefixLen = <u32>(srcIdx - payloadStart);
-      if (prefixLen != 0) {
-        memory.copy(bs.buffer, payloadStart, prefixLen);
-        bs.offset += prefixLen;
+      const runLen = <u32>(srcIdx - lastPtr);
+      if (runLen != 0) {
+        memory.copy(bs.offset, lastPtr, runLen);
+        bs.offset += runLen;
       }
 
       const chunk = load<u32>(srcIdx);
       const code = <u16>(chunk >> 16);
-
       if (code !== 0x75) {
         store<u16>(bs.offset, load<u16>(DESERIALIZE_ESCAPE_TABLE + code));
         bs.offset += 2;
-        let lastPtr = srcIdx + 4;
-        srcStart = lastPtr;
-        while (srcStart <= srcEnd8) {
-          const blockStart = srcStart;
-          let escapedMask = inline.always(backslash_or_quote_mask(load<u64>(srcStart)));
-          if (escapedMask === 0) {
-            srcStart += 8;
-            continue;
-          }
-
-          do {
-            const escapedLaneIdx = usize(ctz(escapedMask) >> 3);
-            escapedMask &= escapedMask - 1;
-            const escapedIdx = srcStart + escapedLaneIdx;
-            const escapedChar = load<u16>(escapedIdx);
-
-            if (escapedChar == QUOTE) {
-              const runLen = <u32>(escapedIdx - lastPtr);
-              if (runLen != 0) {
-                memory.copy(bs.offset, lastPtr, runLen);
-                bs.offset += runLen;
-              }
-              writeStringToField(dstFieldPtr, bs.buffer, <u32>(bs.offset - bs.buffer));
-              bs.offset = bs.buffer;
-              return escapedIdx + 2;
-            }
-            if (escapedChar != BACK_SLASH) continue;
-
-            const runLen = <u32>(escapedIdx - lastPtr);
-            if (runLen != 0) {
-              memory.copy(bs.offset, lastPtr, runLen);
-              bs.offset += runLen;
-            }
-
-            const escapedChunk = load<u32>(escapedIdx);
-            const escapedCode = <u16>(escapedChunk >> 16);
-            if (escapedCode !== 0x75) {
-              store<u16>(bs.offset, load<u16>(DESERIALIZE_ESCAPE_TABLE + escapedCode));
-              bs.offset += 2;
-              lastPtr = escapedIdx + 4;
-            } else {
-              store<u16>(bs.offset, hex4_to_u16_swar(load<u64>(escapedIdx, 4)));
-              bs.offset += 2;
-              lastPtr = escapedIdx + 12;
-            }
-            srcStart = lastPtr;
-            break;
-          } while (escapedMask !== 0);
-
-          if (srcStart == blockStart) srcStart += 8;
-        }
-
-        while (srcStart < srcEnd) {
-          const tailChar = load<u16>(srcStart);
-          if (tailChar == QUOTE) {
-            const runLen = <u32>(srcStart - lastPtr);
-            if (runLen != 0) {
-              memory.copy(bs.offset, lastPtr, runLen);
-              bs.offset += runLen;
-            }
-            writeStringToField(dstFieldPtr, bs.buffer, <u32>(bs.offset - bs.buffer));
-            bs.offset = bs.buffer;
-            return srcStart + 2;
-          }
-          if (tailChar != BACK_SLASH) {
-            srcStart += 2;
-            continue;
-          }
-
-          const runLen = <u32>(srcStart - lastPtr);
-          if (runLen != 0) {
-            memory.copy(bs.offset, lastPtr, runLen);
-            bs.offset += runLen;
-          }
-          const tailCode = load<u16>(srcStart, 2);
-          if (tailCode !== 0x75) {
-            store<u16>(bs.offset, load<u16>(DESERIALIZE_ESCAPE_TABLE + tailCode));
-            bs.offset += 2;
-            srcStart += 4;
-          } else {
-            store<u16>(bs.offset, hex4_to_u16_swar(load<u64>(srcStart, 4)));
-            bs.offset += 2;
-            srcStart += 12;
-          }
-          lastPtr = srcStart;
-        }
-        bs.offset = bs.buffer;
-        return srcStart;
+        lastPtr = srcIdx + 4;
       } else {
         store<u16>(bs.offset, hex4_to_u16_swar(load<u64>(srcIdx, 4)));
         bs.offset += 2;
-        let lastPtr = srcIdx + 12;
-        srcStart = lastPtr;
-        while (srcStart <= srcEnd8) {
-          const blockStart = srcStart;
-          let escapedMask = inline.always(backslash_or_quote_mask(load<u64>(srcStart)));
-          if (escapedMask === 0) {
-            srcStart += 8;
-            continue;
-          }
-
-          do {
-            const escapedLaneIdx = usize(ctz(escapedMask) >> 3);
-            escapedMask &= escapedMask - 1;
-            const escapedIdx = srcStart + escapedLaneIdx;
-            const escapedChar = load<u16>(escapedIdx);
-
-            if (escapedChar == QUOTE) {
-              const runLen = <u32>(escapedIdx - lastPtr);
-              if (runLen != 0) {
-                memory.copy(bs.offset, lastPtr, runLen);
-                bs.offset += runLen;
-              }
-              writeStringToField(dstFieldPtr, bs.buffer, <u32>(bs.offset - bs.buffer));
-              bs.offset = bs.buffer;
-              return escapedIdx + 2;
-            }
-            if (escapedChar != BACK_SLASH) continue;
-
-            const runLen = <u32>(escapedIdx - lastPtr);
-            if (runLen != 0) {
-              memory.copy(bs.offset, lastPtr, runLen);
-              bs.offset += runLen;
-            }
-
-            const escapedChunk = load<u32>(escapedIdx);
-            const escapedCode = <u16>(escapedChunk >> 16);
-            if (escapedCode !== 0x75) {
-              store<u16>(bs.offset, load<u16>(DESERIALIZE_ESCAPE_TABLE + escapedCode));
-              bs.offset += 2;
-              lastPtr = escapedIdx + 4;
-            } else {
-              store<u16>(bs.offset, hex4_to_u16_swar(load<u64>(escapedIdx, 4)));
-              bs.offset += 2;
-              lastPtr = escapedIdx + 12;
-            }
-            srcStart = lastPtr;
-            break;
-          } while (escapedMask !== 0);
-
-          if (srcStart == blockStart) srcStart += 8;
-        }
-
-        while (srcStart < srcEnd) {
-          const tailChar = load<u16>(srcStart);
-          if (tailChar == QUOTE) {
-            const runLen = <u32>(srcStart - lastPtr);
-            if (runLen != 0) {
-              memory.copy(bs.offset, lastPtr, runLen);
-              bs.offset += runLen;
-            }
-            writeStringToField(dstFieldPtr, bs.buffer, <u32>(bs.offset - bs.buffer));
-            bs.offset = bs.buffer;
-            return srcStart + 2;
-          }
-          if (tailChar != BACK_SLASH) {
-            srcStart += 2;
-            continue;
-          }
-
-          const runLen = <u32>(srcStart - lastPtr);
-          if (runLen != 0) {
-            memory.copy(bs.offset, lastPtr, runLen);
-            bs.offset += runLen;
-          }
-          const tailCode = load<u16>(srcStart, 2);
-          if (tailCode !== 0x75) {
-            store<u16>(bs.offset, load<u16>(DESERIALIZE_ESCAPE_TABLE + tailCode));
-            bs.offset += 2;
-            srcStart += 4;
-          } else {
-            store<u16>(bs.offset, hex4_to_u16_swar(load<u64>(srcStart, 4)));
-            bs.offset += 2;
-            srcStart += 12;
-          }
-          lastPtr = srcStart;
-        }
-        bs.offset = bs.buffer;
-        return srcStart;
+        lastPtr = srcIdx + 12;
       }
+      srcStart = lastPtr;
+      break;
     } while (mask !== 0);
+
+    if (srcStart == blockStart) srcStart += 8;
   }
 
   while (srcStart < srcEnd) {
     const char = load<u16>(srcStart);
     if (char == QUOTE) {
-      writeStringToField(dstFieldPtr, payloadStart, <u32>(srcStart - payloadStart));
+      const runLen = <u32>(srcStart - lastPtr);
+      if (runLen != 0) {
+        memory.copy(bs.offset, lastPtr, runLen);
+        bs.offset += runLen;
+      }
+      bs.toField(outStart, dstFieldPtr);
       return srcStart + 2;
     }
-    if (char == BACK_SLASH) {
-      bs.offset = bs.buffer;
-      bs.ensureSize(<u32>(srcEnd - payloadStart));
-      const prefixLen = <u32>(srcStart - payloadStart);
-      if (prefixLen != 0) {
-        memory.copy(bs.buffer, payloadStart, prefixLen);
-        bs.offset += prefixLen;
-      }
+    if (char != BACK_SLASH) {
+      srcStart += 2;
+      continue;
+    }
 
-      let lastPtr = srcStart;
-      const code = load<u16>(srcStart, 2);
-      if (code !== 0x75) {
-        store<u16>(bs.offset, load<u16>(DESERIALIZE_ESCAPE_TABLE + code));
-        bs.offset += 2;
-        srcStart += 4;
-      } else {
-        store<u16>(bs.offset, hex4_to_u16_swar(load<u64>(srcStart, 4)));
-        bs.offset += 2;
-        srcStart += 12;
-      }
-      lastPtr = srcStart;
-
-      while (srcStart < srcEnd) {
-        const tailChar = load<u16>(srcStart);
-        if (tailChar == QUOTE) {
-          const runLen = <u32>(srcStart - lastPtr);
-          if (runLen != 0) {
-            memory.copy(bs.offset, lastPtr, runLen);
-            bs.offset += runLen;
-          }
-          writeStringToField(dstFieldPtr, bs.buffer, <u32>(bs.offset - bs.buffer));
-          bs.offset = bs.buffer;
-          return srcStart + 2;
-        }
-        if (tailChar != BACK_SLASH) {
-          srcStart += 2;
-          continue;
-        }
+    const runLen = <u32>(srcStart - lastPtr);
+    if (runLen != 0) {
+      memory.copy(bs.offset, lastPtr, runLen);
+      bs.offset += runLen;
+    }
 
-        const runLen = <u32>(srcStart - lastPtr);
-        if (runLen != 0) {
-          memory.copy(bs.offset, lastPtr, runLen);
-          bs.offset += runLen;
-        }
-        const tailCode = load<u16>(srcStart, 2);
-        if (tailCode !== 0x75) {
-          store<u16>(bs.offset, load<u16>(DESERIALIZE_ESCAPE_TABLE + tailCode));
-          bs.offset += 2;
-          srcStart += 4;
-        } else {
-          store<u16>(bs.offset, hex4_to_u16_swar(load<u64>(srcStart, 4)));
-          bs.offset += 2;
-          srcStart += 12;
-        }
-        lastPtr = srcStart;
-      }
-      bs.offset = bs.buffer;
-      return srcStart;
+    const code = load<u16>(srcStart, 2);
+    if (code !== 0x75) {
+      store<u16>(bs.offset, load<u16>(DESERIALIZE_ESCAPE_TABLE + code));
+      bs.offset += 2;
+      srcStart += 4;
+    } else {
+      store<u16>(bs.offset, hex4_to_u16_swar(load<u64>(srcStart, 4)));
+      bs.offset += 2;
+      srcStart += 12;
     }
-    srcStart += 2;
+    lastPtr = srcStart;
   }
 
+  bs.offset = bs.buffer + outStart;
+  abort("Unterminated string literal");
   return srcStart;
 }
-*/
 
+// Scans a quoted string value, writes into the destination field, and returns next unread src pointer.
 // @ts-expect-error: @inline is a valid decorator
-@inline function deserializeEscapedStringScan_SWAR(payloadStart: usize, escapeStart: usize, srcEnd: usize, dstFieldPtr: usize): usize {
+@inline function deserializeEscapedStringScan_SWAR_SplitTuned(payloadStart: usize, escapeStart: usize, srcEnd: usize, dstFieldPtr: usize): usize {
   const prefixLen = <u32>(escapeStart - payloadStart);
-  const srcEnd8 = srcEnd >= 8 ? srcEnd - 8 : 0;
+  const srcEnd8 = srcEnd - 8;
   bs.offset = bs.buffer;
   bs.ensureSize(<u32>(srcEnd - payloadStart));
   if (prefixLen != 0) {
@@ -699,7 +398,6 @@ export function deserializeStringField_SWAR<T extends string | null>(srcStart: u
       bs.offset += 2;
       srcStart += 12;
     }
-
     lastPtr = srcStart;
   }
 
@@ -708,12 +406,189 @@ export function deserializeStringField_SWAR<T extends string | null>(srcStart: u
   return srcStart;
 }
 
-// Scans a quoted string value, writes into the destination field, and returns next unread src pointer.
+// @ts-expect-error: @inline is a valid decorator
+@inline function deserializeEscapedStringContinuation_SWAR_MergedTuned(lastPtr: usize, srcStart: usize, srcEnd: usize, dstFieldPtr: usize): usize {
+  const srcEnd8 = srcEnd - 8;
+
+  while (srcStart <= srcEnd8) {
+    const blockStart = srcStart;
+    let mask = inline.always(backslash_or_quote_mask(load<u64>(srcStart)));
+    if (mask === 0) {
+      srcStart += 8;
+      continue;
+    }
+
+    do {
+      const laneIdx = usize(ctz(mask) >> 3);
+      mask &= mask - 1;
+      const srcIdx = srcStart + laneIdx;
+      const char = load<u16>(srcIdx);
+      if (char == QUOTE) {
+        const runLen = <u32>(srcIdx - lastPtr);
+        if (runLen != 0) {
+          memory.copy(bs.offset, lastPtr, runLen);
+          bs.offset += runLen;
+        }
+        writeStringToField(dstFieldPtr, bs.buffer, <u32>(bs.offset - bs.buffer));
+        bs.offset = bs.buffer;
+        return srcIdx + 2;
+      }
+      if (char != BACK_SLASH) continue;
+
+      const runLen = <u32>(srcIdx - lastPtr);
+      if (runLen != 0) {
+        memory.copy(bs.offset, lastPtr, runLen);
+        bs.offset += runLen;
+      }
+
+      const chunk = load<u32>(srcIdx);
+      const code = <u16>(chunk >> 16);
+      if (code !== 0x75) {
+        store<u16>(bs.offset, load<u16>(DESERIALIZE_ESCAPE_TABLE + code));
+        bs.offset += 2;
+        lastPtr = srcIdx + 4;
+      } else {
+        store<u16>(bs.offset, hex4_to_u16_swar(load<u64>(srcIdx, 4)));
+        bs.offset += 2;
+        lastPtr = srcIdx + 12;
+      }
+      srcStart = lastPtr;
+      break;
+    } while (mask !== 0);
+
+    if (srcStart == blockStart) srcStart += 8;
+  }
+
+  while (srcStart < srcEnd) {
+    const tailChar = load<u16>(srcStart);
+    if (tailChar == QUOTE) {
+      const runLen = <u32>(srcStart - lastPtr);
+      if (runLen != 0) {
+        memory.copy(bs.offset, lastPtr, runLen);
+        bs.offset += runLen;
+      }
+      writeStringToField(dstFieldPtr, bs.buffer, <u32>(bs.offset - bs.buffer));
+      bs.offset = bs.buffer;
+      return srcStart + 2;
+    }
+    if (tailChar != BACK_SLASH) {
+      srcStart += 2;
+      continue;
+    }
+
+    const runLen = <u32>(srcStart - lastPtr);
+    if (runLen != 0) {
+      memory.copy(bs.offset, lastPtr, runLen);
+      bs.offset += runLen;
+    }
+    const tailCode = load<u16>(srcStart, 2);
+    if (tailCode !== 0x75) {
+      store<u16>(bs.offset, load<u16>(DESERIALIZE_ESCAPE_TABLE + tailCode));
+      bs.offset += 2;
+      srcStart += 4;
+    } else {
+      store<u16>(bs.offset, hex4_to_u16_swar(load<u64>(srcStart, 4)));
+      bs.offset += 2;
+      srcStart += 12;
+    }
+    lastPtr = srcStart;
+  }
+
+  bs.offset = bs.buffer;
+  return srcStart;
+}
+
+function deserializeStringField_SWAR_MergedTuned(srcStart: usize, srcEnd: usize, dstFieldPtr: usize): usize {
+  if (srcStart + 2 > srcEnd || load<u16>(srcStart) != QUOTE) abort("Expected leading quote");
+
+  const payloadStart = srcStart + 2;
+  const srcEnd8 = srcEnd - 8;
+  srcStart = payloadStart;
+
+  while (srcStart <= srcEnd8) {
+    let mask = inline.always(backslash_or_quote_mask(load<u64>(srcStart)));
+    if (mask === 0) {
+      srcStart += 8;
+      continue;
+    }
+
+    do {
+      const laneIdx = usize(ctz(mask) >> 3);
+      mask &= ~(0xffff << (laneIdx << 3));
+      const srcIdx = srcStart + laneIdx;
+      const char = load<u16>(srcIdx);
+
+      if (char == QUOTE) {
+        writeStringToField(dstFieldPtr, payloadStart, <u32>(srcIdx - payloadStart));
+        return srcIdx + 2;
+      }
+      if (char != BACK_SLASH) continue;
+
+      bs.offset = bs.buffer;
+      bs.ensureSize(<u32>(srcEnd - payloadStart));
+      const prefixLen = <u32>(srcIdx - payloadStart);
+      if (prefixLen != 0) {
+        memory.copy(bs.buffer, payloadStart, prefixLen);
+        bs.offset += prefixLen;
+      }
+
+      const chunk = load<u32>(srcIdx);
+      const code = <u16>(chunk >> 16);
+      let lastPtr: usize;
+      if (code !== 0x75) {
+        store<u16>(bs.offset, load<u16>(DESERIALIZE_ESCAPE_TABLE + code));
+        bs.offset += 2;
+        lastPtr = srcIdx + 4;
+      } else {
+        store<u16>(bs.offset, hex4_to_u16_swar(load<u64>(srcIdx, 4)));
+        bs.offset += 2;
+        lastPtr = srcIdx + 12;
+      }
+      return inline.always(deserializeEscapedStringContinuation_SWAR_MergedTuned(lastPtr, lastPtr, srcEnd, dstFieldPtr));
+    } while (mask !== 0);
+
+    srcStart += 8;
+  }
+
+  while (srcStart < srcEnd) {
+    const char = load<u16>(srcStart);
+    if (char == QUOTE) {
+      writeStringToField(dstFieldPtr, payloadStart, <u32>(srcStart - payloadStart));
+      return srcStart + 2;
+    }
+    if (char == BACK_SLASH) {
+      bs.offset = bs.buffer;
+      bs.ensureSize(<u32>(srcEnd - payloadStart));
+      const prefixLen = <u32>(srcStart - payloadStart);
+      if (prefixLen != 0) {
+        memory.copy(bs.buffer, payloadStart, prefixLen);
+        bs.offset += prefixLen;
+      }
+
+      const code = load<u16>(srcStart, 2);
+      let lastPtr: usize;
+      if (code !== 0x75) {
+        store<u16>(bs.offset, load<u16>(DESERIALIZE_ESCAPE_TABLE + code));
+        bs.offset += 2;
+        lastPtr = srcStart + 4;
+      } else {
+        store<u16>(bs.offset, hex4_to_u16_swar(load<u64>(srcStart, 4)));
+        bs.offset += 2;
+        lastPtr = srcStart + 12;
+      }
+      return inline.always(deserializeEscapedStringContinuation_SWAR_MergedTuned(lastPtr, lastPtr, srcEnd, dstFieldPtr));
+    }
+    srcStart += 2;
+  }
+
+  return srcStart;
+}
+
 export function deserializeStringField_SWAR<T extends string | null>(srcStart: usize, srcEnd: usize, dstFieldPtr: usize): usize {
   if (srcStart + 2 > srcEnd || load<u16>(srcStart) != QUOTE) abort("Expected leading quote");
 
   const payloadStart = srcStart + 2;
-  const srcEnd8 = srcEnd >= 8 ? srcEnd - 8 : 0;
+  const srcEnd8 = srcEnd - 8;
   srcStart = payloadStart;
 
   while (srcStart <= srcEnd8) {
@@ -733,8 +608,7 @@ export function deserializeStringField_SWAR<T extends string | null>(srcStart: u
         return srcIdx + 2;
       }
       if (char != BACK_SLASH) continue;
-
-      return deserializeEscapedStringScan_SWAR(payloadStart, srcIdx, srcEnd, dstFieldPtr);
+      return inline.always(deserializeEscapedStringScan_SWAR_SplitTuned(payloadStart, srcIdx, srcEnd, dstFieldPtr));
     } while (mask !== 0);
 
     srcStart += 8;
@@ -747,7 +621,7 @@ export function deserializeStringField_SWAR<T extends string | null>(srcStart: u
       return srcStart + 2;
     }
     if (char == BACK_SLASH) {
-      return deserializeEscapedStringScan_SWAR(payloadStart, srcStart, srcEnd, dstFieldPtr);
+      return inline.always(deserializeEscapedStringScan_SWAR_SplitTuned(payloadStart, srcStart, srcEnd, dstFieldPtr));
     }
     srcStart += 2;
   }
@@ -756,6 +630,7 @@ export function deserializeStringField_SWAR<T extends string | null>(srcStart: u
   return srcStart;
 }
 
+
 /**
  * Computes a per-byte mask identifying ASCII backslash or quote bytes.
  *