@fluffylabs/anan-as 1.0.0-791e5e1 → 1.0.0-7ec9bd7

package/README.md

@@ -1,24 +1,23 @@
 # 🍍 anan-as
 
-Assembly Script implementation of the JAM PVM (32bit).
+AssemblyScript implementation of the JAM PVM (64-bit).
 
 [Demo](https://todr.me/anan-as)
 
-#### Todo
+## Todo
 
 - [x] Memory
 - [x] [JAM tests](https://github.com/w3f/jamtestvectors/pull/3) compatibility
 - [x] 64-bit & new instructions ([GrayPaper v0.5.0](https://graypaper.fluffylabs.dev))
 - [x] GP 0.5.4 compatibility (ZBB extensions)
 
-### Why?
+## Why?
 
-- [Pineaples](https://en.wikipedia.org/wiki/Ananas) are cool.
+- [Pineapples](https://en.wikipedia.org/wiki/Ananas) are cool.
 - [JAM](https://graypaper.com/) is promising.
 - [PVM](https://github.com/paritytech/polkavm) is neat.
 
-
-### Useful where?
+## Useful where?
 
 - Potentially as an alternative implementation for [`typeberry`](https://github.com/fluffylabs).
 - To test out the [PVM debugger](https://pvm.fluffylabs.dev).
@@ -54,9 +53,11 @@ ananAs.__collect();
 
 ```
 
-### Raw Bindings
+## Raw Bindings
 
-Raw bindings give you direct access to WebAssembly exports without the JavaScript wrapper layer. This is useful for instantiating multiple instances or when you need more control:
+Raw bindings give you direct access to WebAssembly exports
+without the JavaScript wrapper layer.
+This is useful for instantiating multiple instances or when you need more control:
 
 ```javascript
 // Raw bindings
@@ -74,9 +75,10 @@ const ananAs = await instantiate(module);
 
 ```
 
-### Version Tags
+## Version Tags
 
-When installing the package, you can choose between stable releases and bleeding-edge builds:
+When installing the package, you can choose between stable releases
+and bleeding-edge builds:
 
 ```bash
 # Latest stable release
@@ -89,24 +91,25 @@ npm install @fluffylabs/anan-as@next
 ## Building
 
 To download the dependencies:
-```
-$ npm ci
+
+```cmd
+npm ci
 ```
 
 To build the WASM modules (in `./build/{release,debug}.wasm`):
 
-```
-$ npm run build
+```cmd
+npm run build
 ```
 
 To run the example in the browser at [http://localhost:3000](http://localhost:3000).
 
-```
-$ npm run web
+```cmd
+npm run web
 ```
 
 To run JSON test vectors.
 
-```
-$ npm start ./path/to/tests/*.json
+```cmd
+npm start ./path/to/tests/*.json
 ```

package/build/debug-raw.d.ts

@@ -97,12 +97,20 @@ declare namespace __AdaptedExports {
    * @returns `~lib/typedarray/Uint8Array`
    */
   export function getPageDump(index: number): Uint8Array;
+  /**
+   * assembly/api-debugger/getMemory
+   * @param address `u32`
+   * @param length `u32`
+   * @returns `~lib/typedarray/Uint8Array | null`
+   */
+  export function getMemory(address: number, length: number): Uint8Array | null;
   /**
    * assembly/api-debugger/setMemory
    * @param address `u32`
    * @param data `~lib/typedarray/Uint8Array`
+   * @returns `bool`
    */
-  export function setMemory(address: number, data: Uint8Array): void;
+  export function setMemory(address: number, data: Uint8Array): boolean;
   /** assembly/api-utils/InputKind */
   export enum InputKind {
     /** @type `i32` */

package/build/debug-raw.js

@@ -109,10 +109,14 @@ export async function instantiate(module, imports = {}) {
       // assembly/api-debugger/getPageDump(u32) => ~lib/typedarray/Uint8Array
       return __liftTypedArray(Uint8Array, exports.getPageDump(index) >>> 0);
     },
+    getMemory(address, length) {
+      // assembly/api-debugger/getMemory(u32, u32) => ~lib/typedarray/Uint8Array | null
+      return __liftTypedArray(Uint8Array, exports.getMemory(address, length) >>> 0);
+    },
     setMemory(address, data) {
-      // assembly/api-debugger/setMemory(u32, ~lib/typedarray/Uint8Array) => void
+      // assembly/api-debugger/setMemory(u32, ~lib/typedarray/Uint8Array) => bool
       data = __lowerTypedArray(Uint8Array, 10, 0, data) || __notnull();
-      exports.setMemory(address, data);
+      return exports.setMemory(address, data) != 0;
     },
     InputKind: (values => (
       // assembly/api-utils/InputKind

package/build/debug.d.ts

@@ -96,12 +96,20 @@ export declare function setRegisters(flatRegisters: Array<number>): void;
  * @returns `~lib/typedarray/Uint8Array`
  */
 export declare function getPageDump(index: number): Uint8Array;
+/**
+ * assembly/api-debugger/getMemory
+ * @param address `u32`
+ * @param length `u32`
+ * @returns `~lib/typedarray/Uint8Array | null`
+ */
+export declare function getMemory(address: number, length: number): Uint8Array | null;
 /**
  * assembly/api-debugger/setMemory
  * @param address `u32`
  * @param data `~lib/typedarray/Uint8Array`
+ * @returns `bool`
  */
-export declare function setMemory(address: number, data: Uint8Array): void;
+export declare function setMemory(address: number, data: Uint8Array): boolean;
 /** assembly/api-utils/InputKind */
 export declare enum InputKind {
   /** @type `i32` */

package/build/debug.js

@@ -109,10 +109,14 @@ async function instantiate(module, imports = {}) {
       // assembly/api-debugger/getPageDump(u32) => ~lib/typedarray/Uint8Array
       return __liftTypedArray(Uint8Array, exports.getPageDump(index) >>> 0);
     },
+    getMemory(address, length) {
+      // assembly/api-debugger/getMemory(u32, u32) => ~lib/typedarray/Uint8Array | null
+      return __liftTypedArray(Uint8Array, exports.getMemory(address, length) >>> 0);
+    },
     setMemory(address, data) {
-      // assembly/api-debugger/setMemory(u32, ~lib/typedarray/Uint8Array) => void
+      // assembly/api-debugger/setMemory(u32, ~lib/typedarray/Uint8Array) => bool
       data = __lowerTypedArray(Uint8Array, 10, 0, data) || __notnull();
-      exports.setMemory(address, data);
+      return exports.setMemory(address, data) != 0;
     },
     InputKind: (values => (
       // assembly/api-utils/InputKind
@@ -388,6 +392,7 @@ export const {
   getRegisters,
   setRegisters,
   getPageDump,
+  getMemory,
   setMemory,
   InputKind,
   HasMetadata,

package/build/release-mini.d.ts

@@ -102,12 +102,20 @@ export declare function setRegisters(flatRegisters: Array<number>): void;
  * @returns `~lib/typedarray/Uint8Array`
  */
 export declare function getPageDump(index: number): Uint8Array;
+/**
+ * assembly/api-debugger/getMemory
+ * @param address `u32`
+ * @param length `u32`
+ * @returns `~lib/typedarray/Uint8Array | null`
+ */
+export declare function getMemory(address: number, length: number): Uint8Array | null;
 /**
  * assembly/api-debugger/setMemory
  * @param address `u32`
  * @param data `~lib/typedarray/Uint8Array`
+ * @returns `bool`
  */
-export declare function setMemory(address: number, data: Uint8Array): void;
+export declare function setMemory(address: number, data: Uint8Array): boolean;
 /** assembly/api-utils/InputKind */
 export declare enum InputKind {
   /** @type `i32` */

package/build/release-mini.js

@@ -109,10 +109,14 @@ async function instantiate(module, imports = {}) {
       // assembly/api-debugger/getPageDump(u32) => ~lib/typedarray/Uint8Array
       return __liftTypedArray(Uint8Array, exports.getPageDump(index) >>> 0);
     },
+    getMemory(address, length) {
+      // assembly/api-debugger/getMemory(u32, u32) => ~lib/typedarray/Uint8Array | null
+      return __liftTypedArray(Uint8Array, exports.getMemory(address, length) >>> 0);
+    },
     setMemory(address, data) {
-      // assembly/api-debugger/setMemory(u32, ~lib/typedarray/Uint8Array) => void
+      // assembly/api-debugger/setMemory(u32, ~lib/typedarray/Uint8Array) => bool
       data = __lowerTypedArray(Uint8Array, 10, 0, data) || __notnull();
-      exports.setMemory(address, data);
+      return exports.setMemory(address, data) != 0;
     },
     InputKind: (values => (
       // assembly/api-utils/InputKind
@@ -393,6 +397,7 @@ export const {
   getRegisters,
   setRegisters,
   getPageDump,
+  getMemory,
   setMemory,
   InputKind,
   HasMetadata,

package/build/release-stub.d.ts

@@ -0,0 +1,218 @@
+/** Exported memory */
+export declare const memory: WebAssembly.Memory;
+// Exported runtime interface
+export declare function __new(size: number, id: number): number;
+export declare function __pin(ptr: number): number;
+export declare function __unpin(ptr: number): void;
+export declare function __collect(): void;
+export declare const __rtti_base: number;
+/**
+ * assembly/api-internal/getAssembly
+ * @param p `assembly/program/Program`
+ * @returns `~lib/string/String`
+ */
+export declare function getAssembly(p: __Internref26): string;
+/**
+ * assembly/program-build/wrapAsProgram
+ * @param bytecode `~lib/typedarray/Uint8Array`
+ * @returns `~lib/typedarray/Uint8Array`
+ */
+export declare function wrapAsProgram(bytecode: Uint8Array): Uint8Array;
+/**
+ * assembly/api-debugger/resetJAM
+ * @param program `~lib/array/Array<u8>`
+ * @param pc `f64`
+ * @param initialGas `i64`
+ * @param args `~lib/array/Array<u8>`
+ * @param hasMetadata `bool`
+ */
+export declare function resetJAM(program: Array<number>, pc: number, initialGas: bigint, args: Array<number>, hasMetadata?: boolean): void;
+/**
+ * assembly/api-debugger/resetGeneric
+ * @param program `~lib/array/Array<u8>`
+ * @param flatRegisters `~lib/array/Array<u8>`
+ * @param initialGas `i64`
+ * @param hasMetadata `bool`
+ */
+export declare function resetGeneric(program: Array<number>, flatRegisters: Array<number>, initialGas: bigint, hasMetadata?: boolean): void;
+/**
+ * assembly/api-debugger/resetGenericWithMemory
+ * @param program `~lib/array/Array<u8>`
+ * @param flatRegisters `~lib/array/Array<u8>`
+ * @param pageMap `~lib/typedarray/Uint8Array`
+ * @param chunks `~lib/typedarray/Uint8Array`
+ * @param initialGas `i64`
+ * @param hasMetadata `bool`
+ */
+export declare function resetGenericWithMemory(program: Array<number>, flatRegisters: Array<number>, pageMap: Uint8Array, chunks: Uint8Array, initialGas: bigint, hasMetadata?: boolean): void;
+/**
+ * assembly/api-debugger/nextStep
+ * @returns `bool`
+ */
+export declare function nextStep(): boolean;
+/**
+ * assembly/api-debugger/nSteps
+ * @param steps `u32`
+ * @returns `bool`
+ */
+export declare function nSteps(steps: number): boolean;
+/**
+ * assembly/api-debugger/getProgramCounter
+ * @returns `u32`
+ */
+export declare function getProgramCounter(): number;
+/**
+ * assembly/api-debugger/setNextProgramCounter
+ * @param pc `u32`
+ */
+export declare function setNextProgramCounter(pc: number): void;
+/**
+ * assembly/api-debugger/getStatus
+ * @returns `u8`
+ */
+export declare function getStatus(): number;
+/**
+ * assembly/api-debugger/getExitArg
+ * @returns `u32`
+ */
+export declare function getExitArg(): number;
+/**
+ * assembly/api-debugger/getGasLeft
+ * @returns `i64`
+ */
+export declare function getGasLeft(): bigint;
+/**
+ * assembly/api-debugger/setGasLeft
+ * @param gas `i64`
+ */
+export declare function setGasLeft(gas: bigint): void;
+/**
+ * assembly/api-debugger/getRegisters
+ * @returns `~lib/typedarray/Uint8Array`
+ */
+export declare function getRegisters(): Uint8Array;
+/**
+ * assembly/api-debugger/setRegisters
+ * @param flatRegisters `~lib/array/Array<u8>`
+ */
+export declare function setRegisters(flatRegisters: Array<number>): void;
+/**
+ * assembly/api-debugger/getPageDump
+ * @param index `u32`
+ * @returns `~lib/typedarray/Uint8Array`
+ */
+export declare function getPageDump(index: number): Uint8Array;
+/**
+ * assembly/api-debugger/getMemory
+ * @param address `u32`
+ * @param length `u32`
+ * @returns `~lib/typedarray/Uint8Array | null`
+ */
+export declare function getMemory(address: number, length: number): Uint8Array | null;
+/**
+ * assembly/api-debugger/setMemory
+ * @param address `u32`
+ * @param data `~lib/typedarray/Uint8Array`
+ * @returns `bool`
+ */
+export declare function setMemory(address: number, data: Uint8Array): boolean;
+/** assembly/api-utils/InputKind */
+export declare enum InputKind {
+  /** @type `i32` */
+  Generic,
+  /** @type `i32` */
+  SPI,
+}
+/** assembly/api-utils/HasMetadata */
+export declare enum HasMetadata {
+  /** @type `i32` */
+  Yes,
+  /** @type `i32` */
+  No,
+}
+/**
+ * assembly/api-utils/getGasCosts
+ * @param input `~lib/array/Array<u8>`
+ * @param kind `i32`
+ * @param withMetadata `i32`
+ * @returns `~lib/array/Array<assembly/gas-costs/BlockGasCost>`
+ */
+export declare function getGasCosts(input: Array<number>, kind: number, withMetadata: number): Array<__Record50<never>>;
+/**
+ * assembly/api-utils/disassemble
+ * @param input `~lib/array/Array<u8>`
+ * @param kind `i32`
+ * @param withMetadata `i32`
+ * @returns `~lib/string/String`
+ */
+export declare function disassemble(input: Array<number>, kind: number, withMetadata: number): string;
+/**
+ * assembly/api-utils/prepareProgram
+ * @param kind `i32`
+ * @param hasMetadata `i32`
+ * @param program `~lib/array/Array<u8>`
+ * @param initialRegisters `~lib/array/Array<u64>`
+ * @param initialPageMap `~lib/array/Array<assembly/api-internal/InitialPage>`
+ * @param initialMemory `~lib/array/Array<assembly/api-internal/InitialChunk>`
+ * @param args `~lib/array/Array<u8>`
+ * @returns `assembly/spi/StandardProgram`
+ */
+export declare function prepareProgram(kind: number, hasMetadata: number, program: Array<number>, initialRegisters: Array<bigint>, initialPageMap: Array<__Record46<undefined>>, initialMemory: Array<__Record48<undefined>>, args: Array<number>): __Internref42;
+/**
+ * assembly/api-utils/runProgram
+ * @param program `assembly/spi/StandardProgram`
+ * @param initialGas `i64`
+ * @param programCounter `u32`
+ * @param logs `bool`
+ * @param useSbrkGas `bool`
+ * @returns `assembly/api-internal/VmOutput`
+ */
+export declare function runProgram(program: __Internref42, initialGas?: bigint, programCounter?: number, logs?: boolean, useSbrkGas?: boolean): __Record55<never>;
+/** assembly/program/Program */
+declare class __Internref26 extends Number {
+  private __nominal26: symbol;
+  private __nominal0: symbol;
+}
+/** assembly/gas-costs/BlockGasCost */
+declare interface __Record50<TOmittable> {
+  /** @type `u32` */
+  pc: number | TOmittable;
+  /** @type `u64` */
+  gas: bigint | TOmittable;
+}
+/** assembly/api-internal/InitialPage */
+declare interface __Record46<TOmittable> {
+  /** @type `u32` */
+  address: number | TOmittable;
+  /** @type `u32` */
+  length: number | TOmittable;
+  /** @type `i32` */
+  access: number | TOmittable;
+}
+/** assembly/api-internal/InitialChunk */
+declare interface __Record48<TOmittable> {
+  /** @type `u32` */
+  address: number | TOmittable;
+  /** @type `~lib/array/Array<u8>` */
+  data: Array<number>;
+}
+/** assembly/spi/StandardProgram */
+declare class __Internref42 extends Number {
+  private __nominal42: symbol;
+  private __nominal0: symbol;
+}
+/** assembly/api-internal/VmOutput */
+declare interface __Record55<TOmittable> {
+  /** @type `i32` */
+  status: number | TOmittable;
+  /** @type `~lib/array/Array<u64>` */
+  registers: Array<bigint>;
+  /** @type `u32` */
+  pc: number | TOmittable;
+  /** @type `~lib/array/Array<assembly/api-internal/InitialChunk>` */
+  memory: Array<__Record48<never>>;
+  /** @type `i64` */
+  gas: bigint | TOmittable;
+  /** @type `u32` */
+  exitCode: number | TOmittable;
+}

package/build/release-stub.js

@@ -0,0 +1,415 @@
+async function instantiate(module, imports = {}) {
+  const adaptedImports = {
+    env: Object.setPrototypeOf({
+      abort(message, fileName, lineNumber, columnNumber) {
+        // ~lib/builtins/abort(~lib/string/String | null?, ~lib/string/String | null?, u32?, u32?) => void
+        message = __liftString(message >>> 0);
+        fileName = __liftString(fileName >>> 0);
+        lineNumber = lineNumber >>> 0;
+        columnNumber = columnNumber >>> 0;
+        (() => {
+          // @external.js
+          throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);
+        })();
+      },
+      "console.log"(text) {
+        // ~lib/bindings/dom/console.log(~lib/string/String) => void
+        text = __liftString(text >>> 0);
+        console.log(text);
+      },
+    }, Object.assign(Object.create(globalThis), imports.env || {})),
+  };
+  const { exports } = await WebAssembly.instantiate(module, adaptedImports);
+  const memory = exports.memory || imports.env.memory;
+  const adaptedExports = Object.setPrototypeOf({
+    getAssembly(p) {
+      // assembly/api-internal/getAssembly(assembly/program/Program) => ~lib/string/String
+      p = __lowerInternref(p) || __notnull();
+      return __liftString(exports.getAssembly(p) >>> 0);
+    },
+    wrapAsProgram(bytecode) {
+      // assembly/program-build/wrapAsProgram(~lib/typedarray/Uint8Array) => ~lib/typedarray/Uint8Array
+      bytecode = __lowerTypedArray(Uint8Array, 10, 0, bytecode) || __notnull();
+      return __liftTypedArray(Uint8Array, exports.wrapAsProgram(bytecode) >>> 0);
+    },
+    resetJAM(program, pc, initialGas, args, hasMetadata) {
+      // assembly/api-debugger/resetJAM(~lib/array/Array<u8>, f64, i64, ~lib/array/Array<u8>, bool?) => void
+      program = __retain(__lowerArray(__setU8, 6, 0, program) || __notnull());
+      initialGas = initialGas || 0n;
+      args = __lowerArray(__setU8, 6, 0, args) || __notnull();
+      hasMetadata = hasMetadata ? 1 : 0;
+      try {
+        exports.__setArgumentsLength(arguments.length);
+        exports.resetJAM(program, pc, initialGas, args, hasMetadata);
+      } finally {
+        __release(program);
+      }
+    },
+    resetGeneric(program, flatRegisters, initialGas, hasMetadata) {
+      // assembly/api-debugger/resetGeneric(~lib/array/Array<u8>, ~lib/array/Array<u8>, i64, bool?) => void
+      program = __retain(__lowerArray(__setU8, 6, 0, program) || __notnull());
+      flatRegisters = __lowerArray(__setU8, 6, 0, flatRegisters) || __notnull();
+      initialGas = initialGas || 0n;
+      hasMetadata = hasMetadata ? 1 : 0;
+      try {
+        exports.__setArgumentsLength(arguments.length);
+        exports.resetGeneric(program, flatRegisters, initialGas, hasMetadata);
+      } finally {
+        __release(program);
+      }
+    },
+    resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas, hasMetadata) {
+      // assembly/api-debugger/resetGenericWithMemory(~lib/array/Array<u8>, ~lib/array/Array<u8>, ~lib/typedarray/Uint8Array, ~lib/typedarray/Uint8Array, i64, bool?) => void
+      program = __retain(__lowerArray(__setU8, 6, 0, program) || __notnull());
+      flatRegisters = __retain(__lowerArray(__setU8, 6, 0, flatRegisters) || __notnull());
+      pageMap = __retain(__lowerTypedArray(Uint8Array, 10, 0, pageMap) || __notnull());
+      chunks = __lowerTypedArray(Uint8Array, 10, 0, chunks) || __notnull();
+      initialGas = initialGas || 0n;
+      hasMetadata = hasMetadata ? 1 : 0;
+      try {
+        exports.__setArgumentsLength(arguments.length);
+        exports.resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas, hasMetadata);
+      } finally {
+        __release(program);
+        __release(flatRegisters);
+        __release(pageMap);
+      }
+    },
+    nextStep() {
+      // assembly/api-debugger/nextStep() => bool
+      return exports.nextStep() != 0;
+    },
+    nSteps(steps) {
+      // assembly/api-debugger/nSteps(u32) => bool
+      return exports.nSteps(steps) != 0;
+    },
+    getProgramCounter() {
+      // assembly/api-debugger/getProgramCounter() => u32
+      return exports.getProgramCounter() >>> 0;
+    },
+    getExitArg() {
+      // assembly/api-debugger/getExitArg() => u32
+      return exports.getExitArg() >>> 0;
+    },
+    setGasLeft(gas) {
+      // assembly/api-debugger/setGasLeft(i64) => void
+      gas = gas || 0n;
+      exports.setGasLeft(gas);
+    },
+    getRegisters() {
+      // assembly/api-debugger/getRegisters() => ~lib/typedarray/Uint8Array
+      return __liftTypedArray(Uint8Array, exports.getRegisters() >>> 0);
+    },
+    setRegisters(flatRegisters) {
+      // assembly/api-debugger/setRegisters(~lib/array/Array<u8>) => void
+      flatRegisters = __lowerArray(__setU8, 6, 0, flatRegisters) || __notnull();
+      exports.setRegisters(flatRegisters);
+    },
+    getPageDump(index) {
+      // assembly/api-debugger/getPageDump(u32) => ~lib/typedarray/Uint8Array
+      return __liftTypedArray(Uint8Array, exports.getPageDump(index) >>> 0);
+    },
+    getMemory(address, length) {
+      // assembly/api-debugger/getMemory(u32, u32) => ~lib/typedarray/Uint8Array | null
+      return __liftTypedArray(Uint8Array, exports.getMemory(address, length) >>> 0);
+    },
+    setMemory(address, data) {
+      // assembly/api-debugger/setMemory(u32, ~lib/typedarray/Uint8Array) => bool
+      data = __lowerTypedArray(Uint8Array, 10, 0, data) || __notnull();
+      return exports.setMemory(address, data) != 0;
+    },
+    InputKind: (values => (
+      // assembly/api-utils/InputKind
+      values[values.Generic = exports["InputKind.Generic"].valueOf()] = "Generic",
+      values[values.SPI = exports["InputKind.SPI"].valueOf()] = "SPI",
+      values
+    ))({}),
+    HasMetadata: (values => (
+      // assembly/api-utils/HasMetadata
+      values[values.Yes = exports["HasMetadata.Yes"].valueOf()] = "Yes",
+      values[values.No = exports["HasMetadata.No"].valueOf()] = "No",
+      values
+    ))({}),
+    getGasCosts(input, kind, withMetadata) {
+      // assembly/api-utils/getGasCosts(~lib/array/Array<u8>, i32, i32) => ~lib/array/Array<assembly/gas-costs/BlockGasCost>
+      input = __lowerArray(__setU8, 6, 0, input) || __notnull();
+      return __liftArray(pointer => __liftRecord50(__getU32(pointer)), 2, exports.getGasCosts(input, kind, withMetadata) >>> 0);
+    },
+    disassemble(input, kind, withMetadata) {
+      // assembly/api-utils/disassemble(~lib/array/Array<u8>, i32, i32) => ~lib/string/String
+      input = __lowerArray(__setU8, 6, 0, input) || __notnull();
+      return __liftString(exports.disassemble(input, kind, withMetadata) >>> 0);
+    },
+    prepareProgram(kind, hasMetadata, program, initialRegisters, initialPageMap, initialMemory, args) {
+      // assembly/api-utils/prepareProgram(i32, i32, ~lib/array/Array<u8>, ~lib/array/Array<u64>, ~lib/array/Array<assembly/api-internal/InitialPage>, ~lib/array/Array<assembly/api-internal/InitialChunk>, ~lib/array/Array<u8>) => assembly/spi/StandardProgram
+      program = __retain(__lowerArray(__setU8, 6, 0, program) || __notnull());
+      initialRegisters = __retain(__lowerArray(__setU64, 52, 3, initialRegisters) || __notnull());
+      initialPageMap = __retain(__lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord46(value) || __notnull()); }, 47, 2, initialPageMap) || __notnull());
+      initialMemory = __retain(__lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord48(value) || __notnull()); }, 49, 2, initialMemory) || __notnull());
+      args = __lowerArray(__setU8, 6, 0, args) || __notnull();
+      try {
+        return __liftInternref(exports.prepareProgram(kind, hasMetadata, program, initialRegisters, initialPageMap, initialMemory, args) >>> 0);
+      } finally {
+        __release(program);
+        __release(initialRegisters);
+        __release(initialPageMap);
+        __release(initialMemory);
+      }
+    },
+    runProgram(program, initialGas, programCounter, logs, useSbrkGas) {
+      // assembly/api-utils/runProgram(assembly/spi/StandardProgram, i64?, u32?, bool?, bool?) => assembly/api-internal/VmOutput
+      program = __lowerInternref(program) || __notnull();
+      initialGas = initialGas || 0n;
+      logs = logs ? 1 : 0;
+      useSbrkGas = useSbrkGas ? 1 : 0;
+      exports.__setArgumentsLength(arguments.length);
+      return __liftRecord55(exports.runProgram(program, initialGas, programCounter, logs, useSbrkGas) >>> 0);
+    },
+  }, exports);
+  function __liftRecord50(pointer) {
+    // assembly/gas-costs/BlockGasCost
+    // Hint: Opt-out from lifting as a record by providing an empty constructor
+    if (!pointer) return null;
+    return {
+      pc: __getU32(pointer + 0),
+      gas: __getU64(pointer + 8),
+    };
+  }
+  function __lowerRecord46(value) {
+    // assembly/api-internal/InitialPage
+    // Hint: Opt-out from lowering as a record by providing an empty constructor
+    if (value == null) return 0;
+    const pointer = exports.__pin(exports.__new(12, 46));
+    __setU32(pointer + 0, value.address);
+    __setU32(pointer + 4, value.length);
+    __setU32(pointer + 8, value.access);
+    exports.__unpin(pointer);
+    return pointer;
+  }
+  function __lowerRecord48(value) {
+    // assembly/api-internal/InitialChunk
+    // Hint: Opt-out from lowering as a record by providing an empty constructor
+    if (value == null) return 0;
+    const pointer = exports.__pin(exports.__new(8, 48));
+    __setU32(pointer + 0, value.address);
+    __setU32(pointer + 4, __lowerArray(__setU8, 6, 0, value.data) || __notnull());
+    exports.__unpin(pointer);
+    return pointer;
+  }
+  function __liftRecord48(pointer) {
+    // assembly/api-internal/InitialChunk
+    // Hint: Opt-out from lifting as a record by providing an empty constructor
+    if (!pointer) return null;
+    return {
+      address: __getU32(pointer + 0),
+      data: __liftArray(__getU8, 0, __getU32(pointer + 4)),
+    };
+  }
+  function __liftRecord55(pointer) {
+    // assembly/api-internal/VmOutput
+    // Hint: Opt-out from lifting as a record by providing an empty constructor
+    if (!pointer) return null;
+    return {
+      status: __getI32(pointer + 0),
+      registers: __liftArray(pointer => BigInt.asUintN(64, __getU64(pointer)), 3, __getU32(pointer + 4)),
+      pc: __getU32(pointer + 8),
+      memory: __liftArray(pointer => __liftRecord48(__getU32(pointer)), 2, __getU32(pointer + 12)),
+      gas: __getI64(pointer + 16),
+      exitCode: __getU32(pointer + 24),
+    };
+  }
+  function __liftString(pointer) {
+    if (!pointer) return null;
+    const
+      end = pointer + new Uint32Array(memory.buffer)[pointer - 4 >>> 2] >>> 1,
+      memoryU16 = new Uint16Array(memory.buffer);
+    let
+      start = pointer >>> 1,
+      string = "";
+    while (end - start > 1024) string += String.fromCharCode(...memoryU16.subarray(start, start += 1024));
+    return string + String.fromCharCode(...memoryU16.subarray(start, end));
+  }
+  function __liftArray(liftElement, align, pointer) {
+    if (!pointer) return null;
+    const
+      dataStart = __getU32(pointer + 4),
+      length = __dataview.getUint32(pointer + 12, true),
+      values = new Array(length);
+    for (let i = 0; i < length; ++i) values[i] = liftElement(dataStart + (i << align >>> 0));
+    return values;
+  }
+  function __lowerArray(lowerElement, id, align, values) {
+    if (values == null) return 0;
+    const
+      length = values.length,
+      buffer = exports.__pin(exports.__new(length << align, 1)) >>> 0,
+      header = exports.__pin(exports.__new(16, id)) >>> 0;
+    __setU32(header + 0, buffer);
+    __dataview.setUint32(header + 4, buffer, true);
+    __dataview.setUint32(header + 8, length << align, true);
+    __dataview.setUint32(header + 12, length, true);
+    for (let i = 0; i < length; ++i) lowerElement(buffer + (i << align >>> 0), values[i]);
+    exports.__unpin(buffer);
+    exports.__unpin(header);
+    return header;
+  }
+  function __liftTypedArray(constructor, pointer) {
+    if (!pointer) return null;
+    return new constructor(
+      memory.buffer,
+      __getU32(pointer + 4),
+      __dataview.getUint32(pointer + 8, true) / constructor.BYTES_PER_ELEMENT
+    ).slice();
+  }
+  function __lowerTypedArray(constructor, id, align, values) {
+    if (values == null) return 0;
+    const
+      length = values.length,
+      buffer = exports.__pin(exports.__new(length << align, 1)) >>> 0,
+      header = exports.__new(12, id) >>> 0;
+    __setU32(header + 0, buffer);
+    __dataview.setUint32(header + 4, buffer, true);
+    __dataview.setUint32(header + 8, length << align, true);
+    new constructor(memory.buffer, buffer, length).set(values);
+    exports.__unpin(buffer);
+    return header;
+  }
+  class Internref extends Number {}
+  const registry = new FinalizationRegistry(__release);
+  function __liftInternref(pointer) {
+    if (!pointer) return null;
+    const sentinel = new Internref(__retain(pointer));
+    registry.register(sentinel, pointer);
+    return sentinel;
+  }
+  function __lowerInternref(value) {
+    if (value == null) return 0;
+    if (value instanceof Internref) return value.valueOf();
+    throw TypeError("internref expected");
+  }
+  const refcounts = new Map();
+  function __retain(pointer) {
+    if (pointer) {
+      const refcount = refcounts.get(pointer);
+      if (refcount) refcounts.set(pointer, refcount + 1);
+      else refcounts.set(exports.__pin(pointer), 1);
+    }
+    return pointer;
+  }
+  function __release(pointer) {
+    if (pointer) {
+      const refcount = refcounts.get(pointer);
+      if (refcount === 1) exports.__unpin(pointer), refcounts.delete(pointer);
+      else if (refcount) refcounts.set(pointer, refcount - 1);
+      else throw Error(`invalid refcount '${refcount}' for reference '${pointer}'`);
+    }
+  }
+  function __notnull() {
+    throw TypeError("value must not be null");
+  }
+  let __dataview = new DataView(memory.buffer);
+  function __setU8(pointer, value) {
+    try {
+      __dataview.setUint8(pointer, value, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      __dataview.setUint8(pointer, value, true);
+    }
+  }
+  function __setU32(pointer, value) {
+    try {
+      __dataview.setUint32(pointer, value, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      __dataview.setUint32(pointer, value, true);
+    }
+  }
+  function __setU64(pointer, value) {
+    try {
+      __dataview.setBigUint64(pointer, value, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      __dataview.setBigUint64(pointer, value, true);
+    }
+  }
+  function __getU8(pointer) {
+    try {
+      return __dataview.getUint8(pointer, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      return __dataview.getUint8(pointer, true);
+    }
+  }
+  function __getI32(pointer) {
+    try {
+      return __dataview.getInt32(pointer, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      return __dataview.getInt32(pointer, true);
+    }
+  }
+  function __getU32(pointer) {
+    try {
+      return __dataview.getUint32(pointer, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      return __dataview.getUint32(pointer, true);
+    }
+  }
+  function __getI64(pointer) {
+    try {
+      return __dataview.getBigInt64(pointer, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      return __dataview.getBigInt64(pointer, true);
+    }
+  }
+  function __getU64(pointer) {
+    try {
+      return __dataview.getBigUint64(pointer, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      return __dataview.getBigUint64(pointer, true);
+    }
+  }
+  return adaptedExports;
+}
+export const {
+  memory,
+  __new,
+  __pin,
+  __unpin,
+  __collect,
+  __rtti_base,
+  getAssembly,
+  wrapAsProgram,
+  resetJAM,
+  resetGeneric,
+  resetGenericWithMemory,
+  nextStep,
+  nSteps,
+  getProgramCounter,
+  setNextProgramCounter,
+  getStatus,
+  getExitArg,
+  getGasLeft,
+  setGasLeft,
+  getRegisters,
+  setRegisters,
+  getPageDump,
+  getMemory,
+  setMemory,
+  InputKind,
+  HasMetadata,
+  getGasCosts,
+  disassemble,
+  prepareProgram,
+  runProgram,
+} = await (async url => instantiate(
+  await (async () => {
+    const isNodeOrBun = typeof process != "undefined" && process.versions != null && (process.versions.node != null || process.versions.bun != null);
+    if (isNodeOrBun) { return globalThis.WebAssembly.compile(await (await import("node:fs/promises")).readFile(url)); }
+    else { return await globalThis.WebAssembly.compileStreaming(globalThis.fetch(url)); }
+  })(), {
+  }
+))(new URL("release-stub.wasm", import.meta.url));

package/build/release.d.ts

@@ -96,12 +96,20 @@ export declare function setRegisters(flatRegisters: Array<number>): void;
  * @returns `~lib/typedarray/Uint8Array`
  */
 export declare function getPageDump(index: number): Uint8Array;
+/**
+ * assembly/api-debugger/getMemory
+ * @param address `u32`
+ * @param length `u32`
+ * @returns `~lib/typedarray/Uint8Array | null`
+ */
+export declare function getMemory(address: number, length: number): Uint8Array | null;
 /**
  * assembly/api-debugger/setMemory
  * @param address `u32`
  * @param data `~lib/typedarray/Uint8Array`
+ * @returns `bool`
  */
-export declare function setMemory(address: number, data: Uint8Array): void;
+export declare function setMemory(address: number, data: Uint8Array): boolean;
 /** assembly/api-utils/InputKind */
 export declare enum InputKind {
   /** @type `i32` */

package/build/release.js

@@ -109,10 +109,14 @@ async function instantiate(module, imports = {}) {
       // assembly/api-debugger/getPageDump(u32) => ~lib/typedarray/Uint8Array
       return __liftTypedArray(Uint8Array, exports.getPageDump(index) >>> 0);
     },
+    getMemory(address, length) {
+      // assembly/api-debugger/getMemory(u32, u32) => ~lib/typedarray/Uint8Array | null
+      return __liftTypedArray(Uint8Array, exports.getMemory(address, length) >>> 0);
+    },
     setMemory(address, data) {
-      // assembly/api-debugger/setMemory(u32, ~lib/typedarray/Uint8Array) => void
+      // assembly/api-debugger/setMemory(u32, ~lib/typedarray/Uint8Array) => bool
       data = __lowerTypedArray(Uint8Array, 10, 0, data) || __notnull();
-      exports.setMemory(address, data);
+      return exports.setMemory(address, data) != 0;
     },
     InputKind: (values => (
       // assembly/api-utils/InputKind
@@ -388,6 +392,7 @@ export const {
   getRegisters,
   setRegisters,
   getPageDump,
+  getMemory,
   setMemory,
   InputKind,
   HasMetadata,

package/package.json

@@ -1,22 +1,24 @@
 {
 	"name": "@fluffylabs/anan-as",
 	"description": "AssemblyScript PVM interpreter.",
-	"version": "1.0.0-791e5e1",
-	"main": "./bin/index.js",
+	"version": "1.0.0-7ec9bd7",
+	"main": "./bin/index.ts",
 	"repository": {
 		"url": "https://github.com/tomusdrw/anan-as"
 	},
 	"scripts": {
-		"asbuild": "npm run asbuild:debug && npm run asbuild:release && npm run asbuild:raw && npm run asbuild:release-mini",
+		"asbuild": "npm run asbuild:debug && npm run asbuild:release",
+		"asbuild:all": "npm run asbuild:debug && npm run asbuild:release && npm run asbuild:raw && npm run asbuild:release-mini && npm run asbuild:release-stub",
 		"asbuild:debug": "asc assembly/index.ts --target debug",
 		"asbuild:release": "asc assembly/index.ts --uncheckedBehavior=always --target release",
 		"asbuild:release-mini": "asc assembly/index.ts --uncheckedBehavior=always --target release-mini",
+		"asbuild:release-stub": "asc assembly/index.ts --uncheckedBehavior=always --target release-stub",
 		"asbuild:raw": "asc assembly/index.ts --target raw",
 		"asbuild:test": "asc assembly/test-run.ts --target test",
-		"build": "npm run asbuild && npm run cp-build",
+		"build": "npm run asbuild:all && npm run asbuild:test && npm run tsbuild && npm run cp-build",
 		"cp-build": "rm -rf ./web/build; cp -r ./build ./web/",
 		"format": "biome format --write",
-		"fuzz": "npx @jazzer.js/core --sync ./bin/fuzz",
+		"fuzz": "tsx ./bin/fuzz.ts",
 		"lint": "biome lint --write; biome check --write",
 		"prestart": "npm run build",
 		"pretest:w3f": "npm run build",
@@ -24,11 +26,12 @@
 		"preweb": "npm run build",
 		"qa": "biome ci",
 		"qa-fix": "npm run format; npm run lint",
-		"start": "node ./bin/index.js",
-		"test": "npm run asbuild:test && node ./bin/test.js",
-		"test:w3f": "node ./bin/test-w3f.js",
-		"test:gas-cost": "node ./bin/test-gas-cost.js",
-		"update-version": "node ./web/bump-version.js $GITHUB_SHA",
+		"start": "tsx ./bin/index.ts",
+		"test": "npm run asbuild:test && tsx ./bin/test.ts",
+		"tsbuild": "tsc",
+		"test:w3f": "tsx ./bin/test-w3f.ts",
+		"test:gas-cost": "tsx ./bin/test-gas-cost.ts",
+		"update-version": "tsx ./web/bump-version.ts $GITHUB_SHA",
 		"web": "npx live-server ./web"
 	},
 	"type": "module",
@@ -37,7 +40,10 @@
 	"license": "MPL-2.0",
 	"devDependencies": {
 		"@biomejs/biome": "^2.2.6",
-		"assemblyscript": "^0.28.8"
+		"@types/node": "^24.8.1",
+		"assemblyscript": "^0.28.8",
+		"tsx": "^4.20.6",
+		"typescript": "^5.9.3"
 	},
 	"files": [
 		"build/**/*.wasm",
@@ -63,6 +69,10 @@
 			"import": "./build/release-mini.js",
 			"types": "./build/release-mini.d.ts"
 		},
+		"./release-stub": {
+			"import": "./build/release-stub.js",
+			"types": "./build/release-stub.d.ts"
+		},
 		"./raw": {
 			"import": "./build/debug-raw.js",
 			"types": "./build/debug-raw.d.ts"