@fraczak/k 6.3.2 → 6.4.0

package/tests/test-poly.mjs

@@ -0,0 +1,129 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { createState, evaluateInput } from "../backend-api.mjs";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const arithmeticsPath = path.join(root, "Examples/arithmetics.k");
+const polyPath = path.join(root, "Examples/poly.k");
+
+console.log("==> Running Polymorphic List Tests (Examples/poly.k)");
+
+const state = createState();
+await evaluateInput(`:load ${arithmeticsPath}`, state);
+await evaluateInput(`:load ${polyPath}`, state);
+
+async function evalK(snippet) {
+  const res = await evaluateInput(snippet, state);
+  assert.ok(res && res.length > 0 && !res[0].includes("undefined"), `Evaluation failed for: ${snippet}`);
+  return res[0];
+}
+
+// Test 1: Concat
+{
+  const res = await evalK(`
+    l1 = {{}|a car, {{}|b car, nil cdr} cons cdr} cons;
+    l2 = {{}|c car, {{}|d car, nil cdr} cons cdr} cons;
+    {l1 xs, l2 ys} concat
+  `);
+  assert.match(res, /\|a car.*\|b car.*\|c car.*\|d car/);
+  console.log("Test 1 (concat): Passed");
+}
+
+// Test 2: Reverse
+{
+  const res = await evalK(`
+    l = {{}|first car, {{}|second car, {{}|third car, nil cdr} cons cdr} cons cdr} cons;
+    l reverse
+  `);
+  assert.match(res, /\|third car.*\|second car.*\|first car/);
+  console.log("Test 2 (reverse): Passed");
+}
+
+// Test 3: Length
+{
+  const res = await evalK(`
+    l = {{}|a car, {{}|b car, {{}|c car, nil cdr} cons cdr} cons cdr} cons;
+    l length
+  `);
+  // 3 in LSB-first binary with '+' sign: |_|1|1|+
+  assert.match(res, /1.*1.*\+/);
+  console.log("Test 3 (length): Passed");
+}
+
+// Test 4: Get N-th
+{
+  const res0 = await evalK(`
+    l = {{}|item0 car, {{}|item1 car, {{}|item2 car, nil cdr} cons cdr} cons cdr} cons;
+    {0 int n, l xs} get_nth
+  `);
+  assert.match(res0, /\|item0/);
+
+  const res1 = await evalK(`{1 int n, l xs} get_nth`);
+  assert.match(res1, /\|item1/);
+
+  const res2 = await evalK(`{2 int n, l xs} get_nth`);
+  assert.match(res2, /\|item2/);
+  console.log("Test 4 (get_nth): Passed");
+}
+
+// Test 5: Split By
+{
+  const res = await evalK(`
+    l = {{}|a car, {{}|b car, {{}|c car, {{}|d car, nil cdr} cons cdr} cons cdr} cons cdr} cons;
+    {2 int n, l xs} split_by
+  `);
+  assert.match(res, /first/);
+  assert.match(res, /second/);
+  console.log("Test 5 (split_by): Passed");
+}
+
+// Test 6: Take and Drop
+{
+  const resTake = await evalK(`
+    l = {{}|a car, {{}|b car, {{}|c car, nil cdr} cons cdr} cons cdr} cons;
+    {2 int n, l xs} take
+  `);
+  assert.match(resTake, /\|a car.*\|b car/);
+
+  const resDrop = await evalK(`
+    {2 int n, l xs} drop
+  `);
+  assert.match(resDrop, /\|c car/);
+  console.log("Test 6 (take & drop): Passed");
+}
+
+// Test 7: Repeat
+{
+  const res = await evalK(`
+    {3 int n, {}|val x} repeat
+  `);
+  assert.match(res, /\|val car.*\|val car.*\|val car/);
+  console.log("Test 7 (repeat): Passed");
+}
+
+// Test 8: Append
+{
+  const res = await evalK(`
+    l = {{}|a car, {{}|b car, nil cdr} cons cdr} cons;
+    {{}|c x, l xs} append
+  `);
+  assert.match(res, /\|a car.*\|b car.*\|c car/);
+  console.log("Test 8 (append): Passed");
+}
+
+// Test 9: Zip
+{
+  const res = await evalK(`
+    l1 = {{}|k1 car, {{}|k2 car, nil cdr} cons cdr} cons;
+    l2 = {1 int car, {2 int car, nil cdr} cons cdr} cons;
+    {l1 xs, l2 ys} zip
+  `);
+  assert.match(res, /\|k1 x/);
+  assert.match(res, /\|k2 x/);
+  console.log("Test 9 (zip): Passed");
+}
+
+console.log("==> All Polymorphic List Tests Passed Successfully!");

