@fluffylabs/anan-as 1.0.0-031e728

package/README.md

@@ -0,0 +1,112 @@
+# 🍍 anan-as
+
+Assembly Script implementation of the JAM PVM (32bit).
+
+[Demo](https://todr.me/anan-as)
+
+#### 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?
+
+- [Pineaples](https://en.wikipedia.org/wiki/Ananas) are cool.
+- [JAM](https://graypaper.com/) is promising.
+- [PVM](https://github.com/paritytech/polkavm) is neat.
+
+
+### Useful where?
+
+- Potentially as an alternative implementation for [`typeberry`](https://github.com/fluffylabs).
+- To test out the [PVM debugger](https://pvm.fluffylabs.dev).
+
+## Installation
+
+```bash
+npm install @fluffylabs/anan-as
+```
+
+## Usage
+
+The package exports multiple builds to suit different use cases:
+
+### ESM Bindings (Recommended)
+
+ESM bindings provide a convenient JavaScript wrapper around the WebAssembly module:
+
+```javascript
+// Default import (optimized release build with ESM bindings)
+import ananAs from '@fluffylabs/anan-as';
+
+// Debug build (includes source maps and debug info)
+import ananAs from '@fluffylabs/anan-as/debug';
+
+// Explicit release build
+import ananAs from '@fluffylabs/anan-as/release';
+
+// Release build with minimal runtime (requires manually calling GC)
+import ananAs from '@fluffylabs/anan-as/release-mini';
+// make sure to call GC after multiple independent runs
+ananAs.__collect();
+
+```
+
+### 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:
+
+```javascript
+// Raw bindings
+import { instantiate } from '@fluffylabs/anan-as/raw';
+// Import WASM file URLs
+import debugWasm from '@fluffylabs/anan-as/debug.wasm';
+import releaseWasm from '@fluffylabs/anan-as/release.wasm';
+
+// Use with your own loader
+const module = await WebAssembly.instantiateStreaming(
+  fetch(releaseWasm),
+  imports
+);
+const ananAs = await instantiate(module);
+
+```
+
+### Version Tags
+
+When installing the package, you can choose between stable releases and bleeding-edge builds:
+
+```bash
+# Latest stable release
+npm install @fluffylabs/anan-as
+
+# Latest build from main branch (includes commit hash)
+npm install @fluffylabs/anan-as@next
+```
+
+## Building
+
+To download the dependencies:
+```
+$ npm ci
+```
+
+To build the WASM modules (in `./build/{release,debug}.wasm`):
+
+```
+$ npm run build
+```
+
+To run the example in the browser at [http://localhost:3000](http://localhost:3000).
+
+```
+$ npm run web
+```
+
+To run JSON test vectors.
+
+```
+$ npm start ./path/to/tests/*.json
+```

package/build/debug-raw.d.ts

@@ -0,0 +1,210 @@
+declare namespace __AdaptedExports {
+  /** Exported memory */
+  export const memory: WebAssembly.Memory;
+  /**
+   * assembly/api-internal/getAssembly
+   * @param p `assembly/program/Program`
+   * @returns `~lib/string/String`
+   */
+  export function getAssembly(p: __Internref26): string;
+  /**
+   * assembly/program-build/wrapAsProgram
+   * @param bytecode `~lib/typedarray/Uint8Array`
+   * @returns `~lib/typedarray/Uint8Array`
+   */
+  export 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 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 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 function resetGenericWithMemory(program: Array<number>, flatRegisters: Array<number>, pageMap: Uint8Array, chunks: Uint8Array, initialGas: bigint, hasMetadata?: boolean): void;
+  /**
+   * assembly/api-debugger/nextStep
+   * @returns `bool`
+   */
+  export function nextStep(): boolean;
+  /**
+   * assembly/api-debugger/nSteps
+   * @param steps `u32`
+   * @returns `bool`
+   */
+  export function nSteps(steps: number): boolean;
+  /**
+   * assembly/api-debugger/getProgramCounter
+   * @returns `u32`
+   */
+  export function getProgramCounter(): number;
+  /**
+   * assembly/api-debugger/setNextProgramCounter
+   * @param pc `u32`
+   */
+  export function setNextProgramCounter(pc: number): void;
+  /**
+   * assembly/api-debugger/getStatus
+   * @returns `u8`
+   */
+  export function getStatus(): number;
+  /**
+   * assembly/api-debugger/getExitArg
+   * @returns `u32`
+   */
+  export function getExitArg(): number;
+  /**
+   * assembly/api-debugger/getGasLeft
+   * @returns `i64`
+   */
+  export function getGasLeft(): bigint;
+  /**
+   * assembly/api-debugger/setGasLeft
+   * @param gas `i64`
+   */
+  export function setGasLeft(gas: bigint): void;
+  /**
+   * assembly/api-debugger/getRegisters
+   * @returns `~lib/typedarray/Uint8Array`
+   */
+  export function getRegisters(): Uint8Array;
+  /**
+   * assembly/api-debugger/setRegisters
+   * @param flatRegisters `~lib/array/Array<u8>`
+   */
+  export function setRegisters(flatRegisters: Array<number>): void;
+  /**
+   * assembly/api-debugger/getPageDump
+   * @param index `u32`
+   * @returns `~lib/typedarray/Uint8Array`
+   */
+  export function getPageDump(index: number): Uint8Array;
+  /**
+   * assembly/api-debugger/setMemory
+   * @param address `u32`
+   * @param data `~lib/typedarray/Uint8Array`
+   */
+  export function setMemory(address: number, data: Uint8Array): void;
+  /** assembly/api-utils/InputKind */
+  export enum InputKind {
+    /** @type `i32` */
+    Generic,
+    /** @type `i32` */
+    SPI,
+  }
+  /** assembly/api-utils/HasMetadata */
+  export 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 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 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 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 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;
+}
+/** Instantiates the compiled WebAssembly module with the given imports. */
+export declare function instantiate(module: WebAssembly.Module, imports: {
+  env: unknown,
+}): Promise<typeof __AdaptedExports>;

package/build/debug-raw.js

@@ -0,0 +1,372 @@
+export 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);
+    },
+    setMemory(address, data) {
+      // assembly/api-debugger/setMemory(u32, ~lib/typedarray/Uint8Array) => void
+      data = __lowerTypedArray(Uint8Array, 10, 0, data) || __notnull();
+      exports.setMemory(address, data);
+    },
+    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;
+}