json-as 1.3.7 → 1.3.8

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

@@ -0,0 +1,69 @@
+import { JSON } from "../../..";
+import {
+  COMMA,
+  BRACKET_LEFT,
+  BRACKET_RIGHT,
+  NULL_WORD_U64,
+  QUOTE,
+} from "../../../custom/chars";
+import { isSpace, scanStringEnd } from "../../../util";
+
+/**
+ * Strict string-array deserializer (`string[]` / `(string | null)[]`).
+ *
+ * Enforces RFC 8259 array structure: `[`-framed, single-comma separated, no
+ * leading / trailing / doubled commas, and each element must be a quoted string
+ * (or the literal `null` for a nullable element type). Element contents are
+ * validated by `deserializeString_NAIVE` (via `JSON.__deserialize`). Throws on
+ * any deviation.
+ */
+export function deserializeStringArray_NAIVE(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): string[] {
+  const out = changetype<string[]>(
+    dst || changetype<usize>(instantiate<string[]>()),
+  );
+  out.length = 0; // dst may arrive pre-sized; re-parse from empty via push
+
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
+  if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT)
+    throw new Error("Invalid JSON array: expected '['");
+  if (load<u16>(srcEnd - 2) != BRACKET_RIGHT)
+    throw new Error("Invalid JSON array: expected ']'");
+  srcStart += 2; // past '['
+  srcEnd -= 2; // before ']'
+
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  if (srcStart >= srcEnd) return out;
+
+  while (true) {
+    const code = load<u16>(srcStart);
+    if (code == QUOTE) {
+      const closing = scanStringEnd(srcStart, srcEnd);
+      if (closing >= srcEnd)
+        throw new Error("Invalid JSON array: unterminated string");
+      out.push(JSON.__deserialize<string>(srcStart, closing + 2));
+      srcStart = closing + 2;
+    } else if (srcStart + 8 <= srcEnd && load<u64>(srcStart) == NULL_WORD_U64) {
+      // `(string | null)[]` element
+      out.push(changetype<string>(0));
+      srcStart += 8;
+    } else {
+      throw new Error("Invalid JSON array: expected string");
+    }
+
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+    if (srcStart >= srcEnd) break;
+    if (load<u16>(srcStart) != COMMA)
+      throw new Error("Invalid JSON array: expected ',' or ']'");
+    srcStart += 2;
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+    if (srcStart >= srcEnd)
+      throw new Error("Invalid JSON array: trailing comma");
+  }
+
+  return out;
+}

package/assembly/deserialize/{simple → naive}/array/struct.ts