package/tests/test-repl-html.mjs

@@ -0,0 +1,303 @@
+import assert from "node:assert";
+import fs from "node:fs";
+import path from "node:path";
+import { spawn, spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const root = path.resolve(__dirname, "..");
+const replHtmlPath = path.join(root, "repl.html");
+
+console.log("=== Testing Web REPL (repl.html) ===");
+
+// 1. Build repl.html
+console.log("1. Running scripts/build-repl-html.mjs...");
+const buildResult = spawnSync(process.execPath, [path.join(root, "scripts/build-repl-html.mjs")], {
+  cwd: root,
+  stdio: "pipe",
+  encoding: "utf8"
+});
+
+if (buildResult.status !== 0) {
+  console.error(buildResult.stderr || buildResult.stdout);
+  process.exit(buildResult.status ?? 1);
+}
+
+// 2. Validate self-contained HTML
+console.log("2. Validating generated repl.html...");
+assert(fs.existsSync(replHtmlPath), "repl.html must exist");
+const html = fs.readFileSync(replHtmlPath, "utf8");
+
+assert(html.length > 500000, `repl.html size (${html.length} bytes) is suspiciously small`);
+assert(html.includes("<!DOCTYPE html>"), "repl.html must be valid HTML5");
+assert(html.includes("<style>"), "repl.html must contain inlined CSS styles");
+assert(html.includes('<script type="module">'), "repl.html must contain inlined module script");
+assert(!html.includes('<script src="http'), "repl.html must NOT contain external remote scripts");
+assert(html.includes("wasm-in-process"), "repl.html must mention wasm-in-process engine");
+assert(html.includes("arithmetics.k"), "repl.html must embed standard examples");
+assert(html.includes("btn-codecs"), "repl.html must contain Codecs button");
+assert(html.includes("codecs-modal"), "repl.html must contain Codecs modal");
+assert(html.includes("active-codecs-tbody"), "repl.html must contain active codecs table");
+assert(html.includes("codec-preset-select"), "repl.html must contain codec preset templates");
+assert(html.includes("btn-input-popup"), "repl.html must contain input button");
+assert(html.includes("input-popup-modal"), "repl.html must contain input popup modal");
+console.log("   repl.html is valid, self-contained, and has size:", (html.length / 1024).toFixed(1), "KB");
+
+// 3. If Chromium is available, run end-to-end browser test
+const chromiumBin = ["chromium-browser", "chromium", "google-chrome"].find(bin => {
+  const res = spawnSync("which", [bin], { stdio: "ignore" });
+  return res.status === 0;
+});
+
+if (chromiumBin) {
+  console.log(`3. Running browser verification with ${chromiumBin}...`);
+  const tmpDir = `/tmp/chrome-test-${Date.now()}`;
+  fs.mkdirSync(tmpDir, { recursive: true });
+
+  const cdpPort = 9333 + Math.floor(Math.random() * 500);
+  const chrome = spawn(chromiumBin, [
+    "--headless=new",
+    "--disable-gpu",
+    `--remote-debugging-port=${cdpPort}`,
+    "--no-sandbox",
+    "--disable-extensions",
+    `--user-data-dir=${tmpDir}`,
+    `file://${replHtmlPath}`
+  ]);
+
+  try {
+    let wsUrl = null;
+    for (let i = 0; i < 30; i++) {
+      try {
+        const res = await fetch(`http://127.0.0.1:${cdpPort}/json/list`);
+        const list = await res.json();
+        const page = list.find(item => item.url && item.url.includes("repl.html"));
+        if (page && page.webSocketDebuggerUrl) {
+          wsUrl = page.webSocketDebuggerUrl;
+          break;
+        }
+      } catch {}
+      await new Promise(r => setTimeout(r, 200));
+    }
+
+    assert(wsUrl, `Could not connect to Chromium CDP on port ${cdpPort}`);
+
+    const ws = new WebSocket(wsUrl);
+    await new Promise(r => ws.onopen = r);
+
+    let idCounter = 1;
+    const pending = new Map();
+    ws.onmessage = (event) => {
+      const msg = JSON.parse(event.data);
+      if (msg.id && pending.has(msg.id)) {
+        const { resolve, reject } = pending.get(msg.id);
+        pending.delete(msg.id);
+        if (msg.error) reject(new Error(msg.error.message));
+        else resolve(msg.result);
+      }
+    };
+
+    function send(method, params = {}) {
+      const id = idCounter++;
+      return new Promise((resolve, reject) => {
+        pending.set(id, { resolve, reject });
+        ws.send(JSON.stringify({ id, method, params }));
+      });
+    }
+
+    await send("Page.enable");
+    await send("Runtime.enable");
+    await new Promise(r => setTimeout(r, 1200));
+
+    async function evaluateAsync(expression) {
+      const res = await send("Runtime.evaluate", {
+        expression,
+        awaitPromise: true,
+        returnByValue: true
+      });
+      if (res.exceptionDetails) {
+        throw new Error(res.exceptionDetails.exception?.description || "Evaluation error");
+      }
+      return res.result?.value;
+    }
+
+    // Wait for window.kRepl to be ready
+    await evaluateAsync(`new Promise((resolve, reject) => {
+      let tries = 0;
+      const check = () => {
+        if (window.kRepl && typeof window.kRepl.executeCommand === "function") resolve(true);
+        else if (++tries > 100) reject(new Error("Timeout waiting for window.kRepl"));
+        else setTimeout(check, 50);
+      };
+      check();
+    })`);
+
+    // Check UI initialized
+    const title = await evaluateAsync(`document.querySelector(".brand-name")?.textContent`);
+    assert.strictEqual(title, "k repl", "Brand name should be 'k repl'");
+
+    // Verify VFS curated files
+    const vfsList = await evaluateAsync(`window.kRepl.getAllVfsFiles().sort()`);
+    const expectedFiles = [
+      "arithmetics.k",
+      "core.k",
+      "ieee.k",
+      "ieee.mjs",
+      "int.mjs",
+      "json.mjs",
+      "unit.mjs",
+      "utf8.mjs"
+    ].sort();
+    assert.deepStrictEqual(vfsList, expectedFiles, `getAllVfsFiles() must match curated files list, got: ${JSON.stringify(vfsList)}`);
+
+    // Test :load arithmetics.k
+    const loadOut = await evaluateAsync(`(async () => {
+      await window.kRepl.executeCommand(":load arithmetics.k");
+      const lines = Array.from(document.querySelectorAll(".entry-line")).map(el => el.textContent);
+      return lines[lines.length - 1];
+    })()`);
+    assert(loadOut.includes("loaded arithmetics.k"), `Expected loaded arithmetics.k, got: ${loadOut}`);
+
+    // Test evaluating 10
+    const valOut = await evaluateAsync(`(async () => {
+      await window.kRepl.executeCommand("10");
+      const lines = Array.from(document.querySelectorAll(".entry-line")).map(el => el.textContent);
+      return lines[lines.length - 1];
+    })()`);
+    assert(valOut.includes("{}|_|0|1|0|1"), `Expected 10 in output, got: ${valOut}`);
+
+    // Test {10 int x, 5 int y} plus
+    const plusOut = await evaluateAsync(`(async () => {
+      await window.kRepl.executeCommand("{10 int x, 5 int y} plus");
+      const lines = Array.from(document.querySelectorAll(".entry-line")).map(el => el.textContent);
+      return lines[lines.length - 1];
+    })()`);
+    assert(plusOut.includes("{}|_|1|1|1|1|+"), `Expected 15 in output, got: ${plusOut}`);
+
+    // Test :codecs initially empty
+    const codecsOut = await evaluateAsync(`(async () => {
+      await window.kRepl.executeCommand(":codecs");
+      const lines = Array.from(document.querySelectorAll(".entry-line")).map(el => el.textContent);
+      return lines[lines.length - 1];
+    })()`);
+    assert.strictEqual(codecsOut, "(none)");
+
+    // Test :codec load int
+    const loadIntOut = await evaluateAsync(`(async () => {
+      await window.kRepl.executeCommand(":codec load int");
+      const lines = Array.from(document.querySelectorAll(".entry-line")).map(el => el.textContent);
+      return lines[lines.length - 1];
+    })()`);
+    assert(loadIntOut.includes("loaded codec int"), `Expected loaded codec int, got: ${loadIntOut}`);
+
+    // Check codecs badge updated to 1
+    const badgeCount = await evaluateAsync(`document.getElementById("codecs-count-badge")?.textContent`);
+    assert.strictEqual(badgeCount, "1", "Codecs badge count should be 1 after loading int codec");
+
+    // Test evaluating 10 int with int codec active -> output should format using int serializer
+    const formattedVal = await evaluateAsync(`(async () => {
+      await window.kRepl.executeCommand("10 int");
+      const lines = Array.from(document.querySelectorAll(".entry-line")).map(el => el.textContent);
+      return lines[lines.length - 1];
+    })()`);
+    assert(formattedVal.includes("int: 10"), `Expected 'int: 10' in output, got: ${formattedVal}`);
+
+    // Test defining inline custom codec via :codec define
+    await evaluateAsync(`window.kRepl.executeCommand(":type bool = <{} true, {} false>")`);
+    const defineCodecOut = await evaluateAsync(`(async () => {
+      await window.kRepl.executeCommand(":codec define yn bool ({ parse: (t) => Value.variant(t.trim() === 'yes' ? 'true' : 'false', Value.product({})), print: (v) => v.tag === 'true' ? 'YES' : 'NO' })");
+      const lines = Array.from(document.querySelectorAll(".entry-line")).map(el => el.textContent);
+      return lines[lines.length - 1];
+    })()`);
+    assert(defineCodecOut.includes("defined codec yn"), `Expected defined codec yn, got: ${defineCodecOut}`);
+
+    // Test modal interaction via openCodecsModal
+    const modalIsOpen = await evaluateAsync(`(() => {
+      window.kRepl.openCodecsModal();
+      return document.getElementById("codecs-modal")?.classList.contains("open");
+    })()`);
+    assert.strictEqual(modalIsOpen, true, "Codecs modal should open");
+
+    // Close codecs modal
+    await evaluateAsync(`(() => {
+      document.getElementById("codecs-modal")?.classList.remove("open");
+    })()`);
+
+    // Test :input opens input popup modal
+    await evaluateAsync(`window.kRepl.executeCommand(":input int")`);
+    const inputModalOpen = await evaluateAsync(`document.getElementById("input-popup-modal")?.classList.contains("open")`);
+    assert.strictEqual(inputModalOpen, true, "Executing :input int should open input popup modal");
+
+    // Enter value '55' in popup and submit
+    const submitResult = await evaluateAsync(`(async () => {
+      const textEl = document.getElementById("input-popup-text");
+      textEl.value = "55";
+      await window.kRepl.submitInputPopup();
+      const lines = Array.from(document.querySelectorAll(".entry-line")).map(el => el.textContent);
+      return lines[lines.length - 1];
+    })()`);
+    assert(submitResult.includes("int: 55"), `Expected int: 55 after submitting input popup, got: ${submitResult}`);
+
+    // Verify modal is closed after submission
+    const modalClosedAfterSubmit = await evaluateAsync(`!document.getElementById("input-popup-modal")?.classList.contains("open")`);
+    assert.strictEqual(modalClosedAfterSubmit, true, "Input modal should be closed after submit");
+
+    // Test :input directive without args opens input popup
+    await evaluateAsync(`window.kRepl.executeCommand(":input")`);
+    const inputWithoutArgsOpensModal = await evaluateAsync(`document.getElementById("input-popup-modal")?.classList.contains("open")`);
+    assert.strictEqual(inputWithoutArgsOpensModal, true, "Executing :input without args should open input popup");
+
+    // Test cancelInputPopup
+    await evaluateAsync(`window.kRepl.cancelInputPopup()`);
+    const modalClosedAfterCancel = await evaluateAsync(`!document.getElementById("input-popup-modal")?.classList.contains("open")`);
+    assert.strictEqual(modalClosedAfterCancel, true, "Input modal should close on cancel");
+
+    // Test JSON codec with float64 in browser: :input {string a, float64 n} then {"a":"Woj","n":123}
+    await evaluateAsync(`(async () => {
+      await window.kRepl.executeCommand(":load core.k");
+      await window.kRepl.executeCommand(":load ieee.k");
+      await window.kRepl.executeCommand(":codec load json");
+    })()`);
+    const inputPromptOut = await evaluateAsync(`(async () => {
+      await window.kRepl.executeCommand(":input {string a, float64 n}");
+      const lines = Array.from(document.querySelectorAll(".entry-line")).map(el => el.textContent);
+      return lines[lines.length - 1];
+    })()`);
+    assert(inputPromptOut.includes("enter value text"), `Expected input prompt, got: ${inputPromptOut}`);
+
+    // Enter JSON value with float64
+    const jsonResult = await evaluateAsync(`(async () => {
+      await window.kRepl.executeCommand('{"a":"Woj","n":123}');
+      const lines = Array.from(document.querySelectorAll(".entry-line")).map(el => el.textContent);
+      return lines[lines.length - 1];
+    })()`);
+    assert(jsonResult.includes('json: {"a":"Woj","n":123}'), `Expected json: {"a":"Woj","n":123}, got: ${jsonResult}`);
+
+    // Verify text selection holds in output element
+    const selectionCheck = await evaluateAsync(`(() => {
+      const output = document.getElementById("terminal-output");
+      const range = document.createRange();
+      range.selectNodeContents(output);
+      const sel = window.getSelection();
+      sel.removeAllRanges();
+      sel.addRange(range);
+      // Simulate click on terminal container/output
+      output.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+      return window.getSelection().toString().length > 0;
+    })()`);
+    assert.strictEqual(selectionCheck, true, "Selection in terminal output should hold after click");
+
+    ws.close();
+    console.log("   Browser execution verified successfully!");
+  } finally {
+    chrome.kill();
+    await new Promise(r => setTimeout(r, 500));
+    try {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    } catch {}
+  }
+} else {
+  console.log("3. Chromium not found, skipping headless browser CDP step.");
+}
+
+console.log("OK - Web REPL test passed.");

package/tests/test-repl.mjs

@@ -15,7 +15,8 @@ import {
   helpText,
   isMainEntrypoint,
   lineHasExplicitContinuation,
-  lineTerminatesSnippet
+  lineTerminatesSnippet,
+  promptForState
 } from "../repl.mjs";
 import { decodeObject, objectToFunction } from "../object.mjs";
 import { Value } from "../Value.mjs";
@@ -194,6 +195,36 @@ assert.equal(output[0], `input ${utf8State.typeAliases.string} using utf8: enter
 output = await evaluateInput("hello", utf8State);
 assert.match(output[0], /utf8: hello/);
 
+const jsonState = createState();
+output = await evaluateInput(":type bool = <{} true, {} false>", jsonState);
+assert.match(output[0], /^\$ bool = @/);
+output = await evaluateInput(":codec load ./codecs/json.mjs", jsonState);
+assert.match(output[0], /^loaded codec json for all types/);
+output = await evaluateInput(":codec list", jsonState);
+assert.match(output[0], /^json all /);
+completions = completeInput(":input bool j", jsonState)[0];
+assert(completions.includes(":input bool json"));
+output = await evaluateInput(":input bool", jsonState);
+assert.equal(output[0], `input ${jsonState.typeAliases.bool}: enter value text`);
+assert.equal(promptForState(jsonState), "json> ");
+output = await evaluateInput("true", jsonState);
+assert.match(output[0], /\{\}\|true \?</);
+assert.match(output[0], /json: true/);
+assert.equal(promptForState(jsonState), "> ");
+output = await evaluateInput(":input <{}true,{}false>", jsonState);
+assert.equal(output[0], `input ${jsonState.typeAliases.bool}: enter value text`);
+assert.equal(promptForState(jsonState), "json> ");
+output = await evaluateInput("false", jsonState);
+assert.match(output[0], /\{\}\|false \?</);
+assert.match(output[0], /json: false/);
+assert.equal(promptForState(jsonState), "> ");
+output = await evaluateInput(":input {bool left, bool right} json", jsonState);
+assert.match(output[0], /^input @[^ ]+ using json: enter value text$/);
+assert.equal(promptForState(jsonState), "json> ");
+output = await evaluateInput('{"left":true,"right":false}', jsonState);
+assert.match(output[0], /json: \{"left":true,"right":false\}/);
+assert.equal(promptForState(jsonState), "> ");
+
 const replPath = fileURLToPath(new URL("../repl.mjs", import.meta.url));
 try {
   fs.rmSync(symlinkPath, { force: true });
@@ -246,6 +277,149 @@ await assert.rejects(
   /Type Error|Unknown ref: 'type'|Parse error|Parse Error/
 );
 
+// Verify WebAssembly in-process backend supports TCO / stack safety on deep recursion
+const tcoState = createState();
+await evaluateInput(":type nat = <{} zero, nat succ>", tcoState);
+await evaluateInput(":rel countdown = $nat < /zero {}|zero, /succ countdown >", tcoState);
+
+let deepNat = Value.variant("zero", Value.product({}, [["closed-product", []]]), [["open-union", [["zero", 1]]], ["closed-product", []]]);
+for (let i = 0; i < 5000; i++) {
+  deepNat = Value.variant("succ", deepNat, [["open-union", [["succ", 1]]], ...deepNat.pattern]);
+}
+tcoState.value = deepNat;
+
+output = await evaluateInput("countdown", tcoState);
+assert.match(output[0], /^\{\}\|zero/);
+assert.equal(tcoState.value.toJSON(), "zero");
+
+// Verify loading library and evaluating constant/recursive relation from library
+const arithState = createState();
+output = await evaluateInput(":load Examples/arithmetics.k", arithState);
+assert.equal(output[0], "loaded Examples/arithmetics.k");
+output = await evaluateInput("10", arithState);
+assert.match(output[0], /^\{\}\|_\|0\|1\|0\|1/);
+output = await evaluateInput("{10 int x, 5 int y} plus", arithState);
+assert.match(output[0], /^\{\}\|_\|1\|1\|1\|1\|\+/);
+
+// Verify built-in codecs, :codecs, :codec define, and :codec unload
+const codecTestState = createState();
+output = await evaluateInput(":codecs", codecTestState);
+assert.equal(output[0], "(none)");
+
+output = await evaluateInput(":codec load int", codecTestState);
+assert.match(output[0], /^loaded codec int for @/);
+
+output = await evaluateInput(":codecs", codecTestState);
+assert.match(output[0], /^int @/);
+
+completions = completeInput(":codec un", codecTestState)[0];
+assert(completions.includes(":codec unload"));
+completions = completeInput(":codec unload ", codecTestState)[0];
+assert(completions.includes(":codec unload int"));
+completions = completeInput(":codec load i", codecTestState)[0];
+assert(completions.includes(":codec load int"));
+
+output = await evaluateInput(":codec unload int", codecTestState);
+assert.equal(output[0], "unloaded codec int");
+output = await evaluateInput(":codecs", codecTestState);
+assert.equal(output[0], "(none)");
+
+output = await evaluateInput(":type bool = <{} true, {} false>", codecTestState);
+output = await evaluateInput(
+  `:codec define yn bool ({ parse: (text) => Value.variant(text.trim() === "yes" ? "true" : "false", Value.product({})), print: (v) => v.tag === "true" ? "YES" : "NO" })`,
+  codecTestState
+);
+assert.match(output[0], /^defined codec yn for @/);
+
+output = await evaluateInput(":input bool yn", codecTestState);
+output = await evaluateInput("yes", codecTestState);
+assert.match(output[0], /yn: YES/);
+
+// Projection on product with variant field (avoids filter variable collisions)
+const projState = createState();
+output = await evaluateInput("{{}|a x, {} y}", projState);
+assert.match(output[0], /^\{\{\}\|a x, \{\} y\}/);
+output = await evaluateInput(".x", projState);
+assert.match(output[0], /^\{\}\|a/);
+
+const projState2 = createState();
+output = await evaluateInput("{{}|a a, {} y}", projState2);
+assert.match(output[0], /^\{\{\}\|a a, \{\} y\}/);
+output = await evaluateInput(".a", projState2);
+assert.match(output[0], /^\{\}\|a/);
+
+// Auto-loading dependencies and bidirectional type aliasing tests
+const autoLoadState = createState();
+output = await evaluateInput(":codec load int", autoLoadState);
+assert.match(output[0], /auto-loaded (?:Examples\/)?arithmetics\.k/);
+assert.ok(autoLoadState.typeAliases.int, "int type alias should be registered");
+output = await evaluateInput(":input int", autoLoadState);
+output = await evaluateInput("123", autoLoadState);
+assert.match(output[0], /int: 123/);
+
+const utf8AutoState = createState();
+output = await evaluateInput(":codec load utf8", utf8AutoState);
+assert.match(output[0], /auto-loaded core\.k/);
+assert.ok(utf8AutoState.typeAliases.utf8, "utf8 type alias should be registered");
+assert.ok(utf8AutoState.typeAliases.string, "string type alias should be registered");
+assert.equal(utf8AutoState.typeAliases.utf8, utf8AutoState.typeAliases.string);
+output = await evaluateInput(":input utf8", utf8AutoState);
+output = await evaluateInput("test utf8", utf8AutoState);
+assert.match(output[0], /utf8: test utf8/);
+
+const ieeeAutoState = createState();
+output = await evaluateInput(":codec load ieee", ieeeAutoState);
+assert.match(output[0], /auto-loaded (?:Examples\/)?ieee\.k/);
+assert.ok(ieeeAutoState.typeAliases.ieee, "ieee type alias should be registered");
+assert.ok(ieeeAutoState.typeAliases.float64, "float64 type alias should be registered");
+assert.equal(ieeeAutoState.typeAliases.ieee, ieeeAutoState.typeAliases.float64);
+
+const jsonInputState = createState();
+await evaluateInput(":load core.k", jsonInputState);
+await evaluateInput(":load ieee.k", jsonInputState);
+await evaluateInput(":codec load json", jsonInputState);
+output = await evaluateInput(":input {string a, float64 n}", jsonInputState);
+assert.match(output[0], /enter value text/);
+output = await evaluateInput('{"a":"Woj","n":123}', jsonInputState);
+assert.match(output[0], /json: \{"a":"Woj","n":123\}/);
+
+const unitState = createState();
+output = await evaluateInput(":codec load unit", unitState);
+assert.match(output[0], /loaded codec unit/);
+output = await evaluateInput(":input unit", unitState);
+assert.match(output[0], /enter value text/);
+output = await evaluateInput("{}", unitState);
+assert.match(output[0], /unit: \{\}/);
+
+const polyAutoState = createState();
+output = await evaluateInput(":load Examples/poly.k", polyAutoState);
+assert.equal(output[0], "loaded Examples/poly.k");
+assert.ok(polyAutoState.relAliases.reverse, "poly relations should be loaded");
+assert.ok(polyAutoState.typeAliases.int, "arithmetics int should be auto-loaded");
+
+// Verify :timing and :time commands
+const timingState = createState();
+output = await evaluateInput(":time ()", timingState);
+assert.equal(output[0], "{} ?{}");
+assert.match(output[1], /\/\* comp: .*, exec: .* \*\//);
+assert.ok(timingState.lastTiming);
+assert.ok(typeof timingState.lastTiming.compileMs === "number");
+assert.ok(typeof timingState.lastTiming.executeMs === "number");
+
+output = await evaluateInput(":timing on", timingState);
+assert.equal(output[0], "timing reporting enabled");
+assert.equal(timingState.showTiming, true);
+output = await evaluateInput("()", timingState);
+assert.equal(output[0], "{} ?{}");
+assert.match(output[1], /\/\* comp: .*, exec: .* \*\//);
+
+output = await evaluateInput(":timing off", timingState);
+assert.equal(output[0], "timing reporting disabled");
+assert.equal(timingState.showTiming, false);
+output = await evaluateInput("()", timingState);
+assert.equal(output.length, 1);
+assert.equal(output[0], "{} ?{}");
+
 fs.rmSync(tmpDir, { recursive: true, force: true });
 fs.rmSync(symlinkPath, { force: true });
 console.log("OK");

package/tests/test-validate-object.mjs

@@ -0,0 +1,40 @@
+import assert from "node:assert";
+import { compileLibraryBuffer, compileObjectBuffer, decodeObject } from "../object.mjs";
+import { objectToKIRP, retypeObjectRelation } from "../kir.mjs";
+import { validateKIRP, validateObjectPayload } from "../objects/validate.mjs";
+
+const object = decodeObject(compileObjectBuffer("id = (); id", { source: "validate.k" }));
+assert.equal(validateObjectPayload(object), object);
+assert.equal(validateKIRP(objectToKIRP(object)).format, "k-ir");
+const retyped = validateKIRP(retypeObjectRelation(object, "__main__", [["open-product", []]]));
+assert.equal(retyped.layer, "KIR-P");
+assert.equal(retyped.kind, "executable");
+assert(!("instanceKey" in retyped));
+
+const library = decodeObject(compileLibraryBuffer("succ = |succ;\n", { source: "validate-lib.k" }));
+assert.equal(validateObjectPayload(library), library);
+assert.equal(validateKIRP(objectToKIRP(library)).kind, "library");
+
+const badObject = {
+  ...object,
+  rels: {
+    ...object.rels,
+    __main__: {
+      ...object.rels.__main__,
+      typeDerivation: { status: "maybe" }
+    }
+  }
+};
+assert.throws(
+  () => validateObjectPayload(badObject),
+  /typeDerivation\.status must be one of/
+);
+
+const badKir = objectToKIRP(object);
+badKir.rels.__main__.inputPattern = 999;
+assert.throws(
+  () => validateKIRP(badKir),
+  /inputPattern is out of range/
+);
+
+console.log("OK");