json-as 1.3.6 → 1.3.8

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

@@ -1,53 +1,25 @@
-import { deserializeIntegerField } from "../../simple/integer";
-import { deserializeUnsignedField } from "../../simple/unsigned";
+import { deserializeIntegerArray_NAIVE } from "../../naive/array/integer";
 import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
 import { isSpace } from "../../../util";
 import { ensureArrayElementSlot, ensureArrayField } from "./shared";
-
-const ASCII_LANE_MASK_4: u64 = 0x00ff00ff00ff00ff;
-const ASCII_ZERO_4: u64 = 0x0030003000300030;
-const ASCII_RANGE_MASK_4: u64 = 0xfff0fff0fff0fff0;
-const ASCII_RANGE_ADD_4: u64 = 0x0006000600060006;
-
-
-@inline function pushSignedInteger<T extends number[]>(out: T, value: i64): void {
-  if (sizeof<valueof<T>>() == sizeof<i8>()) {
-    out.push(<valueof<T>>(<i8>value));
-  } else if (sizeof<valueof<T>>() == sizeof<i16>()) {
-    out.push(<valueof<T>>(<i16>value));
-  } else if (sizeof<valueof<T>>() == sizeof<i32>()) {
-    out.push(<valueof<T>>(<i32>value));
-  } else if (sizeof<valueof<T>>() == sizeof<isize>()) {
-    out.push(<valueof<T>>(<isize>value));
-  } else {
-    out.push(<valueof<T>>value);
-  }
-}
-
-
-@inline function pushUnsignedInteger<T extends number[]>(out: T, value: u64): void {
-  if (sizeof<valueof<T>>() == sizeof<u8>()) {
-    out.push(<valueof<T>>(<u8>value));
-  } else if (sizeof<valueof<T>>() == sizeof<u16>()) {
-    out.push(<valueof<T>>(<u16>value));
-  } else if (sizeof<valueof<T>>() == sizeof<u32>()) {
-    out.push(<valueof<T>>(<u32>value));
-  } else if (sizeof<valueof<T>>() == sizeof<usize>()) {
-    out.push(<valueof<T>>(<usize>value));
-  } else {
-    out.push(<valueof<T>>value);
-  }
-}
-
-
-@inline function storeSignedInteger<T extends number[]>(slot: usize, value: i64): void {
-  if (sizeof<valueof<T>>() == sizeof<i8>()) {
+import { parse4Digits_PairMul } from "../../../util/swar-int";
+
+// Store helpers parameterised on the element type `E` directly, so they
+// serve both `Array<E>` and `TypedArray<E>` callers. The integer-array
+// callers below all pass `valueof<T>` and AS folds the resulting tower of
+// `sizeof<E>` comparisons at compile time — same codegen as the prior
+// `T extends number[]` version, but reusable from `swar/typedarray.ts`.
+@inline function storeSignedIntegerE<E extends number>(
+  slot: usize,
+  value: i64,
+): void {
+  if (sizeof<E>() == sizeof<i8>()) {
     store<i8>(slot, <i8>value);
-  } else if (sizeof<valueof<T>>() == sizeof<i16>()) {
+  } else if (sizeof<E>() == sizeof<i16>()) {
     store<i16>(slot, <i16>value);
-  } else if (sizeof<valueof<T>>() == sizeof<i32>()) {
+  } else if (sizeof<E>() == sizeof<i32>()) {
     store<i32>(slot, <i32>value);
-  } else if (sizeof<valueof<T>>() == sizeof<isize>()) {
+  } else if (sizeof<E>() == sizeof<isize>()) {
     store<isize>(slot, <isize>value);
   } else {
     store<i64>(slot, value);
@@ -55,30 +27,37 @@ const ASCII_RANGE_ADD_4: u64 = 0x0006000600060006;
 }
 
 
-@inline function storeUnsignedInteger<T extends number[]>(slot: usize, value: u64): void {
-  if (sizeof<valueof<T>>() == sizeof<u8>()) {
+@inline function storeUnsignedIntegerE<E extends number>(
+  slot: usize,
+  value: u64,
+): void {
+  if (sizeof<E>() == sizeof<u8>()) {
     store<u8>(slot, <u8>value);
-  } else if (sizeof<valueof<T>>() == sizeof<u16>()) {
+  } else if (sizeof<E>() == sizeof<u16>()) {
     store<u16>(slot, <u16>value);
-  } else if (sizeof<valueof<T>>() == sizeof<u32>()) {
+  } else if (sizeof<E>() == sizeof<u32>()) {
     store<u32>(slot, <u32>value);
-  } else if (sizeof<valueof<T>>() == sizeof<usize>()) {
+  } else if (sizeof<E>() == sizeof<usize>()) {
     store<usize>(slot, <usize>value);
   } else {
     store<u64>(slot, value);
   }
 }
 
-
-@inline function parse4DigitsASCII(block: u64): u32 {
-  const digits = (block & ASCII_LANE_MASK_4) - ASCII_ZERO_4;
-  if (((digits | (digits + ASCII_RANGE_ADD_4)) & ASCII_RANGE_MASK_4) != 0) return U32.MAX_VALUE;
-
-  return <u32>(<u32>(digits & 0xffff) * 1000 + <u32>((digits >> 16) & 0xffff) * 100 + <u32>((digits >> 32) & 0xffff) * 10 + <u32>(digits >> 48));
-}
-
-
-@inline function parseSignedIntegerScalar<T extends number[]>(srcStart: usize, srcEnd: usize, out: T): usize {
+// The four parse helpers below take a `slot` pointer (`writePtr`) and store
+// the value directly via `store<valueof<T>>(slot, ...)`. The outer dispatcher
+// owns the array's `out.length = maxElements` pre-allocation and the
+// `writePtr` advance, so the per-element `Array.push` capacity check and
+// length write are eliminated for every integer width, not just the u8/i8
+// narrow-lane path.
+// Parsers are also E-parameterised so they're shareable with
+// `swar/typedarray.ts`. The body is byte-identical to the prior version
+// modulo s/valueof<T>/E/.
+@inline export function parseSignedIntegerScalar<E extends number>(
+  srcStart: usize,
+  srcEnd: usize,
+  slot: usize,
+): usize {
   let negative = false;
   let code = load<u16>(srcStart);
   if (code == 45) {
@@ -100,12 +79,16 @@ const ASCII_RANGE_ADD_4: u64 = 0x0006000600060006;
     srcStart += 2;
   }
 
-  pushSignedInteger<T>(out, negative ? -(<i64>value) : <i64>value);
+  storeSignedIntegerE<E>(slot, negative ? -(<i64>value) : <i64>value);
   return srcStart;
 }
 
 
-@inline function parseUnsignedIntegerScalar<T extends number[]>(srcStart: usize, srcEnd: usize, out: T): usize {
+@inline export function parseUnsignedIntegerScalar<E extends number>(
+  srcStart: usize,
+  srcEnd: usize,
+  slot: usize,
+): usize {
   let digit = <u32>load<u16>(srcStart) - 48;
   if (digit > 9) return 0;
 
@@ -118,12 +101,16 @@ const ASCII_RANGE_ADD_4: u64 = 0x0006000600060006;
     srcStart += 2;
   }
 
-  pushUnsignedInteger<T>(out, value);
+  storeUnsignedIntegerE<E>(slot, value);
   return srcStart;
 }
 
 
-@inline function parseSignedIntegerSWAR<T extends number[]>(srcStart: usize, srcEnd: usize, out: T): usize {
+@inline export function parseSignedIntegerSWAR<E extends number>(
+  srcStart: usize,
+  srcEnd: usize,
+  slot: usize,
+): usize {
   let negative = false;
   let code = load<u16>(srcStart);
   if (code == 45) {
@@ -139,11 +126,21 @@ const ASCII_RANGE_ADD_4: u64 = 0x0006000600060006;
   let value: u64 = digit;
   srcStart += 2;
 
-  while (srcStart + 6 < srcEnd) {
-    const parsed = parse4DigitsASCII(load<u64>(srcStart));
-    if (parsed == U32.MAX_VALUE) break;
-    value = value * 10000 + parsed;
-    srcStart += 8;
+  // Signed scan uses parse4 + scalar only (matches the asymmetric tuning in
+  // swar/integer.ts:deserializeIntegerField_SWAR). The leading minus shifts
+  // the digit run into parse8's "terminator-in-load" zone where validate-fail
+  // is common, so parse4's smaller failure unit wins.
+  //
+  // i8 tops out at 3 digits (-128..127), so the 4-digit kernel can never fire
+  // and the failing load + range check just burns cycles. Gate on the lane
+  // width so AS folds the loop away at compile time.
+  if (sizeof<E>() > 1) {
+    while (srcStart + 6 < srcEnd) {
+      const parsed = parse4Digits_PairMul(load<u64>(srcStart));
+      if (parsed == U32.MAX_VALUE) break;
+      value = value * 10000 + parsed;
+      srcStart += 8;
+    }
   }
 
   while (srcStart < srcEnd) {
@@ -153,20 +150,54 @@ const ASCII_RANGE_ADD_4: u64 = 0x0006000600060006;
     srcStart += 2;
   }
 
-  pushSignedInteger<T>(out, negative ? -(<i64>value) : <i64>value);
+  storeSignedIntegerE<E>(slot, negative ? -(<i64>value) : <i64>value);
   return srcStart;
 }
 
 
-@inline function parseUnsignedIntegerSWAR<T extends number[]>(srcStart: usize, srcEnd: usize, out: T): usize {
+@inline export function parseUnsignedIntegerSWAR<E extends number>(
+  srcStart: usize,
+  srcEnd: usize,
+  slot: usize,
+): usize {
+  // Narrow-type path mirrors the NAIVE structure: a tight scan loop to find
+  // the element terminator, then a fixed-count fold with no per-digit break.
+  // TurboFan tends to schedule this better than a single combined
+  // scan-and-fold loop because the fold has no data-dependent exit.
+  if (sizeof<E>() <= 2) {
+    const first = <u32>load<u16>(srcStart) - 48;
+    if (first > 9) return 0;
+    const lastIndex = srcStart;
+    srcStart += 2;
+    while (srcStart < srcEnd) {
+      const c = <u32>load<u16>(srcStart) - 48;
+      if (c > 9) break;
+      srcStart += 2;
+    }
+    let value: u64 = 0;
+    let p = lastIndex;
+    while (p < srcStart) {
+      value = value * 10 + (<u32>load<u16>(p) - 48);
+      p += 2;
+    }
+    storeUnsignedIntegerE<E>(slot, value);
+    return srcStart;
+  }
+
   let digit = <u32>load<u16>(srcStart) - 48;
   if (digit > 9) return 0;
 
   let value: u64 = digit;
   srcStart += 2;
 
+  // Array unsigned path uses parse4 + scalar (not parse8 + scalar as in the
+  // struct-field path swar/integer.ts:deserializeUnsignedField_SWAR). The
+  // bench corpus for arrays mixes element widths (e.g. 1/4/7/10 digits in
+  // u32-64mib), so most parse8 strides hit the `,` separator mid-load and
+  // pay the load+validate cost for a guaranteed miss. parse4 has a smaller
+  // failure unit and matches the typical 1-4 digit run between separators.
   while (srcStart + 6 < srcEnd) {
-    const parsed = parse4DigitsASCII(load<u64>(srcStart));
+    const parsed = parse4Digits_PairMul(load<u64>(srcStart));
     if (parsed == U32.MAX_VALUE) break;
     value = value * 10000 + parsed;
     srcStart += 8;
@@ -179,12 +210,15 @@ const ASCII_RANGE_ADD_4: u64 = 0x0006000600060006;
     srcStart += 2;
   }
 
-  pushUnsignedInteger<T>(out, value);
+  storeUnsignedIntegerE<E>(slot, value);
   return srcStart;
 }
 
 
-@inline function skipIntegerArrayWhitespace(srcStart: usize, srcEnd: usize): usize {
+@inline function skipIntegerArrayWhitespace(
+  srcStart: usize,
+  srcEnd: usize,
+): usize {
   while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) {
     srcStart += 2;
   }
@@ -192,12 +226,17 @@ const ASCII_RANGE_ADD_4: u64 = 0x0006000600060006;
 }
 
 // @ts-ignore: Decorator valid here
-export function deserializeIntegerArray_SLOW<T extends number[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
-  const out = changetype<nonnull<T>>(dst || changetype<usize>(instantiate<T>()));
+export function deserializeIntegerArray_SLOW<T extends number[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): T {
+  const out = changetype<nonnull<T>>(
+    dst || changetype<usize>(instantiate<T>()),
+  );
   let index = 0;
 
   out.length = 0;
-  srcStart = skipIntegerArrayWhitespace(srcStart, srcEnd);
   if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) {
     throw new Error("Failed to parse JSON!");
   }
@@ -231,7 +270,10 @@ export function deserializeIntegerArray_SLOW<T extends number[]>(srcStart: usize
         srcStart += 2;
       }
 
-      storeSignedInteger<T>(ensureArrayElementSlot<T>(out, index), negative ? -(<i64>value) : <i64>value);
+      storeSignedIntegerE<valueof<T>>(
+        ensureArrayElementSlot<T>(out, index),
+        negative ? -(<i64>value) : <i64>value,
+      );
     } else {
       let digit = <u32>code - 48;
       if (digit > 9) break;
@@ -245,7 +287,10 @@ export function deserializeIntegerArray_SLOW<T extends number[]>(srcStart: usize
         srcStart += 2;
       }
 
-      storeUnsignedInteger<T>(ensureArrayElementSlot<T>(out, index), value);
+      storeUnsignedIntegerE<valueof<T>>(
+        ensureArrayElementSlot<T>(out, index),
+        value,
+      );
     }
 
     index++;
@@ -265,8 +310,15 @@ export function deserializeIntegerArray_SLOW<T extends number[]>(srcStart: usize
 }
 
 
-@inline function deserializeIntegerArrayImpl<T extends number[]>(srcStart: usize, srcEnd: usize, dst: usize, useSWAR: bool): T {
-  const out = changetype<nonnull<T>>(dst || changetype<usize>(instantiate<T>()));
+@inline function deserializeIntegerArrayImpl<T extends number[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+  useSWAR: bool,
+): T {
+  const out = changetype<nonnull<T>>(
+    dst || changetype<usize>(instantiate<T>()),
+  );
   const originalSrcStart = srcStart;
   const reusableLength = out.length;
 
@@ -300,11 +352,13 @@ export function deserializeIntegerArray_SLOW<T extends number[]>(srcStart: usize
           let value: u64 = digit;
           srcStart += 2;
 
-          while (srcStart + 6 < srcEnd) {
-            const parsed = parse4DigitsASCII(load<u64>(srcStart));
-            if (parsed == U32.MAX_VALUE) break;
-            value = value * 10000 + parsed;
-            srcStart += 8;
+          if (sizeof<valueof<T>>() > 1) {
+            while (srcStart + 6 < srcEnd) {
+              const parsed = parse4Digits_PairMul(load<u64>(srcStart));
+              if (parsed == U32.MAX_VALUE) break;
+              value = value * 10000 + parsed;
+              srcStart += 8;
+            }
           }
 
           while (srcStart < srcEnd) {
@@ -315,7 +369,10 @@ export function deserializeIntegerArray_SLOW<T extends number[]>(srcStart: usize
           }
 
           if (index >= reusableLength) break;
-          storeSignedInteger<T>(dataStart + <usize>index * sizeof<valueof<T>>(), negative ? -(<i64>value) : <i64>value);
+          storeSignedIntegerE<valueof<T>>(
+            dataStart + <usize>index * sizeof<valueof<T>>(),
+            negative ? -(<i64>value) : <i64>value,
+          );
           index++;
           if (srcStart >= srcEnd) break;
 
@@ -338,11 +395,13 @@ export function deserializeIntegerArray_SLOW<T extends number[]>(srcStart: usize
           let value: u64 = digit;
           srcStart += 2;
 
-          while (srcStart + 6 < srcEnd) {
-            const parsed = parse4DigitsASCII(load<u64>(srcStart));
-            if (parsed == U32.MAX_VALUE) break;
-            value = value * 10000 + parsed;
-            srcStart += 8;
+          if (sizeof<valueof<T>>() > 1) {
+            while (srcStart + 6 < srcEnd) {
+              const parsed = parse4Digits_PairMul(load<u64>(srcStart));
+              if (parsed == U32.MAX_VALUE) break;
+              value = value * 10000 + parsed;
+              srcStart += 8;
+            }
           }
 
           while (srcStart < srcEnd) {
@@ -353,7 +412,10 @@ export function deserializeIntegerArray_SLOW<T extends number[]>(srcStart: usize
           }
 
           if (index >= reusableLength) break;
-          storeUnsignedInteger<T>(dataStart + <usize>index * sizeof<valueof<T>>(), value);
+          storeUnsignedIntegerE<valueof<T>>(
+            dataStart + <usize>index * sizeof<valueof<T>>(),
+            value,
+          );
           index++;
           if (srcStart >= srcEnd) break;
 
@@ -374,63 +436,226 @@ export function deserializeIntegerArray_SLOW<T extends number[]>(srcStart: usize
     srcStart = originalSrcStart;
   }
 
-  out.length = 0;
+  // Worst-case sizing: every element is at least 1 digit + 1 delimiter = 2
+  // UTF-16 chars = 4 bytes. AS skips zero-fill on `length=` for unmanaged
+  // primitive types (every concrete `valueof<T>` here is an integer), so the
+  // over-allocation costs only a small amount of trimmed storage at the end.
+  // The parse helpers below store through `writePtr` directly, eliminating
+  // `Array.push`'s per-element capacity check + length write for every
+  // integer width.
+  const elementSize = sizeof<valueof<T>>();
+  const maxElements = i32((<usize>(srcEnd - srcStart)) >> 2);
+  if (maxElements > 0) out.length = maxElements;
+  const dataStart = out.dataStart;
+  let writePtr = dataStart;
 
   do {
     if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) break;
     srcStart += 2;
     if (srcStart >= srcEnd) break;
-    if (load<u16>(srcStart) == BRACKET_RIGHT) return out;
+    if (load<u16>(srcStart) == BRACKET_RIGHT) {
+      out.length = 0;
+      return out;
+    }
 
     if (isSigned<valueof<T>>()) {
       while (srcStart < srcEnd) {
-        srcStart = useSWAR ? parseSignedIntegerSWAR<T>(srcStart, srcEnd, out) : parseSignedIntegerScalar<T>(srcStart, srcEnd, out);
-        if (!srcStart || srcStart >= srcEnd) break;
+        const next = useSWAR
+          ? parseSignedIntegerSWAR<valueof<T>>(srcStart, srcEnd, writePtr)
+          : parseSignedIntegerScalar<valueof<T>>(srcStart, srcEnd, writePtr);
+        if (!next) break;
+        writePtr += elementSize;
+        srcStart = next;
+        if (srcStart >= srcEnd) break;
 
         const code = load<u16>(srcStart);
         if (code == COMMA) {
           srcStart += 2;
           continue;
         }
-        if (code == BRACKET_RIGHT) return out;
+        if (code == BRACKET_RIGHT) {
+          out.length = i32(<usize>(writePtr - dataStart) / elementSize);
+          return out;
+        }
         break;
       }
     } else {
       while (srcStart < srcEnd) {
-        srcStart = useSWAR ? parseUnsignedIntegerSWAR<T>(srcStart, srcEnd, out) : parseUnsignedIntegerScalar<T>(srcStart, srcEnd, out);
-        if (!srcStart || srcStart >= srcEnd) break;
+        const next = useSWAR
+          ? parseUnsignedIntegerSWAR<valueof<T>>(srcStart, srcEnd, writePtr)
+          : parseUnsignedIntegerScalar<valueof<T>>(srcStart, srcEnd, writePtr);
+        if (!next) break;
+        writePtr += elementSize;
+        srcStart = next;
+        if (srcStart >= srcEnd) break;
 
         const code = load<u16>(srcStart);
         if (code == COMMA) {
           srcStart += 2;
           continue;
         }
-        if (code == BRACKET_RIGHT) return out;
+        if (code == BRACKET_RIGHT) {
+          out.length = i32(<usize>(writePtr - dataStart) / elementSize);
+          return out;
+        }
         break;
       }
     }
   } while (false);
 
-  return deserializeIntegerArray_SLOW<T>(originalSrcStart, srcEnd, changetype<usize>(out));
+  // Fast path bailed (whitespace, malformed numbers, etc). Hand off to the
+  // SLOW path which resets `out.length` to 0 and re-parses from the original
+  // input. The pre-allocated buffer is retained, so SLOW's per-element
+  // `ensureArrayElementSlot` grows-or-reuses through the existing capacity.
+  return deserializeIntegerArray_SLOW<T>(
+    originalSrcStart,
+    srcEnd,
+    changetype<usize>(out),
+  );
 }
 
 // @ts-ignore: Decorator valid here
-export function deserializeIntegerArray<T extends number[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
-  return deserializeIntegerArrayImpl<T>(srcStart, srcEnd, dst, false);
+export function deserializeIntegerArray_SWAR<T extends number[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): T {
+  // u8/i8 elements use a dedicated two-pass SWAR path: a 4-char-stride
+  // comma counter pre-sizes the array so the parse pass can drop the
+  // per-push capacity check and write through a direct pointer. The
+  // wider-lane SWAR kernel never amortizes itself for narrow elements
+  // (u8 max 3 digits) so we skip it entirely here.
+  if (sizeof<valueof<T>>() <= 1) {
+    return deserializeNarrowIntegerArray_SWAR<T>(srcStart, srcEnd, dst);
+  }
+  return deserializeIntegerArrayImpl<T>(srcStart, srcEnd, dst, true);
 }
 
-// @ts-ignore: Decorator valid here
-export function deserializeIntegerArray_SWAR<T extends number[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
-  return deserializeIntegerArrayImpl<T>(srcStart, srcEnd, dst, true);
+/**
+ * Narrow-lane (u8/i8) integer-array deserializer.
+ *
+ * Two passes:
+ *   1) SWAR comma counter (4 chars per stride, popcnt over the lane mask)
+ *      sizes the array exactly so the parse pass can use unchecked stores.
+ *   2) Walks the input NAIVE-style (skip non-digits, scan to separator,
+ *      fold digits) but writes through a direct pointer, eliminating
+ *      `Array.push`'s per-element capacity check and length write.
+ *
+ * V8 already auto-SIMDs NAIVE's scalar scan loop tighter than a hand-rolled
+ * SWAR scan in pass 2, so we keep that pattern there and only pay SWAR cost
+ * on the pre-count - which is a tight load-mask-popcnt loop where V8's
+ * scalar code can't compete with the explicit 4-lane stride.
+ */
+function deserializeNarrowIntegerArray_SWAR<T extends number[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): T {
+  const out = changetype<nonnull<T>>(
+    dst || changetype<usize>(instantiate<T>()),
+  );
+
+  // Worst-case sizing: every element is at least 1 digit + 1 delimiter = 2
+  // UTF-16 chars = 4 bytes, so the body inside `[...]` can't hold more than
+  // `(srcEnd - srcStart) / 4` elements. AS skips zero-fill on `length=` for
+  // unmanaged element types, so over-allocation is essentially free here
+  // and saves a full SWAR pass over the input.
+  const maxElements = i32((<usize>(srcEnd - srcStart)) >> 2);
+  if (maxElements > 0) out.length = maxElements;
+  const dataStart = out.dataStart;
+  const elementSize = sizeof<valueof<T>>();
+  let writePtr = dataStart;
+
+  while (srcStart < srcEnd) {
+    // Fast paths: 1-, 2-, or 3-digit unsigned element followed by `,` packs
+    // into one u64 load (covers ~100% of the typical 0..255 cycle). Ordered
+    // 3 -> 2 -> 1 because 3-digit values dominate any wide-range payload;
+    // the 2- and 1-digit branches cover the rest of `out`.
+    if (!isSigned<valueof<T>>() && srcStart + 6 < srcEnd) {
+      const block = load<u64>(srcStart);
+      if (((block >> 48) & 0xffff) == COMMA) {
+        const digits = (block & 0x0000_00ff_00ff_00ff) - 0x0000_0030_0030_0030;
+        const oor =
+          (digits | (digits + 0x0000_0006_0006_0006)) & 0x0000_fff0_fff0_fff0;
+        if (oor == 0) {
+          const d0 = <u32>(digits & 0xffff);
+          const d1 = <u32>((digits >> 16) & 0xffff);
+          const d2 = <u32>((digits >> 32) & 0xffff);
+          store<valueof<T>>(writePtr, <valueof<T>>(d0 * 100 + d1 * 10 + d2));
+          writePtr += elementSize;
+          srcStart += 8;
+          continue;
+        }
+      } else if (((block >> 32) & 0xffff) == COMMA) {
+        const digits = (block & 0x0000_0000_00ff_00ff) - 0x0000_0000_0030_0030;
+        const oor =
+          (digits | (digits + 0x0000_0000_0006_0006)) & 0x0000_0000_fff0_fff0;
+        if (oor == 0) {
+          const d0 = <u32>(digits & 0xffff);
+          const d1 = <u32>((digits >> 16) & 0xffff);
+          store<valueof<T>>(writePtr, <valueof<T>>(d0 * 10 + d1));
+          writePtr += elementSize;
+          srcStart += 6;
+          continue;
+        }
+      } else if (((block >> 16) & 0xffff) == COMMA) {
+        const d0 = <u32>(block & 0xffff) - 48;
+        if (d0 <= 9) {
+          store<valueof<T>>(writePtr, <valueof<T>>d0);
+          writePtr += elementSize;
+          srcStart += 4;
+          continue;
+        }
+      }
+    }
+    const code = load<u16>(srcStart);
+    if (<u32>code - 48 <= 9 || (isSigned<valueof<T>>() && code == 45)) {
+      const lastIndex = srcStart;
+      srcStart += 2;
+      while (srcStart < srcEnd) {
+        const c = load<u16>(srcStart);
+        if (c == COMMA || c == BRACKET_RIGHT || isSpace(c)) {
+          let value: u64 = 0;
+          let p = lastIndex;
+          if (isSigned<valueof<T>>() && load<u16>(p) == 45) {
+            p += 2;
+            while (p < srcStart) {
+              value = value * 10 + (<u32>load<u16>(p) - 48);
+              p += 2;
+            }
+            store<valueof<T>>(writePtr, <valueof<T>>-(<i64>value));
+          } else {
+            while (p < srcStart) {
+              value = value * 10 + (<u32>load<u16>(p) - 48);
+              p += 2;
+            }
+            store<valueof<T>>(writePtr, <valueof<T>>value);
+          }
+          writePtr += elementSize;
+          break;
+        }
+        srcStart += 2;
+      }
+    }
+    srcStart += 2;
+  }
+
+  out.length = i32(<usize>(writePtr - dataStart) / elementSize);
+  return out;
 }
 
 
-@inline export function deserializeIntegerArrayInto<T extends number[]>(srcStart: usize, srcEnd: usize, out: T): usize {
+@inline function deserializeIntegerArrayBody<T extends number[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  out: T,
+): usize {
   let index = 0;
 
   do {
     if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) break;
     srcStart += 2;
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
     if (srcStart >= srcEnd) break;
     if (load<u16>(srcStart) == BRACKET_RIGHT) {
       out.length = 0;
@@ -439,17 +664,35 @@ export function deserializeIntegerArray_SWAR<T extends number[]>(srcStart: usize
 
     while (srcStart < srcEnd) {
       const slot = ensureArrayElementSlot<T>(out, index);
-      srcStart = isSigned<valueof<T>>() ? deserializeIntegerField<valueof<T>>(srcStart, srcEnd, slot) : deserializeUnsignedField<valueof<T>>(srcStart, srcEnd, slot);
-      if (!srcStart || srcStart >= srcEnd) break;
+      // Inline the array-optimized SWAR parser directly. The top-level
+      // (`deserializeIntegerArrayImpl`) and the typed-array path
+      // (`swar/typedarray.ts`) already call these — having the field path
+      // call them too means the per-element parser is identical across all
+      // three call sites (parse4 + scalar fold for both signed and
+      // unsigned, narrow-lane special case for i8/u8/i16/u16).
+      //
+      // Why not `deserializeUnsignedField_SWAR` (which uses parse8 + scalar)?
+      // That tuning targets the struct-single-field path where the digit
+      // run is one aligned token. In an array, mixed element widths cause
+      // parse8 to fail-and-retry at element boundaries — see u32-64mib's
+      // 23% regression when parse8 was tried in the array path.
+      srcStart = isSigned<valueof<T>>()
+        ? parseSignedIntegerSWAR<valueof<T>>(srcStart, srcEnd, slot)
+        : parseUnsignedIntegerSWAR<valueof<T>>(srcStart, srcEnd, slot);
+      if (!srcStart) break;
+      while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+      if (srcStart >= srcEnd) break;
 
       const code = load<u16>(srcStart);
       if (code == COMMA) {
         srcStart += 2;
+        while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
         index++;
         continue;
       }
       if (code == BRACKET_RIGHT) {
-        out.length = index + 1;
+        const nextLen = index + 1;
+        if (out.length != nextLen) out.length = nextLen;
         return srcStart + 2;
       }
       break;
@@ -460,6 +703,14 @@ export function deserializeIntegerArray_SWAR<T extends number[]>(srcStart: usize
 }
 
 
-@inline export function deserializeIntegerArrayField<T extends number[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
-  return deserializeIntegerArrayInto<T>(srcStart, srcEnd, ensureArrayField<T>(fieldPtr));
+@inline export function deserializeIntegerArrayField<T extends number[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  fieldPtr: usize,
+): usize {
+  return deserializeIntegerArrayBody<T>(
+    srcStart,
+    srcEnd,
+    ensureArrayField<T>(fieldPtr),
+  );
 }