@fraczak/k 6.1.3 → 6.2.1

package/repl.mjs

@@ -213,6 +213,40 @@ function mergeLibrary(state, lib, source = "<load>", options = {}) {
   restoreCodes(state);
 }
 
+function reachableRelations(rels, roots) {
+  const reachable = new Set();
+  const queue = [...roots];
+
+  function walkExp(exp) {
+    if (!exp) return;
+    switch (exp.op) {
+      case "ref":
+        if (exp.ref in rels && !reachable.has(exp.ref)) queue.push(exp.ref);
+        break;
+      case "comp":
+        exp.comp.forEach(walkExp);
+        break;
+      case "union":
+        exp.union.forEach(walkExp);
+        break;
+      case "product":
+        exp.product.forEach(({ exp: child }) => walkExp(child));
+        break;
+    }
+  }
+
+  while (queue.length > 0) {
+    const hash = queue.shift();
+    if (reachable.has(hash) || !(hash in rels)) continue;
+    reachable.add(hash);
+    walkExp(rels[hash].def);
+  }
+
+  return Object.fromEntries(
+    Object.entries(rels).filter(([hash]) => reachable.has(hash))
+  );
+}
+
 function savedLibrary(state) {
   const meta = cloneJSON(state.meta);
   const now = new Date().toISOString();
@@ -226,13 +260,20 @@ function savedLibrary(state) {
     if (meta[hash].type == null) meta[hash].type = "rel";
     meta[hash].origins.push({ source: "<repl>", name, compiledAt: now });
   }
+  const rels = reachableRelations(state.rels, Object.values(state.relAliases));
+  const storedHashes = new Set([
+    ...Object.keys(state.codes),
+    ...Object.keys(rels)
+  ]);
   return {
     format: "k-object",
     codes: state.codes,
-    rels: state.rels,
+    rels,
     relAlias: state.relAliases,
     compileStats: { sccs: [], sccCount: 0 },
-    meta,
+    meta: Object.fromEntries(
+      Object.entries(meta).filter(([hash]) => storedHashes.has(hash))
+    ),
     main: null
   };
 }

package/run.mjs

@@ -483,4 +483,4 @@ run_converged.defs = null;
 const run_coverged = run_converged;
 
 export default run;
-export { run, run_rel, run_converged, run_coverged };
+export { run, run_rel, run_converged, run_coverged, constrainWithPattern, intersectPatterns, projectionPattern, verify };

