@fraczak/k 6.3.3 → 6.4.0

package/scripts/render-benchmark.mjs

@@ -11,7 +11,10 @@ const outputPath = path.resolve(root, process.argv[3] || "benchmark-results.html
 const rowOrder = [
   "Native JS (Envelope-Aware)",
   "Native JS (Envelope-Free)",
-  "kVM Interpreter (Env-Free)"
+  "kVM Interpreter (Env-Free)",
+  "KIR-P Export",
+  "k-wasm",
+  "k-llvm-jit"
 ];
 
 const columnGroups = [
@@ -90,7 +93,7 @@ function cellFor(result, best) {
   const ratio = best ? result.avgMs / best.avgMs : NaN;
   return `
     <div class="time">${fmtMs(result.avgMs)} <span>${fmtRatio(ratio)}</span></div>
-    <div class="sub">rss ${fmtMiB(result.maxRssMiB)}</div>`;
+    <div class="sub">warmup ${fmtMs(result.warmupMs)} · rss ${fmtMiB(result.maxRssMiB)}</div>`;
 }
 
 function factorialCell(byCase, allResults) {
@@ -151,6 +154,7 @@ function buildDetails(results) {
         <td class="num">${fmtMs(result.avgMs)}</td>
         <td class="num">${fmtMs(result.minMs)}</td>
         <td class="num">${fmtMs(result.maxMs)}</td>
+        <td class="num">${fmtMs(result.warmupMs)}</td>
         <td class="num">${fmtMiB(result.maxRssMiB)}</td>
         <td class="hash">${escapeHtml(result.resultDigest || "")}</td>
       </tr>`)
@@ -167,7 +171,7 @@ function render(doc) {
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1">
-  <title>k Benchmark Results</title>
+  <title>k Backend Benchmark Results</title>
   <style>
     :root {
       color-scheme: light;
@@ -201,7 +205,7 @@ function render(doc) {
       font-size: 14px;
     }
     main {
-      max-width: 1320px;
+      max-width: 1480px;
       margin: 0 auto;
       padding: 24px 32px 40px;
     }
@@ -237,7 +241,7 @@ function render(doc) {
       font-weight: 700;
     }
     .matrix {
-      min-width: 980px;
+      min-width: 1120px;
     }
     .matrix .group {
       text-align: center;
@@ -253,7 +257,7 @@ function render(doc) {
       margin-top: 2px;
     }
     .row-head {
-      width: 230px;
+      width: 250px;
       color: var(--ink);
       font-weight: 800;
       background: #fbfcfe;
@@ -302,7 +306,7 @@ function render(doc) {
 </head>
 <body>
   <header>
-    <h1>k Benchmark Results</h1>
+    <h1>k Backend Benchmark Results</h1>
     <div class="meta">
       <span>Generated: ${escapeHtml(generatedAt)}</span>
       <span>Node: ${escapeHtml(doc.node || "unknown")}</span>
@@ -326,7 +330,7 @@ function render(doc) {
       <div class="panel">
         <table>
           <thead>
-            <tr><th>Case</th><th>Mode</th><th>Status</th><th>Avg</th><th>Min</th><th>Max</th><th>Max RSS</th><th>Digest</th></tr>
+            <tr><th>Case</th><th>Mode</th><th>Status</th><th>Avg</th><th>Min</th><th>Max</th><th>Warmup</th><th>Max RSS</th><th>Digest</th></tr>
           </thead>
           <tbody>${buildDetails(results)}</tbody>
         </table>

package/scripts/run-tests.mjs

@@ -21,9 +21,15 @@ const tests = [
   ["tests/test-structural-values.mjs", node, ["tests/test-structural-values.mjs"]],
   ["tests/test-deep-wire-value.mjs", node, ["tests/test-deep-wire-value.mjs"]],
   ["tests/test-k-object.mjs", node, ["tests/test-k-object.mjs"]],
+  ["tests/test-kir.mjs", node, ["tests/test-kir.mjs"]],
+  ["tests/test-validate-object.mjs", node, ["tests/test-validate-object.mjs"]],
+  ["conformance/run.mjs", node, ["conformance/run.mjs"]],
   ["tests/test-repl.mjs", node, ["tests/test-repl.mjs"]],
+  ["tests/test-repl-html.mjs", node, ["tests/test-repl-html.mjs"]],
   ["tests/test-kvm.mjs", node, ["tests/test-kvm.mjs"]],
+  ["tests/test-kvm-polymorphic.mjs", node, ["tests/test-kvm-polymorphic.mjs"]],
   ["tests/test-arithmetics.mjs", node, ["tests/test-arithmetics.mjs"]],
+  ["tests/test-poly.mjs", node, ["tests/test-poly.mjs"]],
   ["tests/test-ieee-arithmetic.mjs", node, ["tests/test-ieee-arithmetic.mjs"]],
   ["tests/integration.sh", path.join(root, "tests/integration.sh"), []]
 ];

package/tests/integration.sh

@@ -10,11 +10,28 @@ trap 'rm -rf "$TMP_DIR"' EXIT
 
 ./objects/compile.mjs 'x = |x; x x' "$TMP_DIR/inline.ko"
 ./objects/decompile.mjs "$TMP_DIR/inline.ko" | grep -q '^----- main -----$'
+./objects/inspect.mjs "$TMP_DIR/inline.ko" | grep -q '^format: k-object$'
+./objects/inspect.mjs --kir "$TMP_DIR/inline.ko" | grep -q '"format": "k-ir"'
+./kir.mjs --help | grep -q 'Export the KIR-P JSON view'
+./kir.mjs "$TMP_DIR/inline.ko" | grep -q '"format": "k-ir"'
+./objects/validate.mjs "$TMP_DIR/inline.ko" | grep -q '^OK object$'
+./kir.mjs "$TMP_DIR/inline.ko" > "$TMP_DIR/inline.kir.json"
+./objects/validate.mjs --kir "$TMP_DIR/inline.kir.json" | grep -q '^OK KIR-P$'
+printf '[["open-product",[]]]' > "$TMP_DIR/input.pattern.json"
+./kir.mjs --retype __main__ --input-pattern "$TMP_DIR/input.pattern.json" "$TMP_DIR/inline.ko" > "$TMP_DIR/inline.retyped.kir.json"
+./objects/validate.mjs --kir "$TMP_DIR/inline.retyped.kir.json" | grep -q '^OK KIR-P$'
+printf '[["closed-product",[]]]' > "$TMP_DIR/unit.pattern.json"
 printf '()' | ./objects/compile.mjs > "$TMP_DIR/stdin.ko"
 ./objects/decompile.mjs "$TMP_DIR/stdin.ko" | grep -q '^----- main -----$'
-./objects/compile.mjs --format kvm '()' | grep -q '"__main__"'
-./objects/compile.mjs "$TMP_DIR/stdin.ko" "$TMP_DIR/stdin.kvm"
+./objects/compile.mjs --format kvm '()' | grep -q '"format": "k-vm"'
+./objects/compile.mjs --format kvm '()' > "$TMP_DIR/stdin.kvm"
+grep -q '"format": "k-vm"' "$TMP_DIR/stdin.kvm"
+grep -q '"layer": "KVM-P"' "$TMP_DIR/stdin.kvm"
+grep -q '"isPolymorphic": true' "$TMP_DIR/stdin.kvm"
 grep -q '"__main__"' "$TMP_DIR/stdin.kvm"
+./objects/compile.mjs "$TMP_DIR/stdin.ko" "$TMP_DIR/poly-object.kvm"
+grep -q '"layer": "KVM-P"' "$TMP_DIR/poly-object.kvm"
+grep -q '"isPolymorphic": true' "$TMP_DIR/poly-object.kvm"
 ./objects/compile.mjs 'id = ();' "$TMP_DIR/export.klib"
 ./objects/compile.mjs --lib "$TMP_DIR/export.klib" --export id:alias 'alias' "$TMP_DIR/export.ko"
 ./objects/decompile.mjs "$TMP_DIR/export.ko" | grep -q '^----- main -----$'

package/tests/test-arithmetics.mjs

@@ -89,6 +89,60 @@ try {
     );
   }
 
+  // Regression tests for inc/dec normalization and div
+  const resDec = run(node, [
+    "k.mjs",
+    "--lib", libPath,
+    "--export", "dec:dec",
+    "--export", "zero_int?:zero_int?",
+    "dec dec zero_int?"
+  ], { input: parseIntWire("2") });
+  assertOk(resDec, "2 int dec dec zero_int? should succeed");
+
+  const divTestCases = [
+    { x: "4", yAlias: "1", yVal: 1n },
+    { x: "10", yAlias: "2", yVal: 2n },
+    { x: "12", yAlias: "3", yVal: 3n },
+    { x: "11", yAlias: "3", yVal: 3n },
+    { x: "100", yAlias: "7", yVal: 7n },
+    { x: "-100", yAlias: "7", yVal: 7n },
+    { x: "1000", yAlias: "10", yVal: 10n }
+  ];
+
+  for (const { x, yAlias, yVal } of divTestCases) {
+    const xBig = BigInt(x);
+    const expectedDiv = (xBig / yVal).toString();
+    const xAbs = xBig < 0n ? -xBig : xBig;
+    const yAbs = yVal < 0n ? -yVal : yVal;
+    const expectedRem = (xAbs % yAbs).toString();
+
+    const wire = parseIntWire(x);
+
+    const resDiv = run(node, [
+      "k.mjs",
+      "--lib", libPath,
+      "--export", "div:div",
+      "--export", "int:int",
+      "--export", `${yAlias}:divisor`,
+      "{() x, divisor int y} div .div"
+    ], { input: wire });
+    assertOk(resDiv, `native div(${x}, ${yAlias}) quotient`);
+    const divOut = printIntWire(resDiv.stdout, `div quotient`);
+    assert.equal(divOut, expectedDiv, `div(${x}, ${yAlias}) quotient should match BigInt oracle`);
+
+    const resRem = run(node, [
+      "k.mjs",
+      "--lib", libPath,
+      "--export", "div:div",
+      "--export", "int:int",
+      "--export", `${yAlias}:divisor`,
+      "{() x, divisor int y} div .rem int"
+    ], { input: wire });
+    assertOk(resRem, `native div(${x}, ${yAlias}) remainder`);
+    const remOut = printIntWire(resRem.stdout, `div remainder`);
+    assert.equal(remOut, expectedRem, `div(${x}, ${yAlias}) remainder should match BigInt oracle`);
+  }
+
   console.log("OK");
 } finally {
   fs.rmSync(tmpDir, { recursive: true, force: true });

package/tests/test-ieee-arithmetic.mjs

@@ -69,6 +69,10 @@ const cases = [
   { op: "mul", x: "-2", y: "4", result: "-8", flags: "none" },
   { op: "mul", x: "Infinity", y: "0", result: "NaN", flags: "invalid" },
   { op: "div", x: "1", y: "2", result: "0.5" },
+  { op: "div", x: "9", y: "3", result: "3", flags: "none", projection: true },
+  { op: "div", x: "10", y: "2", result: "5", flags: "none" },
+  { op: "div", x: "1", y: "3", result: "0.3333333333333333", flags: "inexact" },
+  { op: "div", x: "-6", y: "2", result: "-3", flags: "none" },
   { op: "div", x: "1", y: "0", result: "Infinity", flags: "div_by_zero" },
   { op: "div", x: "0", y: "0", result: "NaN", flags: "invalid" }
 ];

package/tests/test-kir.mjs

@@ -0,0 +1,85 @@
+import assert from "node:assert";
+import { compileLibraryBuffer, compileObjectBuffer, decodeObject } from "../object.mjs";
+import { objectToKIRP, retypeObjectRelation } from "../kir.mjs";
+import {
+  objectToKIRP as backendObjectToKIRP,
+  objectToKVMArtifact,
+  retypeObjectRelation as backendRetypeObjectRelation
+} from "../backend-api.mjs";
+import { validateKIRP } from "../objects/validate.mjs";
+
+const object = decodeObject(compileObjectBuffer(`
+  $ bit = < {} 0, {} 1 >;
+  id = ();
+  .x id
+`, { source: "kir-test.k" }));
+const kir = objectToKIRP(object);
+assert.equal(backendObjectToKIRP(object).format, "k-ir");
+
+assert.equal(kir.format, "k-ir");
+assert.equal(kir.version, 1);
+assert.equal(kir.layer, "KIR-P");
+assert.equal(kir.sourceFormat, "k-object");
+assert.equal(kir.kind, "executable");
+assert.equal(kir.main, "__main__");
+assert.equal(kir.rels.__main__.typeDerivation.status, "converged");
+assert.equal(typeof kir.rels.__main__.inputPattern, "number");
+assert.equal(typeof kir.rels.__main__.outputPattern, "number");
+assert(Array.isArray(kir.rels.__main__.patternGraph.nodes));
+assert(kir.rels.__main__.patternGraph.nodes.every((node, index) => node.id === index));
+assert.deepEqual(new Set(kir.rels.__main__.patternGraph.nodes.map((node) => node.kind)).has("open-product"), true);
+assert.equal(kir.rels.__main__.body.op, "dot");
+assert.equal(kir.rels.__main__.body.label, "x");
+const retyped = validateKIRP(retypeObjectRelation(object, "__main__", [
+  ["closed-product", [["x", 1]]],
+  ["closed-product", []]
+]));
+assert.equal(retyped.layer, "KIR-P");
+assert.equal(retyped.kind, "executable");
+assert.equal(retyped.main, "__main__");
+assert.equal(retyped.rels.__main__.body.op, "ref");
+assert.equal(retyped.rels.__main__.body.ref, "__kir_target__");
+assert(!("instanceKey" in retyped));
+assert(!("callSites" in retyped));
+assert.equal(backendRetypeObjectRelation(object, "__main__", [["open-product", []]]).layer, "KIR-P");
+assert.throws(
+  () => objectToKVMArtifact(object, "__main__", [["open-product", []]]),
+  /\.kvm emission requires a singleton input pattern/
+);
+const kvmArtifact = objectToKVMArtifact(object, "__main__", [
+  ["closed-product", [["x", 1]]],
+  ["closed-product", []]
+]);
+assert.equal(kvmArtifact.format, "k-vm");
+assert.equal(kvmArtifact.layer, "KVM");
+assert.equal(kvmArtifact.entry, "__main__");
+assert.deepEqual(kvmArtifact.inputPattern, [
+  ["closed-product", [["x", 1]]],
+  ["closed-product", []]
+]);
+assert.deepEqual(kvmArtifact.outputPattern, [["closed-product", []]]);
+assert.ok(kvmArtifact.functions.__main__);
+assert.equal(kvmArtifact.kir.layer, "KIR-P");
+assert(!("instanceKey" in kvmArtifact));
+
+const helperObject = decodeObject(compileObjectBuffer("pick = .x; {.a pick left, .b pick right}", { source: "kir-helper.k" }));
+const helperRetyped = validateKIRP(retypeObjectRelation(helperObject, "__main__", [
+  ["open-product", [["a", 1], ["b", 2]]],
+  ["open-product", [["x", 3]]],
+  ["open-product", [["x", 4]]],
+  ["closed-product", []],
+  ["closed-product", []]
+]));
+assert.equal(helperRetyped.layer, "KIR-P");
+assert.equal(helperRetyped.kind, "executable");
+assert.ok(helperRetyped.rels.pick);
+assert(!("instanceKey" in helperRetyped));
+assert(!("callSites" in helperRetyped));
+
+const library = decodeObject(compileLibraryBuffer("succ = |succ;\n", { source: "kir-lib.k" }));
+const libraryKir = objectToKIRP(library);
+assert.equal(libraryKir.kind, "library");
+assert.equal(libraryKir.main, null);
+assert(Object.values(libraryKir.rels).some((rel) => rel.body.op === "vid"));
+
+console.log("OK");

package/tests/test-kvm-polymorphic.mjs

@@ -0,0 +1,278 @@
+import assert from "node:assert";
+import k from "../index.mjs";
+import {
+  objectToKVMArtifact,
+  specializeKVM,
+  executeKVM
+} from "../kvm.mjs";
+import { compileObjectBuffer, decodeObject } from "../object.mjs";
+import { objectToKIRP } from "../kir.mjs";
+import { fromObject, Value } from "../Value.mjs";
+import { lowerToWasm } from "../backends/wasm/src/kvm2wasm.mjs";
+import wabtFactory from "wabt";
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const runtimeWat = fs.readFileSync(path.join(__dirname, "../backends/wasm/runtime.wat"), "utf8");
+
+function toJSON(value) {
+  if (value === undefined) return undefined;
+  return JSON.parse(JSON.stringify(value));
+}
+
+console.log("==> Starting Polymorphic kVM & Specialization Tests");
+
+// Test 1: Compile Polymorphic kVM Artifact (AOT) without input pattern
+{
+  const script = `
+    map = { .a first, .b second };
+    map
+  `;
+  const obj = decodeObject(compileObjectBuffer(script));
+  const kvmArtifact = objectToKVMArtifact(obj);
+
+  assert.equal(kvmArtifact.format, "k-vm");
+  assert.equal(kvmArtifact.layer, "KVM-P");
+  assert.equal(kvmArtifact.isPolymorphic, true);
+  assert.ok(kvmArtifact.functions["__main__"]);
+  assert.ok(Array.isArray(kvmArtifact.inputPattern));
+  console.log("Test 1 (Polymorphic kVM AOT Artifact): Passed");
+}
+
+// Test 2: Specialize Polymorphic kVM with Conforming Envelope & Subtyping
+{
+  const script = `
+    map = { .a first, .b second };
+    map
+  `;
+  const obj = decodeObject(compileObjectBuffer(script));
+  const kvmArtifact = objectToKVMArtifact(obj);
+
+  // Input envelope carries extra field 'extra'
+  const inputEnvelope = [
+    ["closed-product", [["a", 1], ["b", 2], ["extra", 3]]],
+    ["closed-product", []],
+    ["closed-union", [["valB", 4]]],
+    ["closed-product", []],
+    ["closed-product", []]
+  ];
+
+  const specialized = specializeKVM(kvmArtifact, inputEnvelope);
+  assert.equal(specialized.isSpecialized, true);
+  assert.equal(specialized.layer, "KVM-M");
+
+  const specFunc = specialized.functions[specialized.entry];
+  assert.ok(specFunc);
+  assert.equal(specFunc.isSpecialized, true);
+
+  // Execute in envelopeFree mode
+  const val = fromObject({
+    a: { unit: {} },
+    b: { valB: {} },
+    extra: { dummy: {} }
+  });
+
+  const res = executeKVM(specFunc, val, {
+    rels: kvmArtifact.kir.rels,
+    codes: kvmArtifact.codes,
+    options: { envelopeFree: true }
+  });
+
+  assert.deepEqual(toJSON(res), {
+    first: "unit",
+    second: "valB"
+  });
+  console.log("Test 2 (Specialize with Subtyping & Envelope-Free Execution): Passed");
+}
+
+// Test 3: Type Error on Envelope Mismatch
+{
+  const script = `
+    $ bool = < {} true, {} false >;
+    check = $bool;
+    check
+  `;
+  const obj = decodeObject(compileObjectBuffer(script));
+  const kvmArtifact = objectToKVMArtifact(obj);
+
+  // An envelope with variant 'other' does not conform to bool
+  const incompatibleEnvelope = [
+    ["closed-union", [["other", 1]]],
+    ["closed-product", []]
+  ];
+
+  assert.throws(
+    () => specializeKVM(kvmArtifact, incompatibleEnvelope),
+    (err) => {
+      assert.ok(err instanceof TypeError);
+      assert.ok(err.message.includes("Type Error"));
+      return true;
+    },
+    "Expected TypeError on incompatible envelope"
+  );
+  console.log("Test 3 (Type Error on Envelope Mismatch): Passed");
+}
+
+// Test 4: Dead Branch Elimination in Union Specialization
+{
+  const script = `
+    choose = < /x, /y >;
+    choose
+  `;
+  const obj = decodeObject(compileObjectBuffer(script));
+  const kvmArtifact = objectToKVMArtifact(obj);
+  const unspecFunc = kvmArtifact.functions[kvmArtifact.entry];
+  const unspecUnion = unspecFunc.body.find(inst => inst.op === "union");
+  assert.equal(unspecUnion.branches.length, 2, "Unspecialized union has 2 branches");
+
+  // Specialize with envelope containing ONLY variant 'x'
+  const xEnvelope = [
+    ["closed-union", [["x", 1]]],
+    ["closed-product", []]
+  ];
+
+  const specialized = specializeKVM(kvmArtifact, xEnvelope);
+  const specFunc = specialized.functions[specialized.entry];
+  const specUnion = specFunc.body.find(inst => inst.op === "union");
+
+  // The 'y' branch should be pruned!
+  assert.equal(specUnion.branches.length, 1, "Specialized union should prune unreachable branch");
+  assert.equal(specUnion.branches[0].body[0].tag, "x");
+
+  // Execution on { x: payload }
+  const valX = fromObject({ x: { payload: {} } });
+  const resX = executeKVM(specFunc, valX, {
+    rels: kvmArtifact.kir.rels,
+    codes: kvmArtifact.codes,
+    options: { envelopeFree: true }
+  });
+  assert.deepEqual(toJSON(resX), "payload");
+
+  console.log("Test 4 (Dead Branch Elimination in Union): Passed");
+}
+
+// Test 5: Redundant Guard Elimination
+{
+  const script = `
+    filterTest = ?{ ... } (.a);
+    filterTest
+  `;
+  const obj = decodeObject(compileObjectBuffer(script));
+  const kvmArtifact = objectToKVMArtifact(obj);
+
+  const inputEnvelope = [
+    ["closed-product", [["a", 1]]],
+    ["closed-product", []]
+  ];
+
+  const specialized = specializeKVM(kvmArtifact, inputEnvelope);
+  const specFunc = specialized.functions[specialized.entry];
+
+  // The guard_pattern was checking open product, which inputEnvelope already satisfies.
+  // It should be simplified to 'id' or eliminated!
+  const hasUnsimplifiedGuard = specFunc.body.some(inst => inst.op === "guard_pattern");
+  assert.equal(hasUnsimplifiedGuard, false, "Redundant guard should be eliminated or simplified to id");
+
+  console.log("Test 5 (Redundant Guard Elimination): Passed");
+}
+
+// Test 6: Fast Compilation to WebAssembly from Specialized kVM
+{
+  const script = `
+    map = { .a first, .b second };
+    map
+  `;
+  const obj = decodeObject(compileObjectBuffer(script));
+  const kvmArtifact = objectToKVMArtifact(obj);
+
+  const inputEnvelope = [
+    ["closed-product", [["a", 1], ["b", 2], ["extra", 3]]],
+    ["closed-product", []],
+    ["closed-product", []],
+    ["closed-product", []]
+  ];
+
+  const specialized = specializeKVM(kvmArtifact, inputEnvelope);
+  const specFunc = specialized.functions[specialized.entry];
+
+  // Lower directly to Wasm WAT
+  const watBody = lowerToWasm(specFunc, "map_spec");
+  assert.ok(watBody.includes("(func $map_spec"));
+
+  // Assemble with wabt to ensure it is 100% valid Wasm
+  const wabt = await wabtFactory();
+  const fullWat = runtimeWat.trim().slice(0, -1) + "\n" + watBody + "\n)";
+  const wasmModule = wabt.parseWat("test.wat", fullWat, {
+    mutable_globals: true,
+    sat_float_to_int: true,
+    sign_extension: true,
+    multi_value: true,
+    bulk_memory: true,
+    reference_types: true
+  });
+  wasmModule.resolveNames();
+  wasmModule.validate();
+  const binary = wasmModule.toBinary({ log: false, write_debug_names: false });
+  assert.ok(binary.buffer.byteLength > 0);
+
+  console.log("Test 6 (Direct Lowering to WebAssembly): Passed");
+}
+
+// Test 7: CLI Compilation to Polymorphic .kvm without --input-pattern
+{
+  const compileScript = path.join(__dirname, "../objects/compile.mjs");
+  const res = spawnSync(process.execPath, [compileScript, "--format", "kvm", "Examples/arithmetics.k"], {
+    cwd: path.join(__dirname, ".."),
+    encoding: "utf8"
+  });
+  assert.equal(res.status, 0, `CLI compile failed: ${res.stderr}`);
+  const kvm = JSON.parse(res.stdout);
+  assert.equal(kvm.format, "k-vm");
+  assert.equal(kvm.layer, "KVM-P");
+  assert.equal(kvm.isPolymorphic, true);
+  assert.ok(kvm.functions["__main__"]);
+  console.log("Test 7 (CLI Compilation to Polymorphic .kvm): Passed");
+}
+
+// Test 8: CLI Compilation with --lib and explicit --export (no auto-export)
+{
+  const compileScript = path.join(__dirname, "../objects/compile.mjs");
+  // Fails without explicit --export
+  const failRes = spawnSync(process.execPath, [
+    compileScript,
+    "--lib", "Examples/arithmetics.k",
+    "{succ int x,int y}+"
+  ], {
+    cwd: path.join(__dirname, ".."),
+    encoding: "utf8"
+  });
+  assert.notEqual(failRes.status, 0, "Should fail without explicit --export");
+
+  // Succeeds with explicit --export
+  const successRes = spawnSync(process.execPath, [
+    compileScript,
+    "--lib", "Examples/arithmetics.k",
+    "--export", "plus:+",
+    "--export", "succ",
+    "--export", "int",
+    "--format", "kvm",
+    "{succ int x,int y}+"
+  ], {
+    cwd: path.join(__dirname, ".."),
+    encoding: "utf8",
+    maxBuffer: 10 * 1024 * 1024
+  });
+  assert.equal(successRes.status, 0, `CLI compile with --export failed: ${successRes.stderr}`);
+  const kvm = JSON.parse(successRes.stdout);
+  assert.equal(kvm.format, "k-vm");
+  assert.equal(kvm.layer, "KVM-P");
+  assert.equal(kvm.isPolymorphic, true);
+  assert.ok(kvm.functions["__main__"]);
+  console.log("Test 8 (CLI Compilation with --lib and explicit --export): Passed");
+}
+
+console.log("==> All Polymorphic kVM Tests Passed Successfully!");
+

package/tests/test-kvm.mjs

@@ -1,17 +1,25 @@
 import assert from "node:assert";
 import k from "../index.mjs";
-import { lowerToKVM, executeKVM } from "../kvm.mjs";
+import { lowerKIRRelationToKVM, executeKVM } from "../kvm.mjs";
 import codes from "../codes.mjs";
 import { fromObject } from "../Value.mjs";
 import run, { run_converged } from "../run.mjs";
+import { compileObjectBuffer, decodeObject } from "../object.mjs";
+import { objectToKIRP } from "../kir.mjs";
 
 function runKVM(script, data, options = {}) {
-  const defs = k.annotate(script, {
+  const object = decodeObject(compileObjectBuffer(script, {
     convergence: { strategy: "auto" }
-  });
-  const mainRel = defs.rels.__main__;
-  const kvmFunc = lowerToKVM(mainRel, "__main__");
-  const context = { rels: defs.rels, findCode: codes.find, options };
+  }));
+  const kir = objectToKIRP(object);
+  const mainRel = kir.rels[kir.main];
+  const kvmFunc = lowerKIRRelationToKVM(mainRel, kir.main, { codes: kir.codes });
+  const context = {
+    rels: kir.rels,
+    codes: kir.codes,
+    findCode: (hash) => kir.codes[hash] || codes.find(hash),
+    options
+  };
   return executeKVM(kvmFunc, fromObject(data), context);
 }
 
@@ -160,4 +168,15 @@ console.log("==> Starting kVM Tests");
   console.log("Test 9 (KVM vs JS run equivalence & Peano addition): Passed");
 }
 
+// Test 10: Intrinsic handling is explicit, not based on identifier spelling
+{
+  const result = runKVM("_user = .a; _user", { a: {}, b: {} });
+  assert.deepEqual(toJSON(result), {});
+  assert.throws(
+    () => runKVM("_log!", { unit: {} }),
+    /kVM interpreter: unsupported intrinsic '_log!'/
+  );
+  console.log("Test 10 (Explicit intrinsics): Passed");
+}
+
 console.log("==> All kVM Tests Passed!");