@fraczak/k 7.0.1 → 7.1.0

package/tests/test-polymorphic-tdd.mjs

@@ -0,0 +1,196 @@
+import assert from "node:assert/strict";
+import { createState, evaluateInput } from "../backend-api.mjs";
+
+console.log("==> Running Polymorphic TDD Suite (tests/test-polymorphic-tdd.mjs)");
+
+const state = createState();
+
+async function evalK(snippet) {
+  const res = await evaluateInput(snippet, state);
+  assert.ok(
+    res && res.length > 0 && !res[0].includes("undefined"),
+    `Evaluation failed for snippet:\n${snippet}`
+  );
+  const raw = res[0];
+  const splitIdx = raw.indexOf(" ?");
+  const val = splitIdx !== -1 ? raw.slice(0, splitIdx) : raw;
+  const type = splitIdx !== -1 ? raw.slice(splitIdx + 1) : "";
+  return { val, type, raw };
+}
+
+// --------------------------------------------------------------------
+// Test 1: Search - Homogeneous List with Opaque Fields
+// --------------------------------------------------------------------
+{
+  console.log("--> Test 1: Search on Homogeneous List with Opaque Fields");
+  const script = `
+    search = {()list, {}|nil result} search_; 
+    search_ = ?{X list, X result} 
+    < 
+      {.list/nil if, .result then}.then, 
+      < 
+        {.list/cons.car.flag/true if, {.list/cons.cdr list, {.list/cons.car car, .result cdr}|cons result} then} .then,
+        {.list/cons.cdr list, .result result}
+      > search_
+    >;
+
+    i1 = {{}|alpha id, {}|true flag, {}|payload_a payload};
+    i2 = {{}|beta id, {}|false flag, {}|payload_b payload};
+    i3 = {{}|gamma id, {}|true flag, {}|payload_c payload};
+
+    l_homo = {i1 car, {i2 car, {i3 car, {}|nil cdr}|cons cdr}|cons cdr}|cons;
+    l_homo search
+  `;
+
+  const out = await evalK(script);
+  // Expect i3 followed by i1 (accumulator reverses order); i2 is excluded
+  assert.match(out.val, /gamma/);
+  assert.match(out.val, /alpha/);
+  assert.doesNotMatch(out.val, /beta/);
+  // Check opaque fields are intact
+  assert.match(out.val, /payload_c/);
+  assert.match(out.val, /payload_a/);
+  console.log("    Passed: Homogeneous list filtered with opaque payload preserved.");
+}
+
+// --------------------------------------------------------------------
+// Test 2: Search - Pathological Field Ordering & Disparate Field Schemas
+// --------------------------------------------------------------------
+{
+  console.log("--> Test 2: Search with Out-of-Order Fields & Disparate Value Types");
+  const script = `
+    p1 = {{}|large_blob data, {}|true flag, {}|first id};
+    p2 = {{}|false flag, {}|second id, {}|medium_blob data};
+    p3 = {{}|third id, {}|tiny_blob data, {}|true flag};
+
+    l_reorder = {p1 car, {p2 car, {p3 car, {}|nil cdr}|cons cdr}|cons cdr}|cons;
+    l_reorder search
+  `;
+
+  const out = await evalK(script);
+  // Expect p3 matching first, then p1 matching; p2 excluded
+  assert.match(out.val, /third/);
+  assert.match(out.val, /tiny_blob/);
+  assert.match(out.val, /first/);
+  assert.match(out.val, /large_blob/);
+  assert.doesNotMatch(out.val, /second/);
+  assert.doesNotMatch(out.val, /medium_blob/);
+  console.log("    Passed: Out-of-order fields & disparate value types preserved.");
+}
+
+// --------------------------------------------------------------------
+// Test 3: Search - Boundary Cases (Empty List, All Match, None Match)
+// --------------------------------------------------------------------
+{
+  console.log("--> Test 3: Search Boundary Cases (Empty, None Match, All Match)");
+
+  // 3a: Empty list
+  const outEmpty = await evalK(`{}|nil search`);
+  assert.match(outEmpty.val, /nil/);
+
+  // 3b: None match (all flag: false)
+  const outNone = await evalK(`
+    n1 = {{}|f1 id, {}|false flag};
+    n2 = {{}|f2 id, {}|false flag};
+    l_none = {n1 car, {n2 car, {}|nil cdr}|cons cdr}|cons;
+    l_none search
+  `);
+  assert.match(outNone.val, /nil/);
+
+  // 3c: All match (all flag: true)
+  const outAll = await evalK(`
+    m1 = {{}|t1 id, {}|true flag};
+    m2 = {{}|t2 id, {}|true flag};
+    l_all = {m1 car, {m2 car, {}|nil cdr}|cons cdr}|cons;
+    l_all search
+  `);
+  assert.match(outAll.val, /t2.*t1/);
+  console.log("    Passed: Boundary cases handled cleanly.");
+}
+
+// --------------------------------------------------------------------
+// Test 4: Multi-Variant Dispatch with Varying Offsets (extract_id)
+// --------------------------------------------------------------------
+{
+  console.log("--> Test 4: Multi-Variant Dispatch with Varying Offsets");
+  const script = `
+    extract_id = <
+      /click.id,
+      /sensor.id,
+      /ping.id
+    >;
+
+    evt_c = {{}|evt_click id, {}|active status}|click;
+    evt_s = {{}|battery_low status, {}|evt_sensor id, {}|reading data}|sensor;
+    evt_p = {{}|evt_ping id}|ping;
+  `;
+  await evalK(script);
+
+  const outC = await evalK("evt_c extract_id");
+  assert.match(outC.val, /evt_click/);
+
+  const outS = await evalK("evt_s extract_id");
+  assert.match(outS.val, /evt_sensor/);
+
+  const outP = await evalK("evt_p extract_id");
+  assert.match(outP.val, /evt_ping/);
+  console.log("    Passed: Common field extracted across variants with distinct layouts.");
+}
+
+// --------------------------------------------------------------------
+// Test 5: Polymorphic Zip - Concurrency of Two Independent Types
+// --------------------------------------------------------------------
+{
+  console.log("--> Test 5: Polymorphic Zip across Independent Types");
+  const script = `
+    zip = <
+      {.xs /nil if, {}|nil then} .then,
+      {.ys /nil if, {}|nil then} .then,
+      {
+        {.xs/cons.car x, .ys/cons.car y} car,
+        {.xs/cons.cdr xs, .ys/cons.cdr ys} zip cdr
+      }|cons
+    >;
+
+    xs = {{}|num1 car, {{}|num2 car, {}|nil cdr}|cons cdr}|cons;
+    ys = {
+      {{}|rec1_name name, {}|flag_true flag} car,
+      {{{}|rec2_name name, {}|flag_false flag} car, {}|nil cdr}|cons cdr
+    }|cons;
+
+    {xs xs, ys ys} zip
+  `;
+
+  const out = await evalK(script);
+  assert.match(out.val, /num1.*rec1_name/);
+  assert.match(out.val, /num2.*rec2_name/);
+  console.log("    Passed: Independent polymorphic streams paired into product.");
+}
+
+// --------------------------------------------------------------------
+// Test 6: Polymorphic Reverse with Opaque Records
+// --------------------------------------------------------------------
+{
+  console.log("--> Test 6: Polymorphic Reverse with Opaque Records");
+  const script = `
+    poly_rev = {()xs, {}|nil acc} _poly_rev;
+    _poly_rev = ?{X xs, X acc} <
+      {.xs/nil if, .acc then} .then,
+      {.xs/cons.cdr xs, {.xs/cons.car car, .acc cdr}|cons acc} _poly_rev
+    >;
+
+    r1 = {{}|first item, {}|opaque_1 extra};
+    r2 = {{}|second item, {}|opaque_2 extra};
+    r3 = {{}|third item, {}|opaque_3 extra};
+    list_to_rev = {r1 car, {r2 car, {r3 car, {}|nil cdr}|cons cdr}|cons cdr}|cons;
+
+    list_to_rev poly_rev
+  `;
+
+  const out = await evalK(script);
+  assert.match(out.val, /third.*second.*first/);
+  assert.match(out.val, /opaque_3.*opaque_2.*opaque_1/);
+  console.log("    Passed: Polymorphic list reversed with opaque record payloads intact.");
+}
+
+console.log("\n==> All Polymorphic TDD Tests Passed Successfully!");

