@fraczak/k 7.0.2 → 7.2.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

@@ -140,6 +140,7 @@ if (chromiumBin) {
     const expectedFiles = [
       "arithmetics.k",
       "core.k",
+      "djson.mjs",
       "ieee.k",
       "ieee.mjs",
       "int.mjs",
@@ -622,9 +623,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 +636,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

@@ -226,6 +226,18 @@ output = await evaluateInput(':input json.mjs {"left":true,"right":false}', json
 assert.match(output[0], /json\.mjs: \{"left":true,"right":false\}/);
 assert.equal(promptForState(jsonState), "> ");
 
+// Test djson.mjs in repl
+const djsonState = createState();
+output = await evaluateInput(":codec load ./codecs/djson.mjs", djsonState);
+assert.match(output[0], /^loaded codec djson\.mjs/);
+completions = completeInput(":input dj", djsonState)[0];
+assert(completions.includes(":input djson.mjs"));
+output = await evaluateInput(
+  ':input djson.mjs {"msg":"hello","values":[1,2]}',
+  djsonState
+);
+assert.match(output[0], /djson\.mjs: \{"msg":"hello","values":\[1,2\]\}/);
+
 const replPath = fileURLToPath(new URL("../repl.mjs", import.meta.url));
 try {
   fs.rmSync(symlinkPath, { force: true });
@@ -471,6 +483,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 +499,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 +526,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);
@@ -519,6 +560,27 @@ output = await evaluateInput("len", wasmListState);
 assert.match(output[0], /int\.mjs:\s*3/);
 assert.match(output[1], /\(wasm\)/);
 
+// Verify :limit command and bounded printing
+const limitState = createState({ engine: "wasm" });
+output = await evaluateInput(":limit", limitState);
+assert.equal(output[0], "Current output limit: none");
+
+output = await evaluateInput(":limit 40", limitState);
+assert.equal(output[0], "output limit set to 40");
+
+output = await evaluateInput(":limit", limitState);
+assert.equal(output[0], "Current output limit: 40");
+
+output = await evaluateInput(":load Examples/arithmetics.k", limitState);
+output = await evaluateInput("{ 10 int x, 5 int y } plus", limitState);
+assert(output[0].includes("..."));
+assert(output[0].length <= 80);
+
+output = await evaluateInput(":limit none", limitState);
+assert.equal(output[0], "output limit disabled");
+output = await evaluateInput(":limit", limitState);
+assert.equal(output[0], "Current output limit: none");
+
 fs.rmSync(tmpDir, { recursive: true, force: true });
 fs.rmSync(symlinkPath, { force: true });
 console.log("OK");

package/backends/llvm/bin/k-llvm-jit.mjs

@@ -1,160 +0,0 @@
-#!/usr/bin/env node
-
-import crypto from "node:crypto";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { spawn } from "node:child_process";
-import { argv, exit, stdin, stdout } from "node:process";
-import { fileURLToPath } from "node:url";
-import { decodeObject } from "@fraczak/k/object.mjs";
-import { decodeWire } from "@fraczak/k/codecs/runtime/prefix-codec.mjs";
-import { compileObjectToExecutable } from "../src/executable.mjs";
-
-const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-
-function usage(stream = console.error) {
-  const prog = argv[1] || "k-llvm-jit.mjs";
-  stream(`Usage: node ${prog} [options] object-file`);
-  stream("Compile and execute a k .ko/.klib object against the stdin binary envelope.");
-  stream("");
-  stream("The runner reads a binary k pattern+value envelope from stdin, specializes");
-  stream("the object with that envelope pattern, then writes a binary envelope to stdout.");
-  stream("");
-  stream("Options:");
-  stream("  --retype rel            Relation to specialize. Defaults to object main.");
-  stream("  --cache-dir path        Directory for compiled native executables.");
-  stream("  --no-cache              Compile in a temporary directory and remove it after execution.");
-  stream("  -h, --help              Show this help.");
-}
-
-async function readStdinBuffer() {
-  const chunks = [];
-  for await (const chunk of stdin) {
-    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-  }
-  return Buffer.concat(chunks);
-}
-
-let cachedBackendFingerprint = null;
-
-function backendFingerprint() {
-  if (cachedBackendFingerprint != null) return cachedBackendFingerprint;
-  const hash = crypto.createHash("sha256");
-  for (const relPath of ["src/llvm.mjs", "src/kvm2llvm.mjs", "src/executable.mjs", "runtime/krt.c", "runtime/krt.h"]) {
-    hash.update(relPath);
-    hash.update("\0");
-    hash.update(fs.readFileSync(path.join(root, relPath)));
-    hash.update("\0");
-  }
-  cachedBackendFingerprint = hash.digest("hex").slice(0, 16);
-  return cachedBackendFingerprint;
-}
-
-function cacheKey({ objectBuffer, relation, inputPattern }) {
-  const hash = crypto.createHash("sha256");
-  hash.update("k-llvm-jit-v2\0");
-  hash.update(backendFingerprint());
-  hash.update("\0");
-  hash.update(relation);
-  hash.update("\0");
-  hash.update(JSON.stringify(inputPattern));
-  hash.update("\0");
-  hash.update(objectBuffer);
-  return hash.digest("hex");
-}
-
-function runExecutable(exePath, inputBuffer) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(exePath, [], { stdio: ["pipe", "pipe", "pipe"] });
-    const stdoutChunks = [];
-    const stderrChunks = [];
-
-    child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
-    child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
-    child.on("error", reject);
-    child.on("close", (status) => {
-      if (status !== 0) {
-        const stderr = Buffer.concat(stderrChunks).toString("utf8");
-        reject(new Error(`${exePath} failed with status ${status}${stderr ? `\n${stderr}` : ""}`));
-        return;
-      }
-      resolve(Buffer.concat(stdoutChunks));
-    });
-
-    child.stdin.end(inputBuffer);
-  });
-}
-
-function compileCached({ object, objectBuffer, relation, inputPattern, cacheDir }) {
-  fs.mkdirSync(cacheDir, { recursive: true });
-  const key = cacheKey({ objectBuffer, relation, inputPattern });
-  const exePath = path.join(cacheDir, `${key}.exe`);
-  if (!fs.existsSync(exePath)) {
-    const tmpPath = path.join(cacheDir, `${key}.${process.pid}.tmp`);
-    compileObjectToExecutable(object, tmpPath, { relation, inputPattern });
-    fs.renameSync(tmpPath, exePath);
-  }
-  return exePath;
-}
-
-function compileTemporary({ object, relation, inputPattern }) {
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "k-llvm-jit-"));
-  const exePath = path.join(tmpDir, "program");
-  compileObjectToExecutable(object, exePath, { relation, inputPattern });
-  return { exePath, tmpDir };
-}
-
-try {
-  const args = argv.slice(2);
-  if (args.includes("-h") || args.includes("--help")) {
-    usage(console.log);
-    exit(0);
-  }
-
-  let relation = null;
-  let cacheDir = path.join(os.tmpdir(), "k-llvm-jit-cache");
-  let useCache = true;
-  while (args.length > 0 && args[0].startsWith("--")) {
-    const option = args.shift();
-    if (option === "--retype") {
-      relation = args.shift();
-      if (!relation) throw new Error("--retype requires a relation name");
-    } else if (option === "--cache-dir") {
-      cacheDir = args.shift();
-      if (!cacheDir) throw new Error("--cache-dir requires a path");
-    } else if (option === "--no-cache") {
-      useCache = false;
-    } else {
-      throw new Error(`Unknown option: ${option}`);
-    }
-  }
-
-  const objectPath = args.shift() || null;
-  if (objectPath == null) throw new Error("object-file is required");
-  if (args.length > 0) throw new Error(`Unexpected argument: ${args[0]}`);
-
-  const objectBuffer = fs.readFileSync(objectPath);
-  const object = decodeObject(objectBuffer);
-  const relationName = relation || object.main;
-  const inputBuffer = await readStdinBuffer();
-  const { pattern: inputPattern } = decodeWire(inputBuffer);
-
-  let tmpDir = null;
-  try {
-    const exePath = useCache
-      ? compileCached({ object, objectBuffer, relation: relationName, inputPattern, cacheDir })
-      : (() => {
-          const compiled = compileTemporary({ object, relation: relationName, inputPattern });
-          tmpDir = compiled.tmpDir;
-          return compiled.exePath;
-        })();
-    stdout.write(await runExecutable(exePath, inputBuffer));
-  } finally {
-    if (tmpDir != null) fs.rmSync(tmpDir, { recursive: true, force: true });
-  }
-} catch (error) {
-  console.error(error.stack || error.message || String(error));
-  usage();
-  exit(1);
-}