@fraczak/k 6.2.0 → 6.2.1

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/tests/code-derivation/codec-witness-pattern.mjs

@@ -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/tests/integration.sh

@@ -5,6 +5,9 @@ set -euo pipefail
 
 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 
 echo '-21' | node ./codecs/int.mjs --parse | node ./codecs/int.mjs --print | grep -qx -- '-21'
@@ -13,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/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!");