package/tests/test-repl-html.mjs

@@ -622,9 +622,12 @@ if (chromiumBin) {
     assert.strictEqual(narrowNavbarCheck.hasTiming, false, "Help modal should not contain :timing");
     assert.strictEqual(narrowNavbarCheck.hasCodecDefine, false, "Help modal should not contain :codec define");
 
-    // 6. Test dual engine switching in browser (wasm <-> js)
+    // 6. Test 3-way engine switching in browser (wasm -> pkir -> js)
     const engineCheck = await evaluateAsync(`(async () => {
       const initialEngine = window.kRepl.getEngine();
+      await window.kRepl.executeCommand(":engine pkir");
+      const pkirEngine = window.kRepl.getEngine();
+      const badgePkirText = document.getElementById("engine-badge")?.textContent;
       await window.kRepl.executeCommand(":engine js");
       const jsEngine = window.kRepl.getEngine();
       const badgeJsText = document.getElementById("engine-badge")?.textContent;
@@ -632,9 +635,19 @@ if (chromiumBin) {
       await window.kRepl.executeCommand(":engine wasm");
       const wasmEngine = window.kRepl.getEngine();
       const badgeWasmText = document.getElementById("engine-badge")?.textContent;
-      return { initialEngine, jsEngine, wasmEngine, badgeJsText, badgeWasmText };
+      return {
+        initialEngine,
+        pkirEngine,
+        jsEngine,
+        wasmEngine,
+        badgePkirText,
+        badgeJsText,
+        badgeWasmText
+      };
     })()`);
     assert.strictEqual(engineCheck.initialEngine, "wasm");
+    assert.strictEqual(engineCheck.pkirEngine, "pkir");
+    assert.strictEqual(engineCheck.badgePkirText, "pkir-wasm");
     assert.strictEqual(engineCheck.jsEngine, "js");
     assert.strictEqual(engineCheck.badgeJsText, "js-in-process");
     assert.strictEqual(engineCheck.wasmEngine, "wasm");

package/tests/test-repl.mjs

@@ -471,6 +471,10 @@ output = await evaluateInput(":wasm", timingState);
 assert.equal(output[0], "engine set to wasm");
 assert.equal(timingState.engine, "wasm");
 
+output = await evaluateInput(":pkir", timingState);
+assert.equal(output[0], "engine set to pkir");
+assert.equal(timingState.engine, "pkir");
+
 output = await evaluateInput(":js", timingState);
 assert.equal(output[0], "engine set to js");
 assert.equal(timingState.engine, "js");
@@ -483,12 +487,13 @@ assert.equal(timingState.engine, "js");
 // Verify invalid engine error
 await assert.rejects(
   () => evaluateInput(":engine invalid", timingState),
-  /Invalid engine 'invalid'\. Valid engines: wasm, js/
+  /Invalid engine 'invalid'\. Valid engines: wasm, pkir, js/
 );
 
 // Verify autocompletion for :engine
 completions = completeInput(":engine ", timingState)[0];
 assert(completions.includes(":engine wasm"));
+assert(completions.includes(":engine pkir"));
 assert(completions.includes(":engine js"));
 
 // Verify evaluating expressions in JS engine
@@ -509,6 +514,30 @@ output = await evaluateInput("{ 10 int x, 5 int y } plus", jsState);
 assert.match(output[0], /^\{\}\|_\|1\|1\|1\|1\|\+/);
 assert.match(output[1], /\(js\)/);
 
+// Verify evaluating expressions in PKIR-powered Wasm engine
+const pkirState = createState({ engine: "pkir" });
+assert.equal(pkirState.engine, "pkir");
+
+output = await evaluateInput(
+  "succ = | succ;\n{} | zero succ succ",
+  pkirState
+);
+assert.match(output[0], /^\{\}\|zero\|succ\|succ/);
+assert.match(output[1], /\(pkir\)/);
+
+output = await evaluateInput(
+  "not = </true | false, /false | true >;\n{} | true not",
+  pkirState
+);
+assert.match(output[0], /^\{\}\|false/);
+assert.match(output[1], /\(pkir\)/);
+
+output = await evaluateInput(":load Examples/arithmetics.k", pkirState);
+assert.equal(output[0], "loaded Examples/arithmetics.k");
+output = await evaluateInput("{ 10 int x, 5 int y } plus", pkirState);
+assert.match(output[0], /^\{\}\|_\|1\|1\|1\|1\|\+/);
+assert.match(output[1], /\(pkir\)/);
+
 // Verify open product projection in wasm engine
 const wasmListState = createState({ engine: "wasm" });
 await evaluateInput(":load Examples/arithmetics.k", wasmListState);

package/backends/arm64/README.md

@@ -1,103 +0,0 @@
-# k Linux ARM64 Backend
-
-`@fraczak/k-arm64` is the native Linux AArch64 (ARM64) backend for
-[`@fraczak/k`](https://github.com/fraczak/k). It lowers typed k programs directly from
-the kVM representation into GNU AArch64 assembly text (`.s`), compiles native ELF
-executables, and provides CLI tools and runners for binary `pattern + value` streams
-and `--json` input/output.
-
-## Features
-
-- **Direct kVM to ARM64 Lowering**: Generates pure GNU AArch64 assembly text without requiring LLVM or external code generators.
-- **Calling Convention & Registers (AAPCS64)**:
-  - `x0`: Input value pointer on entry; Return status (`0` for success, non-zero for failure) on exit.
-  - `x1`: Output value pointer on exit.
-  - `x19`: Callee-saved Arena bump pointer preserved and updated across relation calls.
-  - Standard 16-byte stack frame alignment with FP (`x29`) and LR (`x30`) chaining.
-- **Flat Arena Memory Representation**:
-  - Word 0 (bytes 0–1): Total block size in bytes (16-byte aligned).
-  - Word 1 (bytes 2–3): Value kind (`1` = Product, `2` = Variant).
-  - Word 2 (bytes 4–7): Product field count OR Variant 32-bit tag ID.
-  - Payloads (bytes 8+): 64-bit pointers to child values in the arena.
-- **Self Tail-Call Optimization (TCO)**:
-  - Recursion where the tail call passes new product fields directly updates cached field slots and jumps back to `.Ltail_loop` with zero frame overhead, enabling deep recursion without stack overflow.
-- **Union Backtracking & Memory Rollback**:
-  - Union branches save the arena bump pointer (`x19`) before evaluation. If a branch fails, `x19` is rewound to cleanly roll back all allocations made in the failed speculative branch before attempting subsequent branches.
-- **Standalone Linux Binaries**:
-  - Links with a lightweight C driver (`backends/arm64/src/runtime.c`) and `backends/llvm/runtime/krt.c` to produce independent native ELF executables that execute directly on Linux without Node.js.
-  - Supports `--json` for direct text output, stdin/stdout piping, and binary envelope streams.
-
-## Quick Start
-
-Compile an expression to a standalone native Linux ARM64 executable:
-
-```bash
-node ./backends/arm64/bin/k-arm64-compile.mjs -o /tmp/ok '|ok'
-```
-
-Execute it over unit input and decode output:
-
-```bash
-node ./codecs/unit.mjs --parse | /tmp/ok --json
-```
-
-Output:
-```json
-"ok"
-```
-
-Compile with library dependencies (`--lib` and `--export`):
-
-```bash
-node ./backends/arm64/bin/k-arm64-compile.mjs \
-  --lib Examples/arithmetics.k \
-  --export plus:+ --export succ --export int \
-  '{succ int x,int y}+' \
-  -o /tmp/add-one
-
-node ./codecs/k-parse.mjs <<< '{"x":{"succ":"zero"},"y":{"succ":{"succ":"zero"}}}' |
-  /tmp/add-one --json
-```
-
-Output:
-```json
-{"+":{"1":"_"}}
-```
-
-## CLI Commands
-
-| Command | Purpose |
-| --- | --- |
-| `k-arm64` | Compile k source, `.ko`, or `.kvm` in memory and run immediately |
-| `k-arm64-compile` | Compile k source, `.ko`, or `.kvm` to standalone ELF executable or assembly (`-S`) |
-| `k-arm64-run` | Run a compiled ELF executable over binary wire streams |
-
-### Options
-
-All tools accept `--help`.
-
-- `-S, --assembly`: Emit GNU ARM64 assembly text (`.s`) instead of an ELF binary.
-- `-o, --output <file>`: Specify the output file path.
-- `--lib <file>`: Load one `.klib` or `.k` library dependency.
-- `--export <spec>`: Export library symbols into source scope (`name` or `libname:localname`).
-- `--json`: Format output as JSON instead of binary wire format.
-
-## Running Tests
-
-Run unit tests:
-
-```bash
-node ./backends/arm64/tests/test-arm64.mjs
-```
-
-Run integration tests:
-
-```bash
-./backends/arm64/tests/integration.sh
-```
-
-Run the complete ARM64 backend test suite:
-
-```bash
-npm run test:arm64
-```

package/backends/arm64/bin/k-arm64-compile.mjs

@@ -1,93 +0,0 @@
-#!/usr/bin/env node
-
-import fs from "node:fs";
-import { argv, exit, stdin, stdout } from "node:process";
-
-import {
-  compileProgramInput,
-  parseCompileOptions,
-  resolveProgramInput
-} from "../src/cli.mjs";
-
-function usage(stream = console.error) {
-  const prog = argv[1] || "k-arm64-compile.mjs";
-  stream(`Usage: node ${prog} [options] [source-snippet | input-file [output-file]]`);
-  stream("Compile k source, .ko, or .kvm input into a standalone Linux ARM64 executable or assembly.");
-  stream("");
-  stream("Arguments:");
-  stream("  source-snippet  Inline k source, in the same style as k.mjs.");
-  stream("  input-file      Source .k, .ko, or .kvm file. Reads UTF-8 source from stdin when omitted.");
-  stream("  output-file     Output file path. Writes to stdout when omitted and --assembly is set.");
-  stream("");
-  stream("Options:");
-  stream("  -S, --assembly   Emit GNU ARM64 assembly (.s) instead of an executable binary.");
-  stream("  -o, --output     Specify output file path explicitly.");
-  stream("  --lib file       Load one .klib dependency before compiling.");
-  stream("  --export spec    Export a library alias into source scope. May be repeated.");
-  stream("                   spec is 'name' or 'libname:localname'.");
-  stream("  -h, --help       Show this help.");
-}
-
-try {
-  const args = argv.slice(2);
-  if (args.includes("-h") || args.includes("--help")) {
-    usage(console.log);
-    exit(0);
-  }
-
-  let emitAssembly = false;
-  let explicitOutput = null;
-  // Extract ARM64-specific flags
-  const remainingArgs = [];
-  while (args.length > 0) {
-    const arg = args[0];
-    if (arg === "-S" || arg === "--assembly") {
-      emitAssembly = true;
-      args.shift();
-    } else if (arg === "-o" || arg === "--output") {
-      args.shift();
-      explicitOutput = args.shift();
-      if (!explicitOutput) throw new Error("-o/--output requires a file argument");
-    } else {
-      remainingArgs.push(args.shift());
-    }
-  }
-
-  const { libraries, exportSpecs } = parseCompileOptions(remainingArgs);
-  const input = resolveProgramInput(remainingArgs, { allowStdinSource: true });
-  const positionalOutput = remainingArgs.shift();
-  if (remainingArgs.length > 0) throw new Error("Too many arguments");
-
-  const outputPath = explicitOutput || positionalOutput || null;
-
-  const result = await compileProgramInput(input, {
-    libraries,
-    exportSpecs,
-    stdin,
-    emit: emitAssembly ? "assembly" : null,
-    outputPath: (!emitAssembly && outputPath) ? outputPath : null
-  });
-
-  if (emitAssembly) {
-    const asmText = typeof result === "string" ? result : result.assembly;
-    if (outputPath == null) {
-      stdout.write(asmText);
-    } else {
-      fs.writeFileSync(outputPath, asmText, "utf8");
-    }
-  } else {
-    if (outputPath == null) {
-      if (Buffer.isBuffer(result)) {
-        stdout.write(result);
-      } else if (typeof result === "string") {
-        stdout.write(fs.readFileSync(result));
-      }
-    } else if (Buffer.isBuffer(result)) {
-      fs.writeFileSync(outputPath, result, { mode: 0o755 });
-    }
-  }
-} catch (error) {
-  console.error(error.stack || error.message || String(error));
-  usage();
-  exit(1);
-}

package/backends/arm64/bin/k-arm64-run.mjs

@@ -1,58 +0,0 @@
-#!/usr/bin/env node
-
-import fs from "node:fs";
-import { argv, exit, stdin, stdout } from "node:process";
-
-import { readAll } from "../src/cli.mjs";
-import { runARM64Artifact } from "../src/arm64.mjs";
-
-function usage(stream = console.error) {
-  const prog = argv[1] || "k-arm64-run.mjs";
-  stream(`Usage: node ${prog} [options] executable-file [input-file]`);
-  stream("Run a standalone k Linux ARM64 executable over a binary wire stream.");
-  stream("");
-  stream("Arguments:");
-  stream("  executable-file  Input compiled ELF binary produced by k-arm64-compile.");
-  stream("  input-file       Optional binary input wire file. Reads stdin when omitted.");
-  stream("");
-  stream("Options:");
-  stream("  --json           Format output as JSON instead of binary wire format.");
-  stream("  -h, --help       Show this help.");
-}
-
-async function main() {
-  const args = argv.slice(2);
-  if (args.includes("-h") || args.includes("--help")) {
-    usage(console.log);
-    return;
-  }
-
-  let json = false;
-  const filteredArgs = [];
-  for (const arg of args) {
-    if (arg === "--json") {
-      json = true;
-    } else {
-      filteredArgs.push(arg);
-    }
-  }
-
-  const execPath = filteredArgs.shift();
-  if (!execPath) throw new Error("Missing executable artifact path");
-  const inputPath = filteredArgs.shift();
-  if (filteredArgs.length > 0) throw new Error("Too many arguments");
-
-  const input = await readAll(inputPath == null ? stdin : fs.createReadStream(inputPath));
-  const result = runARM64Artifact(execPath, input, { json });
-  if (json) {
-    stdout.write(result);
-  } else {
-    stdout.write(result);
-  }
-}
-
-main().catch((error) => {
-  console.error(error.stack || error.message || String(error));
-  usage();
-  exit(1);
-});

package/backends/arm64/bin/k-arm64.mjs

@@ -1,88 +0,0 @@
-#!/usr/bin/env node
-
-import fs from "node:fs";
-import { argv, exit, stdin, stdout } from "node:process";
-import { decodeWire } from "../../../backend-api.mjs";
-
-import {
-  compileProgramInput,
-  parseCompileOptions,
-  readAll,
-  resolveProgramInput
-} from "../src/cli.mjs";
-import { runARM64Artifact } from "../src/arm64.mjs";
-
-function usage(stream = console.error) {
-  const prog = argv[1] || "k-arm64.mjs";
-  stream(`Usage: node ${prog} [options] ( source-snippet | input-file ) [ input-file ]`);
-  stream("Compile k source, .ko, or .kvm input to ARM64 in memory and run it over a binary pattern+value stream.");
-  stream("");
-  stream("Options:");
-  stream("  --json           Format output as JSON instead of binary wire format.");
-  stream("  --entry name     Specify entry relation name.");
-  stream("  --lib file       Load one .klib dependency before compiling.");
-  stream("  --export spec    Export a library alias into source scope. May be repeated.");
-  stream("                   spec is 'name' or 'libname:localname'.");
-  stream("  -h, --help       Show this help.");
-}
-
-async function main() {
-  const args = argv.slice(2);
-  if (args.includes("-h") || args.includes("--help")) {
-    usage(console.log);
-    return;
-  }
-
-  let json = false;
-  let entry = null;
-  const remainingArgs = [];
-  while (args.length > 0) {
-    const arg = args[0];
-    if (arg === "--json") {
-      json = true;
-      args.shift();
-    } else if (arg === "--entry") {
-      args.shift();
-      entry = args.shift();
-      if (!entry) throw new Error("--entry requires a name argument");
-    } else {
-      remainingArgs.push(args.shift());
-    }
-  }
-
-  const { libraries, exportSpecs } = parseCompileOptions(remainingArgs);
-  const programInput = resolveProgramInput(remainingArgs);
-  const inputPath = remainingArgs.shift();
-  if (remainingArgs.length > 0) throw new Error("Too many arguments");
-
-  const inputBuffer = await readAll(inputPath == null ? stdin : fs.createReadStream(inputPath));
-  let inputEnvelopePattern = null;
-  if (inputBuffer.length > 0) {
-    try {
-      const decoded = decodeWire(inputBuffer);
-      inputEnvelopePattern = decoded.pattern;
-    } catch {
-      // Not a valid wire buffer or empty
-    }
-  }
-
-  const artifact = await compileProgramInput(programInput, {
-    libraries,
-    exportSpecs,
-    inputEnvelopePattern,
-    entry
-  });
-
-  const output = runARM64Artifact(artifact, inputBuffer, { json });
-  if (json) {
-    stdout.write(output);
-  } else {
-    stdout.write(output);
-  }
-}
-
-main().catch((error) => {
-  console.error(error.stack || error.message || String(error));
-  usage();
-  exit(1);
-});

package/backends/arm64/scripts/run-tests.mjs

@@ -1,57 +0,0 @@
-#!/usr/bin/env node
-
-import path from "node:path";
-import { spawnSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
-
-const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-const node = process.execPath;
-
-function printHelp() {
-  console.log(`Usage: node backends/arm64/scripts/run-tests.mjs [options]
-
-Runs ARM64 backend test suite and integration tests.
-
-Options:
-  -h, --help
-      Show this help message and exit.`);
-}
-
-if (process.argv.includes("-h") || process.argv.includes("--help")) {
-  printHelp();
-  process.exit(0);
-}
-
-const tests = [
-  ["tests/test-arm64.mjs", node, ["tests/test-arm64.mjs"]],
-  ["tests/integration.sh", path.join(root, "tests/integration.sh"), []]
-];
-
-function formatDuration(milliseconds) {
-  if (milliseconds < 1000) return `${milliseconds.toFixed(0)} ms`;
-  return `${(milliseconds / 1000).toFixed(2)} s`;
-}
-
-const suiteStarted = performance.now();
-for (const [name, command, args] of tests) {
-  console.log(`\n==> ${name}`);
-  const started = performance.now();
-  const result = spawnSync(command, args, {
-    cwd: root,
-    stdio: "inherit"
-  });
-  const duration = formatDuration(performance.now() - started);
-
-  if (result.error) {
-    console.error(`<== ${name} FAILED (${duration})`);
-    console.error(result.error.message);
-    process.exit(1);
-  }
-  if (result.status !== 0) {
-    console.error(`<== ${name} FAILED (${duration})`);
-    process.exit(result.status ?? 1);
-  }
-  console.log(`<== ${name} passed (${duration})`);
-}
-
-console.log(`\nAll ARM64 tests passed (${formatDuration(performance.now() - suiteStarted)})`);