json-as 1.0.0-alpha.2 → 1.0.0-alpha.4

package/assembly/serialize/simd/string.ts

@@ -18,7 +18,7 @@ export function serializeString_SIMD(src: string): void {
   const srcSize = changetype<OBJECT>(changetype<usize>(src) - TOTAL_OVERHEAD).rtSize;
   let srcStart = changetype<usize>(src);
   const srcEnd = srcStart + srcSize;
-  bs.ensureSize(srcSize + 4);
+  bs.proposeSize(srcSize + 4);
   const srcEnd16 = srcEnd - 15;
 
   store<u8>(changetype<usize>(bs.offset), 34); /* " */
@@ -45,13 +45,13 @@ export function serializeString_SIMD(src: string): void {
       mask &= mask - 1;
 
       if ((escaped & 0xffff) != BACK_SLASH) {
-        bs.ensureSize(10);
+        bs.growSize(10);
         store<u64>(dst_offset, 13511005048209500);
         store<u32>(dst_offset, escaped, 8);
         v128.store(dst_offset, v128.load(src_offset, 2), 12);
         bs.offset += 10;
       } else {
-        bs.ensureSize(2);
+        bs.growSize(2);
         store<u32>(dst_offset, escaped);
         v128.store(dst_offset, v128.load(src_offset, 2), 4);
         bs.offset += 2;
@@ -84,7 +84,7 @@ export function serializeString_SIMD(src: string): void {
       mask &= mask - 1;
 
       if ((escaped & 0xffff) != BACK_SLASH) {
-        bs.ensureSize(10);
+        bs.growSize(10);
         store<u64>(dst_offset, 13511005048209500);
         store<u32>(dst_offset, escaped, 8);
         while (lane_index < 6) {
@@ -93,7 +93,7 @@ export function serializeString_SIMD(src: string): void {
         }
         bs.offset += 10;
       } else {
-        bs.ensureSize(2);
+        bs.growSize(2);
         store<u32>(dst_offset, escaped);
 
         while (lane_index < 6) {
@@ -116,12 +116,12 @@ export function serializeString_SIMD(src: string): void {
       const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + (codeA << 2));
 
       if ((escaped & 0xffff) != BACK_SLASH) {
-        bs.ensureSize(10);
+        bs.growSize(10);
         store<u64>(bs.offset, 13511005048209500);
         store<u32>(bs.offset, escaped, 8);
         bs.offset += 12;
       } else {
-        bs.ensureSize(2);
+        bs.growSize(2);
         store<u32>(bs.offset, escaped);
         bs.offset += 4;
       }
@@ -134,12 +134,12 @@ export function serializeString_SIMD(src: string): void {
       const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + (codeB << 2));
 
       if ((escaped & 0xffff) != BACK_SLASH) {
-        bs.ensureSize(10);
+        bs.growSize(10);
         store<u64>(bs.offset, 13511005048209500);
         store<u32>(bs.offset, escaped, 8);
         bs.offset += 12;
       } else {
-        bs.ensureSize(2);
+        bs.growSize(2);
         store<u32>(bs.offset, escaped);
         bs.offset += 4;
       }
@@ -156,12 +156,12 @@ export function serializeString_SIMD(src: string): void {
       const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + (code << 2));
 
       if ((escaped & 0xffff) != BACK_SLASH) {
-        bs.ensureSize(10);
+        bs.growSize(10);
         store<u64>(bs.offset, 13511005048209500);
         store<u32>(bs.offset, escaped, 8);
         bs.offset += 12;
       } else {
-        bs.ensureSize(2);
+        bs.growSize(2);
         store<u32>(bs.offset, escaped);
         bs.offset += 4;
       }

package/assembly/serialize/simple/array.ts

@@ -3,15 +3,16 @@ import { COMMA, BRACKET_RIGHT, BRACKET_LEFT } from "../../custom/chars";
 import { JSON } from "../..";
 
 export function serializeArray<T extends any[]>(src: T): void {
+  bs.proposeSize(4);
   const end = src.length - 1;
   let i = 0;
   if (end == -1) {
-    bs.ensureSize(4);
     store<u32>(bs.offset, 6094939);
     bs.offset += 4;
     return;
   }
-  bs.ensureSize(end << 3);
+  // {} = 4
+  // xi, = n << 1
 
   store<u16>(bs.offset, BRACKET_LEFT);
   bs.offset += 2;
@@ -19,14 +20,14 @@ export function serializeArray<T extends any[]>(src: T): void {
   while (i < end) {
     const block = unchecked(src[i++]);
     JSON.__serialize<valueof<T>>(block);
-    bs.ensureSize(2);
+    bs.growSize(2);
     store<u16>(bs.offset, COMMA);
     bs.offset += 2;
   }
 
   const lastBlock = unchecked(src[end]);
   JSON.__serialize<valueof<T>>(lastBlock);
-  bs.ensureSize(2);
+  bs.growSize(2);
   store<u16>(bs.offset, BRACKET_RIGHT);
   bs.offset += 2;
 }

package/assembly/serialize/simple/bool.ts

@@ -7,11 +7,11 @@ import { bs } from "../../../modules/as-bs";
  */
 export function serializeBool(data: bool): void {
   if (data == true) {
-    bs.ensureSize(8);
+    bs.proposeSize(8);
     store<u64>(bs.offset, 28429475166421108);
     bs.offset += 8;
   } else {
-    bs.ensureSize(10);
+    bs.proposeSize(10);
     store<u64>(bs.offset, 32370086184550502);
     store<u64>(bs.offset, 101, 8);
     bs.offset += 10;

package/assembly/serialize/simple/date.ts

@@ -5,7 +5,7 @@ import { bytes } from "../../util/bytes";
 export function serializeDate(src: Date): void {
   const data = src.toISOString();
   const dataSize = bytes(data);
-  bs.ensureSize(dataSize + 4);
+  bs.proposeSize(dataSize + 4);
   store<u16>(bs.offset, QUOTE);
   memory.copy(bs.offset + 2, changetype<usize>(data), dataSize);
   store<u16>(bs.offset + dataSize, QUOTE, 2);

package/assembly/serialize/simple/integer.ts

@@ -3,5 +3,10 @@ import { bs } from "../../../modules/as-bs";
 
 export function serializeInteger<T extends number>(data: T): void {
   bs.ensureSize(sizeof<T>() << 3);
-  bs.offset += itoa_buffered(bs.offset, data) << 1;
+  const bytesWritten = itoa_buffered(bs.offset, data) << 1;
+  bs.offset += bytesWritten;
+  bs.growSize(bytesWritten);
 }
+
+// 32 {"x":,"y":,"z"}
+// 18 3.41.28.3

package/assembly/serialize/simple/map.ts

@@ -7,7 +7,7 @@ export function serializeMap<T extends Map<any, any>>(src: T): void {
   const srcEnd = srcSize - 1;
 
   if (srcSize == 0) {
-    bs.ensureSize(4);
+    bs.proposeSize(4);
     store<u32>(bs.offset, 8192123);
     bs.offset += 4;
     return;
@@ -16,28 +16,28 @@ export function serializeMap<T extends Map<any, any>>(src: T): void {
   let keys = src.keys();
   let values = src.values();
 
-  bs.ensureSize(srcSize << 3); // This needs to be predicted better
+  bs.proposeSize(srcSize << 3); // This needs to be predicted better
 
   store<u16>(bs.offset, BRACE_LEFT);
   bs.offset += 2;
 
   for (let i = 0; i < srcEnd; i++) {
     JSON.__serialize(unchecked(keys[i]));
-    bs.ensureSize(2);
+    bs.growSize(2);
     store<u16>(bs.offset, COLON);
     bs.offset += 2;
     JSON.__serialize(unchecked(values[i]));
-    bs.ensureSize(2);
+    bs.growSize(2);
     store<u16>(bs.offset, COMMA);
     bs.offset += 2;
   }
 
   JSON.__serialize(unchecked(keys[srcEnd]));
-  bs.ensureSize(2);
+  bs.growSize(2);
   store<u16>(bs.offset, COLON);
   bs.offset += 2;
   JSON.__serialize(unchecked(values[srcEnd]));
-  bs.ensureSize(2);
+  bs.growSize(2);
   store<u16>(bs.offset, BRACE_RIGHT);
   bs.offset += 2;
 }

package/assembly/serialize/simple/string.ts

@@ -11,7 +11,7 @@ import { SERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
  */
 export function serializeString(src: string): void {
   const srcSize = bytes(src);
-  bs.ensureSize(srcSize + 4);
+  bs.proposeSize(srcSize + 4);
   let srcPtr = changetype<usize>(src);
   const srcEnd = srcPtr + srcSize;
 
@@ -27,12 +27,12 @@ export function serializeString(src: string): void {
       bs.offset += remBytes;
       const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + (code << 2));
       if ((escaped & 0xffff) != BACK_SLASH) {
-        bs.ensureSize(10);
+        bs.growSize(10);
         store<u64>(bs.offset, 13511005048209500, 0);
         store<u32>(bs.offset, escaped, 8);
         bs.offset += 12;
       } else {
-        bs.ensureSize(2);
+        bs.growSize(2);
         store<u32>(bs.offset, escaped, 0);
         bs.offset += 4;
       }

package/assembly/test.ts

@@ -1,25 +1,30 @@
 import { JSON } from ".";
+import { bytes } from "./util";
 
-// @json or @serializable work here
 @json
-class Vec3 {
-  x: f64 = 0.0;
-  y: f64 = 0.0;
-  z: f64 = 0.0;
+class Obj {
+  public a: string = "hello";
+  public b: string = "world";
+  public c: string = "\"\t\f\u0000\u0001";
 }
 
+@json
+class Vec3 {
+  x: f32 = 0.0;
+  y: f32 = 0.0;
+  z: f32 = 0.0;
+}
 
 @json
 class Player {
-
   @alias("first name")
   firstName!: string;
   lastName!: string;
   lastActive!: i32[];
   // Drop in a code block, function, or expression that evaluates to a boolean
-  @omitif((self: Player): boolean => self.age <= 18)
+  @omitif((age) => age < 18)
+  @omitif('this.age <= 0')
   age!: i32;
-
   @omitnull()
   pos!: Vec3 | null;
   isVerified!: boolean;
@@ -28,17 +33,27 @@ class Player {
 const player: Player = {
   firstName: "Jairus",
   lastName: "Tanaka",
-  lastActive: [1, 20, 2025],
+  lastActive: [2, 7, 2025],
   age: 18,
   pos: {
     x: 3.4,
     y: 1.2,
-    z: 8.3,
+    z: 8.3
   },
-  isVerified: true,
+  isVerified: true
 };
 
-const stringified = JSON.stringify<Player>(player);
-console.log("Serialized: " + stringified);
-// const parsed = JSON.parse<Player>('{"pos":{"x":3.4,"y":1.2,"z":8.3},"first name":"Jairus","lastName":"Tanaka","lastActive":[1,20,2025],"age":18,"isVerified":true}');
-console.log("Deserialized: " + JSON.stringify<Player>(JSON.parse<Player>('{"pos":{"x":3.4,"y":1.2,"z":8.3},"first name":"Jairus","lastName":"Tanaka","lastActive":[1,20,2025],"age":18,"isVerified":true}')));
+const a1 = JSON.stringify("\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\u0008\u0009\u000a\u000b\u000c\u000d\u000e\u000f\u000f\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001a\u001b\u001c\u001d\u001e\u001f");
+// console.log("Bytes    " + bytes(a1).toString());
+console.log("a1: " + a1);
+
+const obj = new Obj();
+const a2 = JSON.stringify(obj);
+// console.log("Bytes    " + bytes(a2).toString());
+console.log("a2: " + a2);
+
+const a3 = JSON.stringify(player);
+// console.log("Bytes    " + bytes(a3).toString());
+console.log("a3: " + a3);
+
+JSON.Memory.shrink();

package/assembly/util/bytes.ts

@@ -7,6 +7,6 @@ import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
   } else if (isManaged<T>() || isReference<T>()) {
     return changetype<OBJECT>(changetype<usize>(o) - TOTAL_OVERHEAD).rtSize;
   } else {
-    ERROR("Cannot convert type " + nameof<T>() + " to bytes!");
+    throw new Error("Cannot convert type " + nameof<T>() + " to bytes!");
   }
 }

package/assembly/util/snp.ts

@@ -7,7 +7,7 @@ import { POW_TEN_TABLE_32, POW_TEN_TABLE_64 } from "../globals/tables";
 import { atoi } from "./atoi";
 
 // @ts-ignore: Decorator valid here
-@inline function snp<T extends number>(srcStart: usize, srcEnd: usize): T {
+@inline export function snp<T extends number>(srcStart: usize, srcEnd: usize): T {
   // @ts-ignore: type
   let val: T = 0;
   let char = load<u16>(srcStart) - 48;
@@ -46,7 +46,7 @@ import { atoi } from "./atoi";
           char = load<u16>(srcStart);
           if (char == 45) {
             // @ts-ignore: type
-            return val / pow10(atoi(srcStart + 2, srcEnd));
+            return val / pow10(atoi<u8>(srcStart + 2, srcEnd));
           } else {
             // @ts-ignore: type
             return val * pow10(atoi(srcStart, srcEnd));

package/modules/as-bs/assembly/index.ts

@@ -1,61 +1,81 @@
 import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
 
-let maxOffset: usize = __new(0, idof<ArrayBuffer>());
-
 /**
  * Central buffer namespace for managing memory operations.
  */
 export namespace bs {
-  /** Current buffer pointer. */
-  export let buffer: usize = maxOffset;
+  /** Current buffer pointer. */ // @ts-ignore
+  export let buffer: ArrayBuffer = new ArrayBuffer(32);//__new(32, idof<ArrayBuffer>());
 
   /** Current offset within the buffer. */
-  export let offset: usize = maxOffset;
+  export let offset: usize = changetype<usize>(buffer);
 
   /** Byte length of the buffer. */
-  export let byteLength: usize = 0;
+  let bufferSize: usize = 32;
+
+  /** Proposed size of output */
+  export let stackSize: usize = 0;
 
   /**
-   * Sets the buffer to a given data object and initializes related properties.
-   * @param data - The data object to set as the buffer.
+   * Proposes that the buffer size is should be greater than or equal to the proposed size.
+   * If necessary, reallocates the buffer to the exact new size.
+   * @param size - The size to propose.
    */
-  // @ts-ignore: Decorator valid here
-  @inline export function setBuffer<T>(data: T): void {
-    buffer = changetype<usize>(data);
-    offset = changetype<usize>(data);
-    byteLength = bytes(data);
-    maxOffset = byteLength + buffer;
+  // @ts-ignore: decorator
+  @inline export function ensureSize(size: u32): void {
+    // console.log("Ensure   " + (stackSize).toString() + " -> " + (stackSize + size).toString() + " (" + size.toString() + ") " + (((stackSize + size) > bufferSize) ? "+" : ""));
+    if (offset + size > bufferSize + changetype<usize>(buffer)) {
+      const deltaBytes = nextPowerOf2(size + 64);
+      bufferSize += deltaBytes;
+      // @ts-ignore: exists
+      const newPtr = changetype<ArrayBuffer>(__renew(
+        changetype<usize>(buffer),
+        bufferSize
+      ));
+      offset = offset + changetype<usize>(newPtr) - changetype<usize>(buffer);
+      buffer = newPtr;
+    }
   }
 
   /**
-   * Ensures the buffer has sufficient capacity for a given size.
-   * If necessary, reallocates the buffer to accommodate the new size.
-   * @param size - The size to ensure capacity for.
+   * Proposes that the buffer size is should be greater than or equal to the proposed size.
+   * If necessary, reallocates the buffer to the exact new size.
+   * @param size - The size to propose.
    */
-  // @ts-ignore: Decorator valid here
-  @inline export function ensureCapacity(size: u32): void {
-    const newSize: usize = offset + size;
-    if (newSize > byteLength) {
-      const newPtr = __renew(buffer, (byteLength = nextPowerOf2(newSize - buffer)));
-      offset = offset - buffer + newPtr;
-      maxOffset = newPtr + byteLength;
+  // @ts-ignore: decorator
+  @inline export function proposeSize(size: u32): void {
+    // console.log("Propose  " + (stackSize).toString() + " -> " + (stackSize + size).toString() + " (" + size.toString() + ") " + (((stackSize + size) > bufferSize) ? "+" : ""));
+    if ((stackSize += size) > bufferSize) {
+      const deltaBytes = nextPowerOf2(size);
+      bufferSize += deltaBytes;
+      // @ts-ignore: exists
+      const newPtr = changetype<ArrayBuffer>(__renew(
+        changetype<usize>(buffer),
+        bufferSize
+      ));
+      offset = offset + changetype<usize>(newPtr) - changetype<usize>(buffer);
       buffer = newPtr;
     }
   }
 
   /**
-   * Ensures the buffer size is sufficient for a given size.
+   * Increases the proposed size by nextPowerOf2(n + 64) if necessary.
    * If necessary, reallocates the buffer to the exact new size.
-   * @param size - The size to ensure.
+   * @param size - The size to grow by.
    */
-  // @ts-ignore: Decorator valid here
-  @inline export function ensureSize(size: u32): void {
-    const newSize: usize = offset + size;
-    if (newSize > maxOffset) {
-      byteLength += size;
-      const newPtr = __renew(buffer, byteLength);
-      offset = offset - buffer + newPtr;
-      maxOffset = newPtr + byteLength;
+  // @ts-ignore: decorator
+  @inline export function growSize(size: u32): void {
+    // console.log("Grow     " + (stackSize).toString() + " -> " + (stackSize + size).toString() + " (" + size.toString() + ") " + (((stackSize + size) > bufferSize) ? "+" : ""));
+    if ((stackSize += size) > bufferSize) {
+      const deltaBytes = nextPowerOf2(size + 64);
+      bufferSize += deltaBytes;
+      // @ts-ignore
+      const newPtr = changetype<ArrayBuffer>(__renew(
+        changetype<usize>(buffer),
+        bufferSize
+      ));
+      // if (buffer != newPtr) console.log("  Old: " + changetype<usize>(buffer).toString() + "\n  New: " + changetype<usize>(newPtr).toString());
+      offset = offset + changetype<usize>(newPtr) - changetype<usize>(buffer);
       buffer = newPtr;
     }
   }
@@ -66,68 +86,27 @@ export namespace bs {
    */
   // @ts-ignore: Decorator valid here
   @inline export function resize(newSize: u32): void {
+    // @ts-ignore: exists
     const newPtr = __renew(buffer, newSize);
-    byteLength = newSize;
+    bufferSize = newSize;
     buffer = newPtr;
-    offset = buffer + newSize;
-    maxOffset = buffer + byteLength;
-  }
-
-  /**
-   * Gets the remaining space available in the buffer.
-   * @returns The number of bytes remaining.
-   */
-  // @ts-ignore: Decorator valid here
-  @inline export function getRemainingSize(): usize {
-    return maxOffset - offset;
-  }
-
-  /**
-   * Clears data from a specified offset onward.
-   * @param fromOffset - The starting offset to clear from.
-   */
-  // @ts-ignore: Decorator valid here
-  @inline export function clearFromOffset(fromOffset: usize): void {
-    if (fromOffset < offset) {
-      memory.fill(fromOffset, 0, offset - fromOffset);
-      offset = fromOffset;
-    }
-  }
-
-  /**
-   * Shrinks the buffer to fit the current offset.
-   */
-  // @ts-ignore: Decorator valid here
-  @inline export function shrink(): void {
-    byteLength = offset - buffer;
-    buffer = __renew(buffer, byteLength);
-    maxOffset = byteLength + buffer;
-  }
-
-  /**
-   * Shrinks the buffer and resets the offset, returning the buffer as a specified type.
-   * @returns The buffer cast to the specified type.
-   */
-  // @ts-ignore: Decorator valid here
-  @inline export function shrinkTo<T>(): T {
-    shrink();
-    offset = buffer;
-    return changetype<T>(buffer);
+    offset = newPtr + newSize;
+    stackSize = newPtr;
   }
 
   /**
    * Copies the buffer's content to a new object of a specified type.
-   * Optionally shrinks the buffer after copying.
-   * @param s - Whether to shrink the buffer after copying.
    * @returns The new object containing the buffer's content.
    */
   // @ts-ignore: Decorator valid here
-  @inline export function out<T>(s: bool = false): T {
-    const len = offset - buffer;
+  @inline export function out<T>(): T {
+    const len = offset - changetype<usize>(buffer);
+    // @ts-ignore: exists
     const _out = __new(len, idof<T>());
-    memory.copy(_out, buffer, len);
-    if (s) shrink();
-    offset = buffer;
+    memory.copy(_out, changetype<usize>(buffer), len);
+
+    offset = changetype<usize>(buffer);
+    stackSize = 0;
     return changetype<T>(_out);
   }
 
@@ -139,12 +118,14 @@ export namespace bs {
    * @returns The destination pointer cast to the specified type.
    */
   // @ts-ignore: Decorator valid here
-  @inline export function outTo<T>(dst: usize, s: bool = false): T {
-    const len = offset - buffer;
+  @inline export function outTo<T>(dst: usize): T {
+    const len = offset - changetype<usize>(buffer);
+    // @ts-ignore: exists
     if (len != changetype<OBJECT>(dst - TOTAL_OVERHEAD).rtSize) __renew(len, idof<T>());
-    memory.copy(dst, buffer, len);
-    if (s) shrink();
-    offset = buffer;
+    memory.copy(dst, changetype<usize>(buffer), len);
+
+    offset = changetype<usize>(buffer);
+    stackSize = 0;
     return changetype<T>(dst);
   }
 }
@@ -161,6 +142,6 @@ export namespace bs {
   } else if (isManaged<T>() || isReference<T>()) {
     return changetype<OBJECT>(changetype<usize>(o) - TOTAL_OVERHEAD).rtSize;
   } else {
-    ERROR("Cannot convert type " + nameof<T>() + " to bytes!");
+    throw new Error("Cannot convert type " + nameof<T>() + " to bytes!");
   }
 }

package/modules/test/assembly/index.ts

@@ -0,0 +1,22 @@
+export function describe(description: string, routine: () => void): void {
+  routine();
+}
+
+export function expect(left: string): Expectation {
+  return new Expectation(left);
+}
+
+class Expectation {
+  public left: string;
+
+  constructor(left: string) {
+    this.left = left;
+  }
+  toBe(right: string): void {
+    if (this.left != right) {
+      console.log("  (expected) -> " + right);
+      console.log("  (received) -> " + this.left);
+      process.exit(1);
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-as",
-  "version": "1.0.0-alpha.2",
+  "version": "1.0.0-alpha.4",
   "author": "Jairus Tanaka",
   "repository": {
     "type": "git",
@@ -8,17 +8,13 @@
   },
   "main": "transform/lib/index.js",
   "devDependencies": {
-    "as-bs": "./modules/as-bs/",
     "@assemblyscript/wasi-shim": "^0.1.0",
-    "@types/node": "latest",
-    "as-bench": "^0.0.0-alpha",
+    "@types/node": "^22.13.1",
     "as-console": "^7.0.0",
-    "as-test": "^0.3.5",
-    "assemblyscript": "^0.27.31",
+    "assemblyscript": "^0.27.34",
     "assemblyscript-prettier": "^3.0.1",
-    "prettier": "^3.4.2",
-    "typescript": "latest",
-    "visitor-as": "^0.11.4"
+    "prettier": "^3.5.0",
+    "typescript": "^5.7.3"
   },
   "bugs": {
     "url": "https://github.com/JairusSW/as-json/issues"
@@ -55,7 +51,7 @@
     "@JairusSW:registry": "https://npm.pkg.github.com"
   },
   "scripts": {
-    "test": "rm -rf ./build/ && ast test",
+    "test": "bash ./run-tests.sh",
     "build:bench": "rm -rf ./build/ && asc assembly/__benches__/misc.bench.ts -o ./build/bench.wasm --textFile ./build/bench.wat --transform ./transform --optimizeLevel 3 --shrinkLevel 0 --converge --noAssert --uncheckedBehavior always --runtime incremental --enable simd --enable bulk-memory",
     "build:test": "rm -rf ./build/ && JSON_DEBUG=true asc assembly/test.ts --transform ./transform -o ./build/test.wasm --textFile ./build/test.wat --optimizeLevel 3 --shrinkLevel 0",
     "build:test:simd": "rm -rf ./build/ && JSON_DEBUG=true asc assembly/test.ts --transform ./transform -o ./build/test.wasm --textFile ./build/test.wat --optimizeLevel 3 --shrinkLevel 0 --enable simd",

package/run-tests.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+
+mkdir -p ./build
+
+for file in ./assembly/__tests__/*.spec.ts; do
+  filename=$(basename -- "$file")
+  output="./build/${filename%.ts}.wasm"
+
+  asc "$file" --transform ./transform -o "$output" || { echo "Tests failed"; exit 1; }
+
+  echo " -> $filename"
+  wasmtime "$output" || { echo "Tests failed"; exit 1; }
+done
+
+echo "All tests passed"