@fluffylabs/anan-as 1.1.4 → 1.1.6-38dddc8

package/README.md

@@ -2,14 +2,11 @@
 
 AssemblyScript implementation of the JAM PVM (64-bit).
 
-[Demo](https://todr.me/anan-as)
-
-## Todo
+![Gray Paper](https://img.shields.io/badge/Gray%20Paper-0.7.2-green)
+[![npm](https://img.shields.io/npm/v/@fluffylabs/anan-as)](https://www.npmjs.com/package/@fluffylabs/anan-as)
+[![npm dev](https://img.shields.io/npm/v/@fluffylabs/anan-as/next?label=dev)](https://www.npmjs.com/package/@fluffylabs/anan-as)
 
-- [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)
+[Demo](https://todr.me/anan-as)
 
 ## Why?
 
@@ -19,7 +16,7 @@ AssemblyScript implementation of the JAM PVM (64-bit).
 
 ## Useful where?
 
-- Potentially as an alternative implementation for [`typeberry`](https://github.com/fluffylabs).
+- Main PVM backend of [`typeberry`](https://github.com/fluffylabs) JAM client.
 - To test out the [PVM debugger](https://pvm.fluffylabs.dev).
 
 ## Installation
@@ -51,9 +48,26 @@ import ananAs from '@fluffylabs/anan-as/release-mini';
 // make sure to call GC after multiple independent runs
 ananAs.__collect();
 
+// Release build with stub host functions (for standalone testing)
+import ananAs from '@fluffylabs/anan-as/release-stub';
+
+// Compiler module (for PVM bytecode compilation)
+import ananAs from '@fluffylabs/anan-as/compiler';
+```
+
+### Inline Builds
+
+Inline builds bundle the WASM binary directly into the JavaScript module (base64 encoded),
+eliminating the need to fetch a separate `.wasm` file:
+
+```javascript
+import ananAs from '@fluffylabs/anan-as/debug-inline';
+import ananAs from '@fluffylabs/anan-as/release-inline';
+import ananAs from '@fluffylabs/anan-as/release-mini-inline';
+import ananAs from '@fluffylabs/anan-as/release-stub-inline';
 ```
 
-## Raw Bindings
+### Raw Bindings
 
 Raw bindings give you direct access to WebAssembly exports
 without the JavaScript wrapper layer.
@@ -72,7 +86,6 @@ const module = await WebAssembly.instantiateStreaming(
   imports
 );
 const ananAs = await instantiate(module);
-
 ```
 
 ## Version Tags
@@ -108,8 +121,90 @@ To run the example in the browser at [http://localhost:3000](http://localhost:30
 npm run web
 ```
 
-To run JSON test vectors.
+To run tests:
 
 ```cmd
-npm start ./path/to/tests/*.json
+# Run AssemblyScript unit tests and trace replay tests
+npm test
+
+# Run W3F test vectors
+npm run test:w3f
+
+# Run gas cost tests
+npm run test:gas-cost
+```
+
+## CLI Usage
+
+The package includes a CLI tool for disassembling, running, and replaying PVM bytecode:
+
+```bash
+# Disassemble bytecode to assembly
+npx @fluffylabs/anan-as disassemble [--spi] [--no-metadata] <file.pvm>
+
+# Run JAM programs
+npx @fluffylabs/anan-as run [--spi] [--no-logs] [--no-metadata] [--pc <number>] [--gas <number>] <file.pvm> [spi-args.bin or hex]
+
+# Replay an ecalli trace
+# Learn more: https://github.com/tomusdrw/JIPs/blob/td-jip6-ecalliloggin/JIP-6.md
+npx @fluffylabs/anan-as replay-trace [--no-metadata] [--no-verify] [--no-logs] <trace.log>
+
+# Show help
+npx @fluffylabs/anan-as --help
+npx @fluffylabs/anan-as disassemble --help
+npx @fluffylabs/anan-as run --help
+```
+
+The `run` command executes PVM bytecode until it encounters a `halt` instruction or a host call.
+The `replay-trace` command re-executes an ecalli trace, replaying recorded host call responses.
+
+### Commands
+
+- `disassemble`: Convert PVM bytecode to human-readable assembly
+- `run`: Execute PVM bytecode and show results
+- `replay-trace`: Re-execute an ecalli trace with recorded host call responses
+
+### Flags
+
+- `--spi`: Treat input as JAM SPI format instead of generic PVM
+- `--no-metadata`: Input does not start with metadata
+- `--no-logs`: Disable execution logs (run and replay-trace commands)
+- `--no-verify`: Skip verification against trace data (replay-trace only)
+- `--pc <number>`: Set initial program counter (default: 0)
+- `--gas <number>`: Set initial gas amount (default: 10,000)
+- `--help`, `-h`: Show help information
+
+### Examples
+
+```bash
+# Disassemble a JAM file (includes metadata by default)
+npx @fluffylabs/anan-as disassemble program.pvm
+
+# Disassemble without metadata
+npx @fluffylabs/anan-as disassemble --no-metadata program.pvm
+
+# Disassemble JAM SPI program
+npx @fluffylabs/anan-as disassemble --spi program.jam
+
+# Run a JAM program with logs (includes metadata by default)
+npx @fluffylabs/anan-as run program.pvm
+
+# Run a JAM program without metadata
+npx @fluffylabs/anan-as run --no-metadata program.pvm
+
+# Run a JAM program quietly
+npx @fluffylabs/anan-as run --no-logs program.pvm
+
+# Run a JAM program with custom initial PC and gas
+npx @fluffylabs/anan-as run --pc 100 --gas 10000 program.pvm
+
+# Run JAM SPI program with arguments (file or hex)
+npx @fluffylabs/anan-as run --spi program.jam args.bin
+npx @fluffylabs/anan-as run --spi program.jam 0xdeadbeef
+
+# Replay an ecalli trace
+npx @fluffylabs/anan-as replay-trace trace.log
+
+# Replay without verification
+npx @fluffylabs/anan-as replay-trace --no-verify trace.log
 ```

package/dist/bin/build-inline.js

@@ -0,0 +1,70 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { basename, dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const projectRoot = resolve(__dirname, "..");
+// Load asconfig.json
+const asconfigPath = resolve(projectRoot, "asconfig.json");
+const asconfig = JSON.parse(readFileSync(asconfigPath, "utf-8"));
+console.log("Building inline JS files with base64-encoded WASM...\n");
+// Process each target
+for (const [targetName, config] of Object.entries(asconfig.targets)) {
+    const wasmPath = resolve(projectRoot, config.outFile);
+    try {
+        // Read the WASM file
+        const wasmBuffer = readFileSync(wasmPath);
+        // Base64 encode
+        const wasmBase64 = wasmBuffer.toString("base64");
+        // Generate the output JS file name
+        // e.g., "build/release.wasm" -> "build/release-inline.js"
+        const wasmFileName = basename(config.outFile, ".wasm");
+        const outputPath = resolve(projectRoot, dirname(config.outFile), `${wasmFileName}-inline.js`);
+        // Create the JS content
+        const jsContent = `// Auto-generated inline WASM module
+// Target: ${targetName}
+// Source: ${config.outFile}
+
+import * as raw from './debug-raw.js';
+
+export const wasmBase64 = "${wasmBase64}";
+let compiledModulePromise = null;
+
+// Helper function to decode and instantiate the module
+export async function instantiate(imports) {
+	if (compiledModulePromise === null) {
+		compiledModulePromise = WebAssembly.compile(getWasmBytes());
+	}
+	const module = await compiledModulePromise;
+	return raw.instantiate(module, imports);
+}
+
+// Helper function to just get the bytes
+export function getWasmBytes() {
+	return Uint8Array.from(atob(wasmBase64), c => c.charCodeAt(0));
+}
+`;
+        // Write the JS file
+        writeFileSync(outputPath, jsContent, "utf-8");
+        // Generate and write the .d.ts file
+        const dtsPath = outputPath.replace(/\.js$/, ".d.ts");
+        const dtsContent = `// Auto-generated type definitions for inline WASM module
+// Target: ${targetName}
+// Source: ${config.outFile}
+
+import {__AdaptedExports} from "./debug-raw.d.ts";
+
+export const wasmBase64: string;
+
+export function instantiate(imports?: { env?: any }): Promise<typeof __AdaptedExports>;
+
+export function getWasmBytes(): Uint8Array;
+`;
+        writeFileSync(dtsPath, dtsContent, "utf-8");
+        console.log(`✓ ${targetName}: ${outputPath} (${Math.round(wasmBase64.length / 1024)} KB base64)`);
+    }
+    catch (error) {
+        console.error(`✗ ${targetName}: Failed to process ${wasmPath}`);
+        console.error(`  ${error instanceof Error ? error.message : error}`);
+    }
+}
+console.log("\nDone!");

package/dist/bin/index.js

@@ -0,0 +1,293 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import minimist from "minimist";
+import { disassemble, HasMetadata, InputKind, prepareProgram, pvmDestroy, pvmResume, pvmSetRegisters, pvmStart, } from "../build/release.js";
+import { LOG_GAS_COST, LOG_HOST_CALL_INDEX, printLogHostCall, WHAT } from "./src/log-host-call.js";
+import { STATUS } from "./src/trace-parse.js";
+import { replayTraceFile } from "./src/trace-replay.js";
+import { hexDecode, hexEncode } from "./src/utils.js";
+const HELP_TEXT = `Usage:
+  anan-as disassemble [--spi] [--no-metadata] <file.(jam|pvm|spi|bin)>
+  anan-as run [--spi] [--no-logs] [--no-metadata] [--no-log-host-call] [--pc <number>] [--gas <number>] <file.jam> [spi-args.bin or hex]
+  anan-as replay-trace [--no-metadata] [--no-verify] [--no-logs] [--no-log-host-call] <trace.log>
+
+Commands:
+  disassemble  Disassemble PVM bytecode to assembly
+  run          Execute PVM bytecode
+  replay-trace  Re-execute a ecalli IO trace
+
+Flags:
+  --spi               Treat input as JAM SPI format
+  --no-metadata       Input does not contain metadata
+  --no-logs           Disable execution logs
+  --no-log-host-call  Disable built-in handling of JIP-1 log host call (ecalli 100)
+  --no-verify         Skip verification against trace data (replay-trace only)
+  --pc <number>       Set initial program counter (default: 0)
+  --gas <number>      Set initial gas amount (default: 10_000)
+  --help, -h          Show this help message`;
+main();
+function main() {
+    const args = process.argv.slice(2);
+    // Handle global help flags
+    if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
+        console.log(HELP_TEXT);
+        return;
+    }
+    const subCommand = args[0];
+    switch (subCommand) {
+        case "disassemble":
+            handleDisassemble(args.slice(1));
+            break;
+        case "run":
+            handleRun(args.slice(1));
+            break;
+        case "replay-trace":
+            handleReplayTrace(args.slice(1));
+            break;
+        default:
+            console.error(`Error: Unknown sub-command '${subCommand}'`);
+            console.error("");
+            console.error(HELP_TEXT);
+            process.exit(1);
+    }
+}
+function handleDisassemble(args) {
+    const parsed = minimist(args, {
+        boolean: ["spi", "metadata", "help"],
+        alias: { h: "help" },
+        default: { metadata: true },
+    });
+    if (parsed.help) {
+        console.log(HELP_TEXT);
+        return;
+    }
+    const files = parsed._;
+    if (files.length === 0) {
+        console.error("Error: No file provided for disassemble command.");
+        console.error("Usage: anan-as disassemble [--spi] [--no-metadata] <file.(jam|pvm|spi|bin)>");
+        process.exit(1);
+    }
+    if (files.length > 1) {
+        console.error("Error: Only one file can be disassembled at a time.");
+        console.error("Usage: anan-as disassemble [--spi] [--no-metadata] <file.(jam|pvm|spi|bin)>");
+        process.exit(1);
+    }
+    const file = files[0];
+    // Validate file extension for disassemble command
+    const validExtensions = [".jam", ".pvm", ".spi", ".bin"];
+    const dotIndex = file.lastIndexOf(".");
+    if (dotIndex === -1) {
+        console.error(`Error: File '${file}' has no extension.`);
+        console.error("Supported extensions: .jam, .pvm, .spi, .bin");
+        process.exit(1);
+    }
+    const ext = file.substring(dotIndex);
+    if (!validExtensions.includes(ext)) {
+        console.error(`Error: Invalid file extension '${ext}' for disassemble command.`);
+        console.error("Supported extensions: .jam, .pvm, .spi, .bin");
+        process.exit(1);
+    }
+    const kind = parsed.spi ? InputKind.SPI : InputKind.Generic;
+    const hasMetadata = parsed.metadata ? HasMetadata.Yes : HasMetadata.No;
+    const f = readFileSync(file);
+    const name = kind === InputKind.Generic ? "generic PVM" : "JAM SPI";
+    console.log(`🤖 Assembly of ${file} (as ${name})`);
+    console.log(disassemble(Array.from(f), kind, hasMetadata));
+}
+function handleRun(args) {
+    const parsed = minimist(args, {
+        boolean: ["spi", "logs", "metadata", "help", "log-host-call"],
+        /** Prevents parsing hex values as numbers. */
+        string: ["pc", "gas", "_"],
+        alias: { h: "help" },
+        default: { metadata: true, logs: true, "log-host-call": true },
+    });
+    if (parsed.help) {
+        console.log(HELP_TEXT);
+        return;
+    }
+    const files = parsed._;
+    if (files.length === 0) {
+        console.error("Error: No file provided for run command.");
+        console.error("Usage: anan-as run [--spi] [--no-logs] [--no-metadata] [--pc <number>] [--gas <number>] <file.jam> [spi-args.bin]");
+        process.exit(1);
+    }
+    const kind = parsed.spi ? InputKind.SPI : InputKind.Generic;
+    let programFile;
+    let spiArgsStr;
+    if (kind === InputKind.SPI) {
+        // For SPI programs, expect: <program.spi> [spi-args.bin or hex]
+        if (files.length > 2) {
+            console.error("Error: Too many arguments for SPI run command.");
+            console.error("Usage: anan-as run --spi [--no-logs] [--no-metadata] [--pc <number>] [--gas <number>] <program.spi> [spi-args.bin or hex]");
+            process.exit(1);
+        }
+        programFile = files[0];
+        spiArgsStr = files[1]; // optional
+    }
+    else {
+        // For generic programs, expect exactly one file
+        if (files.length > 1) {
+            console.error("Error: Only one file can be run at a time.");
+            console.error("Usage: anan-as run [--no-logs] [--no-metadata] [--pc <number>] [--gas <number>] <file.jam>");
+            process.exit(1);
+        }
+        programFile = files[0];
+    }
+    // Validate SPI args file if provided
+    const spiArgs = parseSpiArgs(spiArgsStr);
+    const logs = parsed.logs;
+    const logHostCall = parsed["log-host-call"];
+    const hasMetadata = parsed.metadata ? HasMetadata.Yes : HasMetadata.No;
+    // Parse and validate PC and gas options
+    const initialPc = parsePc(parsed);
+    const initialGas = parseGas(parsed);
+    const programCode = Array.from(readFileSync(programFile));
+    const name = kind === InputKind.Generic ? "generic PVM" : "JAM SPI";
+    console.log(`🚀 Running ${programFile} (as ${name})`);
+    try {
+        const preallocateMemoryPages = 128;
+        const program = prepareProgram(kind, hasMetadata, programCode, [], [], [], spiArgs, preallocateMemoryPages);
+        const id = pvmStart(program, false);
+        let gas = initialGas;
+        let pc = initialPc;
+        for (;;) {
+            const pause = pvmResume(id, gas, pc, logs);
+            if (!pause) {
+                throw new Error("pvmResume returned null");
+            }
+            if (pause.status === STATUS.HOST && pause.exitCode === LOG_HOST_CALL_INDEX && logHostCall) {
+                printLogHostCall(id, pause.registers);
+                // Set r7 = WHAT
+                const regs = pause.registers;
+                regs[7] = WHAT;
+                pvmSetRegisters(id, regs);
+                // Deduct gas and advance PC
+                gas = pause.gas >= LOG_GAS_COST ? pause.gas - LOG_GAS_COST : 0n;
+                pc = pause.nextPc;
+            }
+            else {
+                console.warn(`Unhandled host call: ecalli ${pause.exitCode}. Finishing.`);
+                break;
+            }
+        }
+        const result = pvmDestroy(id);
+        console.log(`Status: ${result?.status}`);
+        console.log(`Exit code: ${result?.exitCode}`);
+        console.log(`Program counter: ${result?.pc}`);
+        console.log(`Gas remaining: ${result?.gas}`);
+        console.log(`Registers: [${result?.registers.join(", ")}]`);
+        console.log(`Result: [${hexEncode(result?.result ?? [])}]`);
+    }
+    catch (error) {
+        console.error(`Error running ${programFile}:`, error);
+        process.exit(1);
+    }
+}
+function handleReplayTrace(args) {
+    const parsed = minimist(args, {
+        boolean: ["metadata", "verify", "logs", "help", "log-host-call"],
+        alias: { h: "help" },
+        default: { metadata: true, logs: true, verify: true, "log-host-call": true },
+    });
+    if (parsed.help) {
+        console.log(HELP_TEXT);
+        return;
+    }
+    const files = parsed._;
+    if (files.length === 0) {
+        console.error("Error: No trace file provided for replay-trace command.");
+        console.error("Usage: anan-as replay-trace [--no-metadata] [--no-verify] [--no-logs] <trace.log>");
+        process.exit(1);
+    }
+    if (files.length > 1) {
+        console.error("Error: Only one trace file can be replayed at a time.");
+        console.error("Usage: anan-as replay-trace [--no-metadata] [--no-verify] [--no-logs] <trace.log>");
+        process.exit(1);
+    }
+    const file = files[0];
+    const hasMetadata = parsed.metadata ? HasMetadata.Yes : HasMetadata.No;
+    const verify = parsed.verify;
+    const logs = parsed.logs;
+    const logHostCall = parsed["log-host-call"];
+    try {
+        const summary = replayTraceFile(file, {
+            logs,
+            hasMetadata,
+            verify,
+            logHostCall,
+        });
+        console.log(`✅ Replay complete: ${summary.ecalliCount} ecalli entries`);
+        console.log(`Status: ${summary.termination.type}`);
+        console.log(`Program counter: ${summary.termination.pc}`);
+        console.log(`Gas remaining: ${summary.termination.gas}`);
+    }
+    catch (error) {
+        console.error(`Error replaying trace ${file}:`, error);
+        process.exit(1);
+    }
+}
+function parseGas(parsed) {
+    if (parsed.gas === undefined) {
+        return BigInt(10_000);
+    }
+    // Ensure it's a string/number, not boolean
+    if (typeof parsed.gas === "boolean") {
+        console.error("Error: --gas requires a value.");
+        process.exit(1);
+    }
+    const gasStr = String(parsed.gas);
+    // Reject floats and non-integer strings
+    if (gasStr.includes(".") || !/^-?\d+$/.test(gasStr)) {
+        console.error("Error: --gas must be a valid integer.");
+        process.exit(1);
+    }
+    let gasValue;
+    try {
+        gasValue = BigInt(gasStr);
+    }
+    catch (_e) {
+        console.error("Error: --gas must be a valid integer.");
+        process.exit(1);
+    }
+    const MAX_I64 = (1n << 63n) - 1n;
+    if (gasValue < 0n || gasValue > MAX_I64) {
+        console.error("Error: --gas must be a non-negative integer <= 2^63-1.");
+        process.exit(1);
+    }
+    return gasValue;
+}
+function parseSpiArgs(spiArgsStr) {
+    if (!spiArgsStr) {
+        return [];
+    }
+    try {
+        return Array.from(hexDecode(spiArgsStr));
+    }
+    catch (e) {
+        console.log(`Attempting to read ${spiArgsStr} as a file, since it's not a hex value: ${e}`);
+        return Array.from(readFileSync(spiArgsStr));
+    }
+}
+function parsePc(parsed) {
+    if (parsed.pc === undefined) {
+        return 0;
+    }
+    // Ensure it's a string/number, not boolean
+    if (typeof parsed.pc === "boolean") {
+        console.error("Error: --pc requires a value.");
+        process.exit(1);
+    }
+    const pcStr = String(parsed.pc);
+    // Reject floats and non-integer strings
+    if (pcStr.includes(".") || !/^-?\d+$/.test(pcStr)) {
+        console.error("Error: --pc must be a valid integer.");
+        process.exit(1);
+    }
+    const pcValue = parseInt(pcStr, 10);
+    if (!Number.isInteger(pcValue) || pcValue < 0 || pcValue > 0xffffffff) {
+        console.error("Error: --pc must be a non-negative integer <= 2^32-1.");
+        process.exit(1);
+    }
+    return pcValue;
+}

package/dist/bin/src/fuzz.js

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+import "json-bigint-patch";
+import fs from "node:fs";
+import { tryAsGas } from "@typeberry/lib/pvm-interface";
+import { Interpreter } from "@typeberry/lib/pvm-interpreter";
+import { disassemble, HasMetadata, InputKind, prepareProgram, runProgram, wrapAsProgram } from "../../build/release.js";
+const runNumber = 0;
+export function fuzz(data) {
+    const gas = 200n;
+    const pc = 0;
+    const vm = new Interpreter();
+    const program = wrapAsProgram(new Uint8Array(data));
+    if (program.length > 100) {
+        return;
+    }
+    try {
+        vm.resetGeneric(program, pc, tryAsGas(gas));
+        vm.runProgram();
+        const printDebugInfo = false;
+        const registers = Array(13)
+            .join(",")
+            .split(",")
+            .map(() => BigInt(0));
+        const exe = prepareProgram(InputKind.Generic, HasMetadata.No, Array.from(program), registers, [], [], [], 0);
+        const output = runProgram(exe, gas, pc, printDebugInfo);
+        const vmRegisters = decodeRegistersFromTypeberry(vm);
+        collectErrors((assertFn) => {
+            assertFn(normalizeStatus(vm.getStatus()), normalizeStatus(output.status), "status");
+            assertFn(vm.gas.get(), output.gas, "gas");
+            assertFn(vmRegisters, output.registers, "registers");
+            assertFn(vm.getPC(), output.pc, "pc");
+        });
+        try {
+            if (runNumber % 100000 === 0) {
+                writeTestCase(program, {
+                    pc,
+                    gas,
+                    registers,
+                }, {
+                    status: normalizeStatus(vm.getStatus()),
+                    gasLeft: vm.gas.get(),
+                    pc: vm.getPC(),
+                    registers: vmRegisters,
+                });
+            }
+        }
+        catch (e) {
+            console.warn("Unable to write file", e);
+        }
+    }
+    catch (e) {
+        const hex = programHex(program);
+        console.log(program);
+        console.log(linkTo(hex));
+        console.log(disassemble(Array.from(program), InputKind.Generic, HasMetadata.No));
+        throw e;
+    }
+}
+import { hexEncode } from "./utils.js";
+function programHex(program) {
+    return hexEncode(program, false);
+}
+function linkTo(programHex) {
+    return `https://pvm.fluffylabs.dev/?program=0x${programHex}#/`;
+}
+function decodeRegistersFromTypeberry(vm) {
+    const registers = [];
+    // Try to get up to 13 registers (common register count)
+    for (let i = 0; i < 13; i++) {
+        try {
+            registers.push(vm.registers.getU64(i));
+        }
+        catch (_e) {
+            // If we can't get a register, break
+            break;
+        }
+    }
+    return registers;
+}
+function normalizeStatus(status) {
+    if (status === 2) {
+        return 1;
+    }
+    return status;
+}
+function assert(tb, an, comment = "") {
+    let condition = tb !== an;
+    if (Array.isArray(tb) && Array.isArray(an)) {
+        condition = tb.toString() !== an.toString();
+    }
+    if (condition) {
+        const alsoAsHex = (f) => {
+            if (Array.isArray(f)) {
+                return `${f.map(alsoAsHex).join(", ")}`;
+            }
+            if (typeof f === "number" || typeof f === "bigint") {
+                if (BigInt(f) !== 0n) {
+                    return `${f} | 0x${f.toString(16)}`;
+                }
+                return `${f}`;
+            }
+            return f;
+        };
+        throw new Error(`Diverging value: ${comment}
+\t(typeberry) ${alsoAsHex(tb)}
+\t(ananas)    ${alsoAsHex(an)}`);
+    }
+}
+function collectErrors(cb) {
+    const errors = [];
+    cb((tb, an, comment = "") => {
+        try {
+            assert(tb, an, comment);
+        }
+        catch (e) {
+            errors.push(`${e}`);
+        }
+    });
+    if (errors.length > 0) {
+        throw new Error(errors.join("\n"));
+    }
+}
+function writeTestCase(program, initial, expected) {
+    const hex = programHex(program);
+    fs.mkdirSync(`../tests/length_${hex.length}`, { recursive: true });
+    fs.writeFileSync(`../tests/length_${hex.length}/${hex}.json`, JSON.stringify({
+        name: linkTo(hex),
+        "initial-regs": initial.registers,
+        "initial-pc": initial.pc,
+        "initial-page-map": [],
+        "initial-memory": [],
+        "initial-gas": initial.gas,
+        program: Array.from(program),
+        "expected-status": statusToStr(expected.status),
+        "expected-regs": Array.from(expected.registers),
+        "expected-pc": expected.pc,
+        "expected-gas": expected.gasLeft,
+        "expected-memory": [],
+    }));
+}
+function statusToStr(status) {
+    if (status === 0) {
+        return "halt";
+    }
+    if (status === 1) {
+        return "trap";
+    }
+    if (status === 4) {
+        return "oog";
+    }
+    if (status === 3) {
+        return "host";
+    }
+    throw new Error(`unexpected status: ${status}`);
+}