package/scripts/run-tests.mjs

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+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;
+const derivationTests = fs.readdirSync(path.join(root, "tests/code-derivation"))
+  .filter((name) => name.endsWith(".mjs"))
+  .sort()
+  .map((name) => [`tests/code-derivation/${name}`, node, [`tests/code-derivation/${name}`]]);
+
+const tests = [
+  ["tests/test.mjs", node, ["tests/test.mjs"]],
+  ...derivationTests,
+  ["tests/test-fingerprint.mjs", node, ["tests/test-fingerprint.mjs"]],
+  ["tests/test-hash-fuzz.mjs", node, ["tests/test-hash-fuzz.mjs"]],
+  ["tests/test-hash-normalization.mjs", node, ["tests/test-hash-normalization.mjs"]],
+  ["tests/test-k-object.mjs", node, ["tests/test-k-object.mjs"]],
+  ["tests/test-repl.mjs", node, ["tests/test-repl.mjs"]],
+  ["tests/test-kvm.mjs", node, ["tests/test-kvm.mjs"]],
+  ["tests/test-ieee-arithmetic.mjs", node, ["tests/test-ieee-arithmetic.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 tests passed (${formatDuration(performance.now() - suiteStarted)})`);

package/tests/README.md

@@ -0,0 +1,35 @@
+# k Test Suite
+
+This directory contains the automated tests, type-derivation validation cases, and integration test scripts for the `k` compiler and runtime.
+
+## Running the Tests
+
+### 1. Run Unit and Integration Test Suite
+To run all core unit tests, type-derivation checks, and integration tests:
+```bash
+npm test
+```
+This executes `node scripts/run-tests.mjs`, which discovers and runs the test scripts sequentially.
+
+## Test Directory Structure
+
+### Core Test Files
+- **[test.mjs](file:///Users/wojtek/gits/k/tests/test.mjs)**: Verifies basic parser and runtime execution behavior.
+- **[test-kvm.mjs](file:///Users/wojtek/gits/k/tests/test-kvm.mjs)**: Comprehensive conformance testing for the kVM register compiler and interpreter under both envelope-aware and envelope-free modes.
+- **[test-ieee-arithmetic.mjs](file:///Users/wojtek/gits/k/tests/test-ieee-arithmetic.mjs)**: Verifies IEEE-754 double precision float arithmetic implementation (`Examples/ieee.k`).
+- **[test-repl.mjs](file:///Users/wojtek/gits/k/tests/test-repl.mjs)**: Tests interactive REPL commands, state transitions, imports, and auto-completions.
+- **[test-k-object.mjs](file:///Users/wojtek/gits/k/tests/test-k-object.mjs)**: Tests serialization, compilation, and loading of `.ko` binary objects.
+- **[test-fingerprint.mjs](file:///Users/wojtek/gits/k/tests/test-fingerprint.mjs)**: Tests semantic expression and relation hashing/fingerprinting.
+- **[test-hash-normalization.mjs](file:///Users/wojtek/gits/k/tests/test-hash-normalization.mjs)**: Verifies consistent normalization of type pattern graphs and hashes.
+- **[test-hash-fuzz.mjs](file:///Users/wojtek/gits/k/tests/test-hash-fuzz.mjs)**: Fuzzes expression/relation hashing to guard against collisions.
+
+### WebAssembly Benchmarks
+
+The WebAssembly execution benchmark moved to the separate
+[`fraczak/k-wasm`](https://github.com/fraczak/k-wasm) backend repository.
+
+### Type Derivation Suites
+- **[code-derivation/](file:///Users/wojtek/gits/k/tests/code-derivation)**: Houses individual files (each containing a focused test scenario) validating type-derivation convergence and pattern-envelope generation.
+
+### Integration Scripts
+- **[integration.sh](file:///Users/wojtek/gits/k/tests/integration.sh)**: Shell script checking boundary data pipelines (`k-parse`, `k-show`, `k-print`) against binary outputs.

package/{Code-derivation-tests → tests/code-derivation}/codec-witness-pattern.mjs

@@ -1,7 +1,7 @@
 import assert from 'assert';
-import { parseValue } from '../valueIO.mjs';
-import { encodeToWire, decodeWire } from '../codecs/runtime/prefix-codec.mjs';
-import { Product, Variant } from '../Value.mjs';
+import { parseValue } from '../../valueIO.mjs';
+import { encodeToWire, decodeWire } from '../../codecs/runtime/prefix-codec.mjs';
+import { Product, Variant } from '../../Value.mjs';
 
 const value = parseValue('{a:{b:x,c:{}}}');
 const repeatedClosedValue = parseValue('{a:{m:{},n:{}},b:{m:{},n:{}}}');
@@ -20,7 +20,7 @@ const explicitProductWire = decodeWire(encodeToWire(value, [
   ["any", []]
 ]));
 assert.deepEqual(explicitProductWire.pattern, [
-  ["open-product", [["a", 1]]],
+  ["closed-product", [["a", 1]]],
   ["closed-product", [["b", 2], ["c", 3]]],
   ["open-union", [["x", 3]]],
   ["closed-product", []]

package/{Code-derivation-tests → tests/code-derivation}/convergence-strategy.mjs

@@ -1,5 +1,5 @@
 import assert from "assert";
-import { annotate } from "../index.mjs";
+import { annotate } from "../../index.mjs";
 
 const script = `
   f = .x;

package/{Code-derivation-tests → tests/code-derivation}/dot.mjs

@@ -1,5 +1,5 @@
 import { t, in_out } from './index.mjs';
-import { hash } from '../hash.mjs';
+import { hash } from '../../hash.mjs';
 import assert from 'assert';
 
 t(`

package/{Code-derivation-tests → tests/code-derivation}/filter-syntax.mjs

@@ -1,5 +1,5 @@
 import assert from 'assert';
-import { annotate } from '../index.mjs';
+import { annotate } from '../../index.mjs';
 
 function succeeds(script) {
   assert.doesNotThrow(() => annotate(script));

package/{Code-derivation-tests → tests/code-derivation}/index.mjs

@@ -1,4 +1,4 @@
-import { annotate } from "../index.mjs";
+import { annotate } from "../../index.mjs";
 
 function in_out(annotated) {
   const [input,output] = annotated.rels.__main__.def.patterns.map( (pat) => 

package/{Code-derivation-tests → tests/code-derivation}/pattern-envelope.mjs

@@ -1,9 +1,9 @@
 import assert from "node:assert/strict";
-import k from "../index.mjs";
-import { Product, Variant, mergePatterns, withPattern } from "../Value.mjs";
-import { decodeWire, encodeToWire } from "../codecs/runtime/prefix-codec.mjs";
-import run from "../run.mjs";
-import codes from "../codes.mjs";
+import k from "../../index.mjs";
+import { Product, Variant, mergePatterns, withPattern } from "../../Value.mjs";
+import { decodeWire, encodeToWire } from "../../codecs/runtime/prefix-codec.mjs";
+import run from "../../run.mjs";
+import codes from "../../codes.mjs";
 
 const INT_PATTERN = [
   ["closed-union", [["+", 1], ["-", 1]]],

package/{Code-derivation-tests → tests/code-derivation}/product.mjs

@@ -1,6 +1,6 @@
 import { t, in_out } from './index.mjs';
 import assert from 'assert';
-import hash from "../hash.mjs";
+import hash from "../../hash.mjs";
 
 const unitCode = hash('$C0={};');
 

package/{tests.sh → tests/integration.sh}

@@ -1,7 +1,12 @@
+#!/usr/bin/env bash
+set -euo pipefail
 
 # This script is used to run the k.mjs interpreter with various test cases.
 
-echo "Running './tests.sh' ..."
+echo "Running './tests/integration.sh' ..."
+
+TMP_DIR=`mktemp -d`
+trap 'rm -rf "$TMP_DIR"' EXIT
 
 echo '["zebara", "ela", "kupa", ala, owca]' | node ./codecs/k-parse.mjs | ./k.mjs '{.1 0,.3 1}' | node ./codecs/k-print.mjs
 echo 
@@ -11,14 +16,14 @@ node ./codecs/unit.mjs --parse | node ./codecs/unit.mjs --print | grep -qx '{}'
 echo 
 printf 'A🙂\nBé~\t' | ./codecs/utf8.mjs --parse | ./k.mjs -k Examples/byte.k |./codecs/utf8.mjs --print
 echo
-./objects/compile-lib.mjs Examples/ieee.k ieee.klib
-MUL=`./objects/extract-aliases.mjs ieee.klib | grep '^mul = @' | sed 's/^mul = \(@[^;]*\);.*$/\1/'`
-DIV=`./objects/extract-aliases.mjs ieee.klib | grep '^div = @' | sed 's/^div = \(@[^;]*\);.*$/\1/'`
+./objects/compile-lib.mjs Examples/ieee.k "$TMP_DIR/ieee.klib"
+MUL=`./objects/extract-aliases.mjs "$TMP_DIR/ieee.klib" | grep '^mul = @' | sed 's/^mul = \(@[^;]*\);.*$/\1/'`
+DIV=`./objects/extract-aliases.mjs "$TMP_DIR/ieee.klib" | grep '^div = @' | sed 's/^div = \(@[^;]*\);.*$/\1/'`
 ARG=0.12
 printf "$ARG * $ARG = "
-echo $ARG | ./codecs/ieee.mjs --parse | ./k.mjs --lib ieee.klib "{()x,()y} $MUL .result" | ./codecs/ieee.mjs --print
+echo $ARG | ./codecs/ieee.mjs --parse | ./k.mjs --lib "$TMP_DIR/ieee.klib" "{()x,()y} $MUL .result" | ./codecs/ieee.mjs --print
 printf "$ARG / $ARG = "
-DIV_RESULT=`echo $ARG | ./codecs/ieee.mjs --parse | ./k.mjs --lib ieee.klib "{()x,()y} $DIV .result" | ./codecs/ieee.mjs --print`
+DIV_RESULT=`echo $ARG | ./codecs/ieee.mjs --parse | ./k.mjs --lib "$TMP_DIR/ieee.klib" "{()x,()y} $DIV .result" | ./codecs/ieee.mjs --print`
 echo "$DIV_RESULT"
 test "$DIV_RESULT" = "1"
 echo

package/{test-fingerprint.mjs → tests/test-fingerprint.mjs}

@@ -1,6 +1,6 @@
-import k from './index.mjs';
-import { encodeCodeToString, find } from './codes.mjs';
-import hash from './hash.mjs';
+import k from '../index.mjs';
+import { encodeCodeToString, find } from '../codes.mjs';
+import hash from '../hash.mjs';
 [
     `
     $bits = < bits 0,  bits 1, {} _ >;

package/{test-hash-fuzz.mjs → tests/test-hash-fuzz.mjs}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import assert from "node:assert/strict";
-import { annotate } from "./index.mjs";
+import { annotate } from "../index.mjs";
 
 function mulberry32(seed) {
   let t = seed >>> 0;

package/{test-hash-normalization.mjs → tests/test-hash-normalization.mjs}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 import assert from "node:assert/strict";
-import { annotate } from "./index.mjs";
-import { hash } from "./hash.mjs";
+import { annotate } from "../index.mjs";
+import { hash } from "../hash.mjs";
 
 const nameRegex = /^[a-zA-Z0-9_+][a-zA-Z0-9_?!+]*$/;
 

package/{test-ieee-arithmetic.mjs → tests/test-ieee-arithmetic.mjs}

@@ -1,10 +1,10 @@
 import assert from "node:assert/strict";
 
-import { createState, evaluateInput } from "./repl.mjs";
-import { Product } from "./Value.mjs";
-import codes from "./codes.mjs";
-import { parse as parseFloat64, print as printFloat64 } from "./codecs/ieee.mjs";
-import { singletonPatternToCodeHash, valueForCode } from "./repl-codecs.mjs";
+import { createState, evaluateInput } from "../repl.mjs";
+import { Product } from "../Value.mjs";
+import codes from "../codes.mjs";
+import { parse as parseFloat64, print as printFloat64 } from "../codecs/ieee.mjs";
+import { singletonPatternToCodeHash, valueForCode } from "../repl-codecs.mjs";
 
 const state = createState();
 await evaluateInput(":load Examples/ieee.k", state);
@@ -44,7 +44,7 @@ function assertFloatResult(value, expected, label) {
   assert.equal(printFloat64(value), expected, label);
 }
 
-async function assertOperation({ op, x, y, result, flags = null }) {
+async function assertOperation({ op, x, y, result, flags = null, projection = false }) {
   const bundle = await runOperation(op, x, y);
   assert.ok(bundle instanceof Product, `${op} should return a result bundle`);
   assert.deepEqual(Object.keys(bundle.product).sort(), ["flags", "result"]);
@@ -53,37 +53,24 @@ async function assertOperation({ op, x, y, result, flags = null }) {
     assert.equal(bundle.product.flags.tag, flags, `${op}(${x}, ${y}).flags`);
   }
 
-  const projected = await runProjectedResult(op, x, y);
-  assertFloatResult(projected, result, `${op}(${x}, ${y}).result projection`);
+  if (projection) {
+    const projected = await runProjectedResult(op, x, y);
+    assertFloatResult(projected, result, `${op}(${x}, ${y}).result projection`);
+  }
 }
 
 const cases = [
-  // Addition: same sign, cancellation, exact fractional add, and specials.
-  { op: "add", x: "1", y: "1", result: "2", flags: "none" },
-  { op: "add", x: "-1", y: "1", result: "0", flags: "none" },
-  { op: "add", x: "0.5", y: "0.25", result: "0.75", flags: "none" },
+  // Keep this as a fast smoke matrix. Examples/ieee.k has detailed relation-level coverage.
+  { op: "add", x: "0.5", y: "0.25", result: "0.75", flags: "none", projection: true },
   { op: "add", x: "Infinity", y: "-Infinity", result: "NaN", flags: "invalid" },
-  { op: "add", x: "NaN", y: "1", result: "NaN", flags: "none" },
 
-  // Subtraction: positive result, negative result, signed-zero-equivalent, and invalid infinity subtraction.
-  { op: "sub", x: "4", y: "2", result: "2", flags: "none" },
+  // Cover each finite arithmetic implementation, including sign and fractional results.
   { op: "sub", x: "2", y: "4", result: "-2", flags: "none" },
-  { op: "sub", x: "0", y: "0", result: "0", flags: "none" },
-  { op: "sub", x: "Infinity", y: "Infinity", result: "NaN", flags: "invalid" },
-
-  // Multiplication: positive, signed, zero, and invalid infinity-by-zero.
-  { op: "mul", x: "4", y: "2", result: "8", flags: "none" },
   { op: "mul", x: "-2", y: "4", result: "-8", flags: "none" },
-  { op: "mul", x: "0", y: "5", result: "0", flags: "none" },
   { op: "mul", x: "Infinity", y: "0", result: "NaN", flags: "invalid" },
-
-  // Division: normalized exact cases, fractional quotient, divide-by-zero, invalid zero-over-zero, and infinity quotient.
-  { op: "div", x: "4", y: "2", result: "2" },
-  { op: "div", x: "1", y: "1", result: "1" },
   { op: "div", x: "1", y: "2", result: "0.5" },
   { op: "div", x: "1", y: "0", result: "Infinity", flags: "div_by_zero" },
-  { op: "div", x: "0", y: "0", result: "NaN", flags: "invalid" },
-  { op: "div", x: "Infinity", y: "2", result: "Infinity", flags: "none" }
+  { op: "div", x: "0", y: "0", result: "NaN", flags: "invalid" }
 ];
 
 for (const testCase of cases) {

package/{test-k-object.mjs → tests/test-k-object.mjs}

@@ -1,11 +1,11 @@
 import assert from "node:assert";
 import fs from "node:fs";
-import k from "./index.mjs";
-import { parseValue } from "./valueIO.mjs";
-import { decodeWire, encodeToWire, CORE_PATTERN_PROPERTY_LIST } from "./codecs/runtime/prefix-codec.mjs";
-import { Product, Variant } from "./Value.mjs";
-import { exportPatternGraph } from "./codecs/runtime/codec.mjs";
-import { patternToPropertyList } from "./codecs/runtime/pattern-json.mjs";
+import k from "../index.mjs";
+import { parseValue } from "../valueIO.mjs";
+import { decodeWire, encodeToWire, CORE_PATTERN_PROPERTY_LIST } from "../codecs/runtime/prefix-codec.mjs";
+import { Product, Variant } from "../Value.mjs";
+import { exportPatternGraph } from "../codecs/runtime/codec.mjs";
+import { patternToPropertyList } from "../codecs/runtime/pattern-json.mjs";
 import {
   compileObjectBuffer,
   compileLibraryBuffer,
@@ -14,7 +14,7 @@ import {
   runConvergedObject,
   decompileObjectBuffer,
   extractAliasesFromObject
-} from "./object.mjs";
+} from "../object.mjs";
 
 const value = parseValue("{a:{b:x,c:{}}}");
 const wire = encodeToWire(value, null);
@@ -96,7 +96,7 @@ const natDecompiledSource = decompileObjectBuffer(natLibraryBuffer);
 const natRoundTripSource = decompileObjectBuffer(
   compileLibraryBuffer(natDecompiledSource, { source: "Examples/nat.decompiled.k" })
 );
-const recursiveNatPattern = /\?\{<X0 succ, \.\.\.>=X0 x, <X1 succ, \.\.\.>=X1 y\} .* \?X1;/;
+const recursiveNatPattern = /\$dTww <\{\.x PgmQ x, \.y h4Wg y\} re64, \.y> \$e9WP;/;
 assert.equal(natRoundTripSource, natDecompiledSource);
 assert.match(natDecompiledSource, recursiveNatPattern);
 

package/tests/test-kvm.mjs

@@ -0,0 +1,163 @@
+import assert from "node:assert";
+import k from "../index.mjs";
+import { lowerToKVM, executeKVM } from "../kvm.mjs";
+import codes from "../codes.mjs";
+import { fromObject, Product, Variant } from "../Value.mjs";
+import run, { run_converged } from "../run.mjs";
+
+function runKVM(script, data, options = {}) {
+  const defs = k.annotate(script, {
+    convergence: { strategy: "auto" }
+  });
+  const mainRel = defs.rels.__main__;
+  const kvmFunc = lowerToKVM(mainRel, "__main__");
+  const context = { rels: defs.rels, findCode: codes.find, options };
+  return executeKVM(kvmFunc, fromObject(data), context);
+}
+
+function toJSON(value) {
+  if (value === undefined) return undefined;
+  return JSON.parse(JSON.stringify(value));
+}
+
+console.log("==> Starting kVM Tests");
+
+// Test 1: Identity
+{
+  const result = runKVM("()", { unit: {} });
+  assert.deepEqual(toJSON(result), "unit");
+  console.log("Test 1 (Identity): Passed");
+}
+
+// Test 2: Product field projection
+{
+  const result = runKVM(".name", { name: { ala: {} }, age: { twentythree: {} } });
+  assert.deepEqual(toJSON(result), "ala");
+  console.log("Test 2 (Field projection): Passed");
+}
+
+// Test 3: Variant projections and lifting
+{
+  const result = runKVM("/tag |tag", { tag: { payload: {} } });
+  assert.deepEqual(toJSON(result), { tag: "payload" });
+  console.log("Test 3 (Variant projection & construction): Passed");
+}
+
+// Test 4: Composition
+{
+  const result = runKVM("(.x .y)", { x: { y: { ok: {}, dummy: {} }, dummy: {} }, dummy: {} });
+  assert.deepEqual(toJSON(result), { ok: {}, dummy: {} });
+  console.log("Test 4 (Composition): Passed");
+}
+
+// Test 5: Union (Speculative choice)
+{
+  const result1 = runKVM("< /x, /y >", { x: { val: {} } });
+  assert.deepEqual(toJSON(result1), "val");
+
+  const result2 = runKVM("< /x, /y >", { y: { val: {} } });
+  assert.deepEqual(toJSON(result2), "val");
+
+  const result3 = runKVM("< /x, /y >", { z: { val: {} } });
+  assert.equal(result3, undefined);
+  console.log("Test 5 (Union / Choice): Passed");
+}
+
+// Test 6: Parallel Product
+{
+  const result = runKVM("{ .x fieldA, .y fieldB }", { x: { valA: {} }, y: { valB: {} } });
+  assert.deepEqual(toJSON(result), {
+    fieldA: "valA",
+    fieldB: "valB"
+  });
+  console.log("Test 6 (Product): Passed");
+}
+
+// Test 7: Filters & Types
+{
+  const script = `
+    $ bool = < {} true, {} false >;
+    $ bool
+  `;
+  const result1 = runKVM(script, { true: {} });
+  assert.deepEqual(toJSON(result1), "true");
+
+  const result2 = runKVM(script, { unknown_tag: {} });
+  assert.deepEqual(toJSON(result2), "unknown_tag");
+  console.log("Test 7 (Filters & Type Guards): Passed");
+}
+
+// Test 8: Recursive List traversal (Cons/Nil)
+{
+  const script = `
+    $ bool = < {} true, {} false >;
+    true = {} | true $bool;
+    false = {} | false $bool;
+    
+    list? = ?< {} nil, {X car, Y cdr} cons > = Y;
+    nil = {}|nil list?;
+    nil? = list? /nil nil;
+    car = list? /cons .car;
+    list? { 
+      < nil? true, false > nil_test,
+      < car, {}|none >  car 
+    }
+  `;
+
+  // Test Nil list
+  const res1 = runKVM(script, { nil: {} });
+  assert.deepEqual(toJSON(res1), { nil_test: "true", car: "none" });
+
+  // Test Cons list
+  const res2 = runKVM(script, {
+    cons: {
+      car: { unit: {} },
+      cdr: { nil: {} }
+    }
+  });
+  assert.deepEqual(toJSON(res2), { nil_test: "false", car: "unit" });
+  console.log("Test 8 (Recursive lists): Passed");
+}
+
+// Test 9: Comparing KVM execution vs Native JS run (Envelope-aware and Envelope-free)
+{
+  const script = `
+    $ nat = < {} 0, nat +1 >;
+    0 = {} | 0 $ nat;
+    inc = | +1 $ nat;
+    dec = $ nat / +1;
+    add = $ { nat x, nat y } <
+      { . x dec x, . y inc y } add,
+      . y
+    >;
+  `;
+
+  const inputData = {
+    x: { "+1": { "+1": { "0": {} } } }, // 2
+    y: { "+1": { "0": {} } }            // 1
+  };
+
+  // Run in native JS envelope-aware mode
+  const nativeAware = k.run(script + " add", inputData);
+  // Run in native JS envelope-free mode
+  const defs = k.annotate(script + " add", {
+    convergence: { strategy: "auto" }
+  });
+  run.defs = defs;
+  run_converged.defs = defs;
+  const nativeFree = run_converged(codes.find, defs.rels.__main__.def, fromObject(inputData), defs.rels.__main__.typePatternGraph);
+
+  // Run in kVM envelope-aware mode
+  const kvmAware = runKVM(script + " add", inputData, { envelopeFree: false });
+  // Run in kVM envelope-free mode
+  const kvmFree = runKVM(script + " add", inputData, { envelopeFree: true });
+
+  assert.deepEqual(toJSON(kvmAware), toJSON(nativeAware));
+  assert.deepEqual(toJSON(kvmFree), toJSON(nativeFree));
+  
+  // Verify that the output is 3 (i.e. +1(+1(+1(0))))
+  assert.deepEqual(toJSON(kvmAware), { "+1": { "+1": { "+1": "0" } } });
+  console.log("Test 9 (KVM vs JS run equivalence & Peano addition): Passed");
+}
+
+console.log("==> All kVM Tests Passed!");

package/{test-repl.mjs → tests/test-repl.mjs}

@@ -16,9 +16,9 @@ import {
   isMainEntrypoint,
   lineHasExplicitContinuation,
   lineTerminatesSnippet
-} from "./repl.mjs";
-import { decodeObject, objectToFunction } from "./object.mjs";
-import { Product } from "./Value.mjs";
+} from "../repl.mjs";
+import { decodeObject, objectToFunction } from "../object.mjs";
+import { Product } from "../Value.mjs";
 
 const state = createState();
 
@@ -90,6 +90,7 @@ await assert.rejects(
 
 const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "k-repl-"));
 const libPath = path.join(tmpDir, "session.klib");
+const recursiveLibPath = path.join(tmpDir, "recursive.klib");
 const koPath = path.join(tmpDir, "succ.ko");
 const sourcePath = path.join(tmpDir, "session.k");
 const codecPath = path.join(tmpDir, "bool-codec.mjs");
@@ -97,6 +98,23 @@ const symlinkPath = path.resolve(".test-k-repl-link");
 output = await evaluateInput(`:klib ${libPath}`, state);
 assert.equal(output[0], `saved ${libPath}`);
 
+const recursiveState = createState();
+await evaluateInput(":type $ nat = < {}_, nat 0, nat 1 >;", recursiveState);
+await evaluateInput(":rel 0? = $ nat < / _ {}|0, / 0 0? >;", recursiveState);
+const staleZeroHash = recursiveState.relAliases["0?"];
+await evaluateInput(":rel 0? = $ nat < / _ {}|_, / 0 0? >;", recursiveState);
+const zeroHash = recursiveState.relAliases["0?"];
+assert.notEqual(zeroHash, staleZeroHash);
+await evaluateInput("{}|_|0|0 $nat", recursiveState);
+assert.deepEqual(
+  Object.keys(recursiveState.rels).sort(),
+  [staleZeroHash, zeroHash].sort()
+);
+output = await evaluateInput(`:klib ${recursiveLibPath}`, recursiveState);
+assert.equal(output[0], `saved ${recursiveLibPath}`);
+const recursiveLibrary = JSON.parse(fs.readFileSync(recursiveLibPath, "utf8"));
+assert.deepEqual(Object.keys(recursiveLibrary.rels), [zeroHash]);
+
 completions = completeInput(`:load ${tmpDir}/ses`, state)[0];
 assert(completions.includes(`:load ${libPath}`));
 completions = completeInput(`:load --no-alias ${tmpDir}/ses`, state)[0];
@@ -176,7 +194,7 @@ assert.equal(output[0], `input ${utf8State.typeAliases.string} using utf8: enter
 output = await evaluateInput("hello", utf8State);
 assert.match(output[0], /utf8: hello/);
 
-const replPath = fileURLToPath(new URL("./repl.mjs", import.meta.url));
+const replPath = fileURLToPath(new URL("../repl.mjs", import.meta.url));
 try {
   fs.rmSync(symlinkPath, { force: true });
 } catch {}

package/{test.mjs → tests/test.mjs}

@@ -1,4 +1,4 @@
-import k from "./index.mjs";
+import k from "../index.mjs";
 
 [
   [{"unit": {}}, "()"],