@@ -18,7 +18,6 @@ export function deserializeStructArray<T extends unknown[]>(
   let lastIndex: usize = 0;
   let depth: u32 = 0;
 
-  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
 
   if (srcStart - srcEnd == 0)

package/assembly/deserialize/{simple → naive}/array.ts

@@ -2,20 +2,15 @@ import { JSON } from "../..";
 import { deserializeArbitraryArray } from "./array/arbitrary";
 import { deserializeArrayArray } from "./array/array";
 import { deserializeBooleanArray } from "./array/bool";
-import { deserializeFloatArray } from "./array/float";
+import { deserializeFloatArray_NAIVE } from "./array/float";
 import { deserializeGenericArray } from "./array/generic";
-import { deserializeIntegerArray } from "./array/integer";
+import { deserializeIntegerArray_NAIVE } from "./array/integer";
 import { deserializeMapArray } from "./array/map";
 import { deserializeStructArray } from "./array/struct";
-import { deserializeStringArray } from "./array/string";
+import { deserializeStringArray_NAIVE } from "./array/string";
 import { deserializeObjectArray } from "./array/object";
 import { deserializeBoxArray } from "./array/box";
 import { deserializeRawArray } from "./array/raw";
-export {
-  deserializeArrayField,
-  deserializeArrayField as deserializeArrayField_SWAR,
-} from "../swar/array";
-
 // @ts-ignore: Decorator valid here
 export function deserializeArray<T extends unknown[]>(
   srcStart: usize,
@@ -23,16 +18,16 @@ export function deserializeArray<T extends unknown[]>(
   dst: usize,
 ): T {
   if (isString<valueof<T>>()) {
-    return <T>deserializeStringArray(srcStart, srcEnd, dst);
+    return <T>deserializeStringArray_NAIVE(srcStart, srcEnd, dst);
   } else if (isBoolean<valueof<T>>()) {
     // @ts-ignore
     return deserializeBooleanArray<T>(srcStart, srcEnd, dst);
   } else if (isInteger<valueof<T>>()) {
     // @ts-ignore
-    return deserializeIntegerArray<T>(srcStart, srcEnd, dst);
+    return deserializeIntegerArray_NAIVE<T>(srcStart, srcEnd, dst);
   } else if (isFloat<valueof<T>>()) {
     // @ts-ignore
-    return deserializeFloatArray<T>(srcStart, srcEnd, dst);
+    return deserializeFloatArray_NAIVE<T>(srcStart, srcEnd, dst);
   } else if (isArray<valueof<T>>()) {
     // @ts-ignore: type
     return deserializeArrayArray<T>(srcStart, srcEnd, dst);

package/assembly/deserialize/naive/float.ts

@@ -0,0 +1,135 @@
+import { ptrToStr } from "../../util/ptrToStr";
+import { isSpace } from "../../util";
+
+// Strict RFC 8259 number-grammar check over [srcStart, srcEnd) (surrounding
+// whitespace tolerated). Throws on any deviation: leading zeros, a bare `-`, a
+// fraction / exponent with no digits, a `+` sign, hex, Inf/NaN, or trailing
+// garbage. f64.parse alone is lenient (parses a numeric prefix and ignores the
+// rest), so this guard is what makes the naive value path reject malformed
+// numbers like `0e`, `-01`, `1.`, `2.e3`, `0x42`.
+// @ts-ignore: inline
+@inline function validateJSONNumber(srcStart: usize, srcEnd: usize): void {
+  let ptr = srcStart;
+  while (ptr < srcEnd && isSpace(load<u16>(ptr))) ptr += 2;
+  let end = srcEnd;
+  while (end > ptr && isSpace(load<u16>(end - 2))) end -= 2;
+  if (ptr >= end) throw new Error("Invalid JSON number: empty");
+
+  if (load<u16>(ptr) == 45) ptr += 2; // optional minus
+  if (ptr >= end) throw new Error("Invalid JSON number: bare '-'");
+
+  // Library extension (non-RFC, intentionally supported + tested): the literals
+  // NaN / Infinity / -Infinity. Hand these to f64.parse without strict checking.
+  const lead = load<u16>(ptr);
+  if (lead == 78 || lead == 110 || lead == 73 || lead == 105) return; // N n I i
+
+  // integer part: lone 0, or [1-9] digit*
+  const first = load<u16>(ptr);
+  if (first == 48) {
+    ptr += 2;
+    if (ptr < end && <u32>(load<u16>(ptr) - 48) <= 9)
+      throw new Error("Invalid JSON number: leading zero");
+  } else if (<u32>(first - 48) <= 9) {
+    ptr += 2;
+    while (ptr < end && <u32>(load<u16>(ptr) - 48) <= 9) ptr += 2;
+  } else {
+    throw new Error("Invalid JSON number: expected digit");
+  }
+
+  // optional fraction: '.' digit+
+  if (ptr < end && load<u16>(ptr) == 46) {
+    ptr += 2;
+    if (ptr >= end || <u32>(load<u16>(ptr) - 48) > 9)
+      throw new Error("Invalid JSON number: fraction needs a digit");
+    while (ptr < end && <u32>(load<u16>(ptr) - 48) <= 9) ptr += 2;
+  }
+
+  // optional exponent: ('e'|'E') ['+'|'-'] digit+
+  if (ptr < end) {
+    const e = load<u16>(ptr);
+    if (e == 101 || e == 69) {
+      ptr += 2;
+      if (ptr < end) {
+        const sign = load<u16>(ptr);
+        if (sign == 43 || sign == 45) ptr += 2;
+      }
+      if (ptr >= end || <u32>(load<u16>(ptr) - 48) > 9)
+        throw new Error("Invalid JSON number: exponent needs a digit");
+      while (ptr < end && <u32>(load<u16>(ptr) - 48) <= 9) ptr += 2;
+    }
+  }
+
+  if (ptr != end) throw new Error("Invalid JSON number: trailing characters");
+}
+
+// @ts-ignore: inline
+@inline export function deserializeFloat_NAIVE<T>(
+  srcStart: usize,
+  srcEnd: usize,
+): T {
+  validateJSONNumber(srcStart, srcEnd);
+  // @ts-ignore
+  const type: T = 0;
+  // @ts-ignore
+  if (type instanceof f64) return f64.parse(ptrToStr(srcStart, srcEnd));
+  // @ts-ignore
+  return f32.parse(ptrToStr(srcStart, srcEnd));
+}
+
+// @ts-ignore: inline
+@inline function scanFloatEnd(srcStart: usize, srcEnd: usize): usize {
+  let ptr = srcStart;
+  if (ptr < srcEnd && load<u16>(ptr) == 45) ptr += 2; // optional minus
+
+  while (ptr < srcEnd) {
+    const code = load<u16>(ptr);
+    if (<u32>code - 48 > 9) break;
+    ptr += 2;
+  }
+
+  if (ptr < srcEnd && load<u16>(ptr) == 46) {
+    ptr += 2;
+    while (ptr < srcEnd) {
+      const code = load<u16>(ptr);
+      if (<u32>code - 48 > 9) break;
+      ptr += 2;
+    }
+  }
+
+  if (ptr < srcEnd) {
+    const code = load<u16>(ptr);
+    if (code == 101 || code == 69) {
+      ptr += 2;
+      if (ptr < srcEnd) {
+        const sign = load<u16>(ptr);
+        if (sign == 45 || sign == 43) ptr += 2;
+      }
+      while (ptr < srcEnd) {
+        const code = load<u16>(ptr);
+        if (<u32>code - 48 > 9) break;
+        ptr += 2;
+      }
+    }
+  }
+
+  return ptr;
+}
+
+// @ts-ignore: inline
+@inline export function deserializeFloatField_NAIVE<T extends number>(
+  srcStart: usize,
+  srcEnd: usize,
+  dstObj: usize,
+  dstOffset: usize = 0,
+): usize {
+  const fieldPtr = dstObj + dstOffset;
+  const end = scanFloatEnd(srcStart, srcEnd);
+
+  if (sizeof<T>() == sizeof<f32>()) {
+    store<f32>(fieldPtr, f32.parse(ptrToStr(srcStart, end)));
+  } else {
+    store<f64>(fieldPtr, f64.parse(ptrToStr(srcStart, end)));
+  }
+
+  return end;
+}

package/assembly/deserialize/{simple → naive}/integer.ts

@@ -1,7 +1,7 @@
 import { atoi } from "../../util/atoi";
 
 // @ts-ignore: inline
-@inline export function deserializeInteger<T>(
+@inline export function deserializeInteger_NAIVE<T extends number>(
   srcStart: usize,
   srcEnd: usize,
 ): T {
@@ -9,7 +9,7 @@ import { atoi } from "../../util/atoi";
 }
 
 // @ts-ignore: inline
-@inline export function deserializeIntegerField<T extends number>(
+@inline export function deserializeIntegerField_NAIVE<T extends number>(
   srcStart: usize,
   srcEnd: usize,
   dstObj: usize,

package/assembly/deserialize/{simple → naive}/map.ts

@@ -13,7 +13,7 @@ import {
   COLON,
 } from "../../custom/chars";
 import { isSpace, isUnescapedQuote, scanStringEnd } from "../../util";
-import { scanValueEnd } from "../swar/array/shared";
+import { scanValueEnd } from "../../util/scanValueEnd";
 
 // @ts-ignore: Decorator is valid here
 @inline function deserializeMapKey<T>(start: usize, end: usize): T {
@@ -37,7 +37,6 @@ export function deserializeMap<T extends Map<any, any>>(
   let depth = 0;
   let lastIndex: usize = 0;
 
-  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2; // would like to optimize this later
 
   if (srcStart - srcEnd == 0)
@@ -231,7 +230,7 @@ export function deserializeMap<T extends Map<any, any>>(
 }
 
 
-@inline export function deserializeMapInto<T extends Map<any, any>>(
+@inline function deserializeMapBody<T extends Map<any, any>>(
   srcStart: usize,
   srcEnd: usize,
   out: T,
@@ -241,10 +240,12 @@ export function deserializeMap<T extends Map<any, any>>(
   if (srcStart >= srcEnd || load<u16>(srcStart) != BRACE_LEFT)
     throw new Error("Failed to parse JSON!");
   srcStart += 2;
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   if (srcStart >= srcEnd) throw new Error("Failed to parse JSON!");
   if (load<u16>(srcStart) == BRACE_RIGHT) return srcStart + 2;
 
   while (srcStart < srcEnd) {
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
     if (load<u16>(srcStart) != QUOTE) break;
 
     const keyStart = srcStart + 2;
@@ -252,8 +253,10 @@ export function deserializeMap<T extends Map<any, any>>(
     if (keyEnd >= srcEnd) break;
 
     srcStart = keyEnd + 2;
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
     if (srcStart >= srcEnd || load<u16>(srcStart) != COLON) break;
     srcStart += 2;
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
 
     const valueEnd = scanValueEnd(srcStart, srcEnd);
     if (!valueEnd || valueEnd <= srcStart) break;
@@ -265,10 +268,12 @@ export function deserializeMap<T extends Map<any, any>>(
     );
     srcStart = valueEnd;
 
+    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;
       continue;
     }
     if (code == BRACE_RIGHT) return srcStart + 2;
@@ -285,10 +290,11 @@ export function deserializeMap<T extends Map<any, any>>(
   dstObj: usize,
   dstOffset: usize = 0,
 ): usize {
-  let out = load<T>(dstObj, dstOffset);
+  const fieldPtr = dstObj + dstOffset;
+  let out = load<T>(fieldPtr);
   if (!changetype<usize>(out)) {
     out = changetype<T>(instantiate<T>());
-    store<T>(dstObj, out, dstOffset);
+    store<T>(fieldPtr, out);
   }
-  return deserializeMapInto<T>(srcStart, srcEnd, out);
+  return deserializeMapBody<T>(srcStart, srcEnd, out);
 }

package/assembly/deserialize/{simple → naive}/object.ts

@@ -15,12 +15,10 @@ import {
 } from "../../custom/chars";
 import { isSpace, isUnescapedQuote, scanStringEnd } from "../../util";
 import { ptrToStr } from "../../util/ptrToStr";
-import { deserializeString_SWAR } from "../swar/string";
-import { deserializeArbitrary } from "./arbitrary";
 import { deserializeArray } from "./array";
 import { deserializeBoolean } from "./bool";
-import { deserializeFloat } from "./float";
-import { deserializeString } from "./string";
+import { deserializeFloat_NAIVE } from "./float";
+import { deserializeString_NAIVE } from "./string";
 
 export function deserializeObject(
   srcStart: usize,
@@ -35,7 +33,6 @@ export function deserializeObject(
   let depth = 0;
   let lastIndex: usize = 0;
 
-  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2; // would like to optimize this later
 
   if (srcStart - srcEnd == 0)
@@ -84,7 +81,7 @@ export function deserializeObject(
           throw new Error("Unterminated string in JSON object");
         out.set(
           ptrToStr(keyStart, keyEnd),
-          deserializeString(lastIndex, srcStart + 2),
+          deserializeString_NAIVE(lastIndex, srcStart + 2),
         );
         srcStart += 2;
         keyStart = 0;
@@ -98,7 +95,7 @@ export function deserializeObject(
             // console.log("Value (number): " + ptrToStr(lastIndex, srcStart));
             out.set(
               ptrToStr(keyStart, keyEnd),
-              deserializeFloat<f64>(lastIndex, srcStart),
+              deserializeFloat_NAIVE<f64>(lastIndex, srcStart),
             );
             // while (isSpace(load<u16>((srcStart += 2)))) {
             //   /* empty */

package/assembly/deserialize/{simple → naive}/set.ts

@@ -54,20 +54,17 @@ function deserializeSetDirect<T extends Set<any>>(
   srcStart: usize,
   srcEnd: usize,
   out: nonnull<T>,
-  allowWhitespace: bool = false,
 ): usize {
   if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT)
     throw new Error("Expected '[' at start of set");
 
   srcStart += 2;
-  if (allowWhitespace)
-    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   if (srcStart >= srcEnd) throw new Error("Unterminated set");
   if (load<u16>(srcStart) == BRACKET_RIGHT) return srcStart + 2;
 
   while (srcStart < srcEnd) {
-    if (allowWhitespace)
-      while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
     const code = load<u16>(srcStart);
 
     // @ts-ignore: type
@@ -97,12 +94,7 @@ function deserializeSetDirect<T extends Set<any>>(
       let ptr = srcStart + 2;
       while (ptr < srcEnd) {
         const next = load<u16>(ptr);
-        if (
-          next == COMMA ||
-          next == BRACKET_RIGHT ||
-          (allowWhitespace && isSpace(next))
-        )
-          break;
+        if (next == COMMA || next == BRACKET_RIGHT || isSpace(next)) break;
         ptr += 2;
       }
       // @ts-ignore: type
@@ -114,12 +106,7 @@ function deserializeSetDirect<T extends Set<any>>(
       let ptr = srcStart + 2;
       while (ptr < srcEnd) {
         const next = load<u16>(ptr);
-        if (
-          next == COMMA ||
-          next == BRACKET_RIGHT ||
-          (allowWhitespace && isSpace(next))
-        )
-          break;
+        if (next == COMMA || next == BRACKET_RIGHT || isSpace(next)) break;
         ptr += 2;
       }
       // @ts-ignore: type
@@ -136,14 +123,12 @@ function deserializeSetDirect<T extends Set<any>>(
       break;
     }
 
-    if (allowWhitespace)
-      while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
     if (srcStart >= srcEnd) break;
     const next = load<u16>(srcStart);
     if (next == COMMA) {
       srcStart += 2;
-      if (allowWhitespace)
-        while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+      while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
       continue;
     }
     if (next == BRACKET_RIGHT) return srcStart + 2;
@@ -163,18 +148,17 @@ export function deserializeSet<T extends Set<any>>(
   );
   out.clear();
 
-  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
 
   if (srcStart >= srcEnd)
     throw new Error("Input string had zero length or was all whitespace");
-  const end = deserializeSetDirect<T>(srcStart, srcEnd, out, true);
+  const end = deserializeSetDirect<T>(srcStart, srcEnd, out);
   if (end != srcEnd) throw new Error("Expected ']' at end of set");
   return out;
 }
 
 // @ts-expect-error: Decorator valid here
-@inline export function deserializeSetInto<T extends Set<any>>(
+@inline function deserializeSetBody<T extends Set<any>>(
   srcStart: usize,
   srcEnd: usize,
   out: T,
@@ -190,10 +174,11 @@ export function deserializeSet<T extends Set<any>>(
   dstObj: usize,
   dstOffset: usize = 0,
 ): usize {
-  let out = load<T>(dstObj, dstOffset);
+  const fieldPtr = dstObj + dstOffset;
+  let out = load<T>(fieldPtr);
   if (!changetype<usize>(out)) {
     out = changetype<T>(instantiate<T>());
-    store<T>(dstObj, out, dstOffset);
+    store<T>(fieldPtr, out);
   }
-  return deserializeSetInto<T>(srcStart, srcEnd, out);
+  return deserializeSetBody<T>(srcStart, srcEnd, out);
 }

package/assembly/deserialize/{simple → naive}/staticarray/array.ts

@@ -19,7 +19,7 @@ export function deserializeStaticArrayArray<T extends StaticArray<any>>(
     ptr += 2;
   }
 
-  const outSize = count << (alignof<valueof<T>>());
+  const outSize = count * sizeof<valueof<T>>();
   const out = changetype<nonnull<T>>(dst || __new(outSize, idof<T>()));
 
   // Second pass: populate values

package/assembly/deserialize/{simple → naive}/staticarray/bool.ts

@@ -20,7 +20,7 @@ export function deserializeStaticArrayBoolean<T extends StaticArray<any>>(
   }
 
   // Allocate StaticArray with correct size
-  const outSize = count << (alignof<valueof<T>>());
+  const outSize = count * sizeof<valueof<T>>();
   const out = changetype<nonnull<T>>(dst || __new(outSize, idof<T>()));
 
   // Second pass: populate values

package/assembly/deserialize/{simple → naive}/staticarray/float.ts

@@ -23,7 +23,7 @@ export function deserializeStaticArrayFloat<T extends StaticArray<any>>(
     ptr += 2;
   }
 
-  const outSize = count << (alignof<valueof<T>>());
+  const outSize = count * sizeof<valueof<T>>();
   const out = changetype<nonnull<T>>(dst || __new(outSize, idof<T>()));
 
   let index = 0;

package/assembly/deserialize/{simple → naive}/staticarray/integer.ts

@@ -22,7 +22,7 @@ export function deserializeStaticArrayInteger<T extends StaticArray<any>>(
     ptr += 2;
   }
 
-  const outSize = count << (alignof<valueof<T>>());
+  const outSize = count * sizeof<valueof<T>>();
   const out = changetype<nonnull<T>>(dst || __new(outSize, idof<T>()));
 
   // Second pass: populate values

package/assembly/deserialize/{simple → naive}/staticarray/struct.ts

@@ -12,7 +12,6 @@ export function deserializeStaticArrayStruct<T extends StaticArray<any>>(
   srcEnd: usize,
   dst: usize,
 ): T {
-  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
 
   if (srcStart - srcEnd == 0)
@@ -44,7 +43,7 @@ export function deserializeStaticArrayStruct<T extends StaticArray<any>>(
   }
 
   // Allocate StaticArray with correct size
-  const outSize = count << (alignof<valueof<T>>());
+  const outSize = count * sizeof<valueof<T>>();
   const out = changetype<nonnull<T>>(dst || __new(outSize, idof<T>()));
 
   // Second pass: populate values

package/assembly/deserialize/{simple → naive}/staticarray.ts

@@ -4,18 +4,18 @@ import { deserializeArbitraryArray } from "./array/arbitrary";
 import { deserializeArrayArray } from "./array/array";
 import { deserializeBooleanArray } from "./array/bool";
 import { deserializeBoxArray } from "./array/box";
-import { deserializeFloatArray } from "./array/float";
-import { deserializeIntegerArray } from "./array/integer";
+import { deserializeFloatArray_NAIVE } from "./array/float";
+import { deserializeIntegerArray_NAIVE } from "./array/integer";
 import { deserializeMapArray } from "./array/map";
 import { deserializeObjectArray } from "./array/object";
 import { deserializeRawArray } from "./array/raw";
 import { deserializeStructArray } from "./array/struct";
-import { deserializeStringArray } from "./array/string";
+import { deserializeStringArray_NAIVE } from "./array/string";
 import { deserializeStaticArrayBoolean } from "./staticarray/bool";
 import { deserializeStaticArrayFloat } from "./staticarray/float";
 import { deserializeStaticArrayInteger } from "./staticarray/integer";
 import { deserializeStaticArrayString } from "./staticarray/string";
-import { scanValueEnd } from "../swar/array/shared";
+import { scanValueEnd } from "../../util/scanValueEnd";
 
 
 @inline function materializeStaticArray<T extends StaticArray<any>>(