@fraczak/k 6.8.0 → 6.10.1

package/tests/test-codecs.mjs

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import * as SDK from "../codecs/runtime/codec-sdk.mjs";
+import * as IntCodec from "../codecs/int.mjs";
+import * as JsonCodec from "../codecs/json.mjs";
+import * as Utf8Codec from "../codecs/utf8.mjs";
+import * as Utf16Codec from "../codecs/utf16.mjs";
+import * as IeeeCodec from "../codecs/ieee.mjs";
+import * as UnitCodec from "../codecs/unit.mjs";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+function runCLI(codecRelPath, args, input = null) {
+  const inputBuffer = typeof input === "string" ? Buffer.from(input, "utf8") : input;
+  const res = spawnSync(process.execPath, [path.join(root, codecRelPath), ...args], {
+    input: inputBuffer,
+    encoding: null
+  });
+  return {
+    status: res.status,
+    stdout: res.stdout,
+    stderr: res.stderr,
+    stdoutText: res.stdout ? res.stdout.toString("utf8") : "",
+    stderrText: res.stderr ? res.stderr.toString("utf8") : ""
+  };
+}
+
+console.log("=== Testing Codec Architecture & CLI Contract ===");
+
+// 1. SDK Exports
+console.log("1. Verifying SDK exports...");
+assert.equal(typeof SDK.Value, "function");
+assert.equal(typeof SDK.isProduct, "function");
+assert.equal(typeof SDK.isVariant, "function");
+assert.equal(typeof SDK.withPattern, "function");
+assert.equal(typeof SDK.encodeToWire, "function");
+assert.equal(typeof SDK.decodeWire, "function");
+assert.equal(typeof SDK.runCodecCLI, "function");
+assert.equal(typeof SDK.isMainEntrypoint, "function");
+assert.equal(typeof SDK.patternFromFilter, "function");
+
+// 2. In-memory Enveloped Value Contract
+console.log("2. Verifying in-memory parse -> enveloped value (P, v)...");
+for (const [name, codec, sampleInput] of [
+  ["int.mjs", IntCodec, "42"],
+  ["json.mjs", JsonCodec, '{"x": 1}'],
+  ["utf8.mjs", Utf8Codec, "hello"],
+  ["utf16.mjs", Utf16Codec, "hello"],
+  ["ieee.mjs", IeeeCodec, "3.14"],
+  ["unit.mjs", UnitCodec, undefined]
+]) {
+  assert.equal(typeof codec.parse, "function", `${name} must export parse()`);
+  assert.equal(typeof codec.print, "function", `${name} must export print()`);
+  const parsed = sampleInput !== undefined ? codec.parse(sampleInput) : codec.parse();
+  assert(parsed && typeof parsed === "object", `${name} parse() must return an object`);
+  assert(parsed.pattern, `${name} parse() must produce an enveloped value with .pattern`);
+  const printed = codec.print(parsed);
+  assert(printed !== undefined, `${name} print() must return a formatted result`);
+}
+
+// 3. CLI --help Flag
+console.log("3. Verifying CLI --help flag...");
+for (const relPath of [
+  "codecs/int.mjs",
+  "codecs/json.mjs",
+  "codecs/utf8.mjs",
+  "codecs/utf16.mjs",
+  "codecs/ieee.mjs",
+  "codecs/unit.mjs"
+]) {
+  const res = runCLI(relPath, ["--help"]);
+  assert.equal(res.status, 0, `${relPath} --help should exit 0`);
+  assert(res.stdoutText.includes("Usage:"), `${relPath} --help should output usage`);
+  assert(res.stdoutText.includes("--parse"), `${relPath} --help should mention --parse`);
+  assert(res.stdoutText.includes("--print"), `${relPath} --help should mention --print`);
+}
+
+// 4. CLI --parse and --print Pipelines
+console.log("4. Verifying CLI --parse and --print pipelines...");
+
+// int.mjs: single integer
+{
+  const parseRes = runCLI("codecs/int.mjs", ["--parse"], "-12345\n");
+  assert.equal(parseRes.status, 0);
+  const printRes = runCLI("codecs/int.mjs", ["--print"], parseRes.stdout);
+  assert.equal(printRes.status, 0);
+  assert.equal(printRes.stdout.toString("utf8").trim(), "-12345");
+}
+
+// int.mjs: integer list
+{
+  const parseRes = runCLI("codecs/int.mjs", ["--parse"], "[0, 1, -2, 3]\n");
+  assert.equal(parseRes.status, 0);
+  const printRes = runCLI("codecs/int.mjs", ["--print"], parseRes.stdout);
+  assert.equal(printRes.status, 0);
+  assert.equal(printRes.stdout.toString("utf8").trim(), "[0,1,-2,3]");
+}
+
+// json.mjs: complex JSON
+{
+  const jsonInput = JSON.stringify({ name: "k", active: true, count: 42, tags: ["fast", "typed"] });
+  const parseRes = runCLI("codecs/json.mjs", ["--parse"], jsonInput);
+  assert.equal(parseRes.status, 0);
+  const printRes = runCLI("codecs/json.mjs", ["--print"], parseRes.stdout);
+  assert.equal(printRes.status, 0);
+  assert.deepEqual(JSON.parse(printRes.stdout.toString("utf8")), JSON.parse(jsonInput));
+}
+
+// utf8.mjs: unicode text
+{
+  const utf8Input = "Hello 🌍, ąęćłó! \nSecond line.";
+  const parseRes = runCLI("codecs/utf8.mjs", ["--parse"], utf8Input);
+  assert.equal(parseRes.status, 0);
+  const printRes = runCLI("codecs/utf8.mjs", ["--print"], parseRes.stdout);
+  assert.equal(printRes.status, 0);
+  assert.equal(printRes.stdout.toString("utf8"), utf8Input);
+}
+
+// ieee.mjs: floating point
+{
+  const parseRes = runCLI("codecs/ieee.mjs", ["--parse"], "2.71828\n");
+  assert.equal(parseRes.status, 0);
+  const printRes = runCLI("codecs/ieee.mjs", ["--print"], parseRes.stdout);
+  assert.equal(printRes.status, 0);
+  assert.equal(printRes.stdout.toString("utf8").trim(), "2.71828");
+}
+
+// unit.mjs: {}
+{
+  const parseRes = runCLI("codecs/unit.mjs", ["--parse"], "");
+  assert.equal(parseRes.status, 0);
+  const printRes = runCLI("codecs/unit.mjs", ["--print"], parseRes.stdout);
+  assert.equal(printRes.status, 0);
+  assert.equal(printRes.stdout.toString("utf8").trim(), "{}");
+}
+
+// 5. Error Handling
+console.log("5. Verifying CLI error handling...");
+{
+  // Unknown flag
+  const res = runCLI("codecs/int.mjs", ["--unknown"]);
+  assert.equal(res.status, 1);
+  assert(res.stderrText.includes("Usage:"));
+}
+
+{
+  // Invalid parse syntax
+  const res = runCLI("codecs/int.mjs", ["--parse"], "not_a_number");
+  assert.equal(res.status, 1);
+  assert(res.stderrText.includes("Invalid integer syntax"));
+}
+
+{
+  // Invalid wire input to --print
+  const res = runCLI("codecs/int.mjs", ["--print"], Buffer.from([0x00, 0x01]));
+  assert.equal(res.status, 1);
+}
+
+// 6. Pattern Derivation via k Type System
+console.log("6. Verifying pattern derivation via k type system (patternFromFilter)...");
+{
+  const intPat = SDK.patternFromFilter('?< <bits 0, bits 1, {} _>=bits "+", bits "-">');
+  assert.deepEqual(IntCodec.INT_PATTERN, intPat);
+
+  const unitPat = SDK.patternFromFilter("?{}");
+  assert.deepEqual(UnitCodec.UNIT_PATTERN, unitPat);
+
+  const listPat = SDK.patternFromFilter(
+    '$ bits = < bits 0, bits 1, {} _ >; $ int = < bits "+", bits "-" >; ?< {} nil, { $int car, list cdr } cons > = list'
+  );
+  assert.deepEqual(IntCodec.INT_LIST_PATTERN, listPat);
+
+  // Verify caching returns identical structure
+  const cached = SDK.patternFromFilter("?{}");
+  assert.deepEqual(cached, unitPat);
+
+  // Verify error when script is not a filter or type expression
+  assert.throws(() => SDK.patternFromFilter(".field"), /Main expression must be a filter or a type name/);
+}
+
+console.log("OK - All codec tests passed.");

package/tests/test-poly.mjs

@@ -126,4 +126,48 @@ async function evalK(snippet) {
   console.log("Test 9 (zip): Passed");
 }
 
+// Test 10: Split, Merge, and Merge Sort
+{
+  const resNil = await evalK(`nil sort`);
+  assert.match(resNil, /\|nil/);
+
+  const resSingle = await evalK(`
+    l = {1 int car, nil cdr} cons;
+    l sort
+  `);
+  assert.match(resSingle, /1/);
+
+  const resSplit = await evalK(`
+    l4 = {1 int car, {2 int car, {3 int car, {4 int car, nil cdr} cons cdr} cons cdr} cons cdr} cons;
+    l4 split
+  `);
+  assert.match(resSplit, /first.*second/);
+
+  const resSorted = await evalK(`
+    gt_int? = { { .x /"+" x, .y /"+" y } GT if, () then } .then;
+    _merge = <
+      {.xs /nil if, .ys then} .then,
+      {.ys /nil if, .xs then} .then,
+      {
+        {.xs car x, .ys car y} gt_int? if,
+        {.ys car car, {.xs xs, .ys cdr ys} _merge cdr} cons then
+      } .then,
+      {.xs car car, {.xs cdr xs, .ys ys} _merge cdr} cons
+    >;
+    _sort = list? <
+      /nil nil,
+      /cons <
+        {.cdr /nil if, .car singleton then} .then,
+        |cons split {.first _sort xs, .second _sort ys} _merge
+      >
+    > list?;
+    l = {5 int car, {2 int car, {4 int car, {1 int car, {3 int car, nil cdr} cons cdr} cons cdr} cons cdr} cons cdr} cons;
+    l _sort
+  `);
+  assert.match(resSorted, /\|1.*\|0\|1.*\|1\|1.*\|0\|0\|1.*\|1\|0\|1/);
+  console.log("Test 10 (split, merge, sort): Passed");
+}
+
 console.log("==> All Polymorphic List Tests Passed Successfully!");
+
+

package/tests/test-repl-html.mjs

@@ -37,10 +37,9 @@ assert(html.includes("wasm-in-process"), "repl.html must mention wasm-in-process
 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");
+assert(html.includes("enabled-codecs-grid"), "repl.html must contain enabled codecs grid");
+assert(!html.includes("btn-input-popup"), "repl.html must NOT contain input button");
+assert(!html.includes("input-popup-modal"), "repl.html must NOT 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
@@ -183,90 +182,127 @@ if (chromiumBin) {
     })()`);
     assert.strictEqual(codecsOut, "(none)");
 
-    // Test :codec load int
+    // Test :codec load int.mjs
     const loadIntOut = await evaluateAsync(`(async () => {
-      await window.kRepl.executeCommand(":codec load int");
+      await window.kRepl.executeCommand(":codec load int.mjs");
       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}`);
+    assert(loadIntOut.includes("loaded codec int.mjs"), `Expected loaded codec int.mjs, 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");
+    assert.strictEqual(badgeCount, "1", "Codecs badge count should be 1 after loading int.mjs codec");
 
-    // Test evaluating 10 int with int codec active -> output should format using int serializer
+    // Test evaluating 10 int with int.mjs codec active -> output should format using int.mjs 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}`);
+    assert(formattedVal.includes("int.mjs: 10"), `Expected 'int.mjs: 10' in output, got: ${formattedVal}`);
 
-    // Test defining custom codec via Custom Codec Studio UI
-    await evaluateAsync(`window.kRepl.executeCommand("$ yes_no = < {} yes, {} no >;");`);
-    const defineCodecOut = await evaluateAsync(`(async () => {
+    // Test modal interaction via openCodecsModal (only enabled codecs shown)
+    const modalCheck = await evaluateAsync(`(() => {
       window.kRepl.openCodecsModal();
-      const typeSelect = document.getElementById("codec-custom-type");
-      if (typeSelect) typeSelect.value = "yes_no";
-      document.getElementById("btn-register-codec").click();
-      return document.getElementById("codec-studio-status")?.textContent || "";
+      const modal = document.getElementById("codecs-modal");
+      const cardInt = document.getElementById("card-codec-int_mjs");
+      const grid = document.getElementById("enabled-codecs-grid");
+      const cards = grid ? Array.from(grid.querySelectorAll(".codec-card")) : [];
+
+      return {
+        open: modal?.classList.contains("open"),
+        hasIntCard: Boolean(cardInt),
+        cardCount: cards.length
+      };
     })()`);
-    assert(defineCodecOut.includes("Successfully registered codec yn"), `Expected defined codec yn, got: ${defineCodecOut}`);
+    assert.strictEqual(modalCheck.open, true, "Codecs modal should open");
+    assert.strictEqual(modalCheck.hasIntCard, true, "Card for enabled int.mjs codec should exist");
+    assert.strictEqual(modalCheck.cardCount, 1, "Only 1 enabled codec card should exist");
 
-    // Test modal interaction via openCodecsModal
-    const modalIsOpen = await evaluateAsync(`(() => {
+    // Test loading unit.mjs via REPL command
+    const loadUnitOut = await evaluateAsync(`(async () => {
+      await window.kRepl.executeCommand(":codec load unit.mjs");
       window.kRepl.openCodecsModal();
-      return document.getElementById("codecs-modal")?.classList.contains("open");
+      const cardUnit = document.getElementById("card-codec-unit_mjs");
+      const badge = document.getElementById("codecs-count-badge");
+      return {
+        hasUnitCard: Boolean(cardUnit),
+        badgeCount: badge?.textContent
+      };
     })()`);
-    assert.strictEqual(modalIsOpen, true, "Codecs modal should open");
+    assert.strictEqual(loadUnitOut.hasUnitCard, true, "card-codec-unit_mjs should exist after loading unit.mjs");
+    assert.strictEqual(loadUnitOut.badgeCount, "2", "Badge count should be 2 after loading unit.mjs");
+
+    // Test unloading unit.mjs via card Unload button
+    const unloadUnitCheck = await evaluateAsync(`(async () => {
+      const unloadBtn = document.querySelector("#card-codec-unit_mjs .btn-danger");
+      unloadBtn.click();
+      await new Promise(r => setTimeout(r, 60));
+      const cardUnit = document.getElementById("card-codec-unit_mjs");
+      const badge = document.getElementById("codecs-count-badge");
+      return {
+        hasUnitCard: Boolean(cardUnit),
+        badgeCount: badge?.textContent
+      };
+    })()`);
+    assert.strictEqual(unloadUnitCheck.hasUnitCard, false, "card-codec-unit_mjs should be removed after Unload");
+    assert.strictEqual(unloadUnitCheck.badgeCount, "1", "Badge count should be 1 after unloading unit.mjs");
 
     // 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");
+    // Test :input directive without args outputs usage in terminal
+    await evaluateAsync(`window.kRepl.executeCommand(":input")`);
+    const inputUsageCheck = await evaluateAsync(`(() => {
+      const lines = Array.from(document.querySelectorAll(".entry-line")).map(el => el.textContent);
+      return lines.slice(-2).join(" ");
+    })()`);
+    assert(inputUsageCheck.includes("Usage: :input <codec.mjs> [text]"), `Expected usage text, got: ${inputUsageCheck}`);
+
+    // Test :input int.mjs sets prompt to int.mjs>
+    await evaluateAsync(`window.kRepl.executeCommand(":input int.mjs")`);
+    const promptAfterInput = await evaluateAsync(`document.getElementById("prompt-label")?.textContent`);
+    assert.strictEqual(promptAfterInput, "int.mjs> ", `Expected prompt label 'int.mjs> ', got: '${promptAfterInput}'`);
 
-    // Enter value '55' in popup and submit
+    // Enter value '55' at the prompt
     const submitResult = await evaluateAsync(`(async () => {
-      const textEl = document.getElementById("input-popup-text");
-      textEl.value = "55";
-      await window.kRepl.submitInputPopup();
+      await window.kRepl.executeCommand("55");
       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");
+    assert(submitResult.includes("int.mjs: 55"), `Expected int.mjs: 55 after entering value, got: ${submitResult}`);
+
+    // Verify prompt is restored to '> '
+    const promptAfterValue = await evaluateAsync(`document.getElementById("prompt-label")?.textContent`);
+    assert.strictEqual(promptAfterValue, "> ", `Expected prompt label '> ', got: '${promptAfterValue}'`);
+
+    // Test Tab autocompletion for :input: typing ":input " and pressing Tab does NOT repeat :input
+    const tabCompletionCheck = await evaluateAsync(`(() => {
+      const inputEl = document.getElementById("repl-input");
+      inputEl.value = ":input ";
+      inputEl.selectionStart = inputEl.selectionEnd = 7;
+      const event = new KeyboardEvent("keydown", { key: "Tab", bubbles: true, cancelable: true });
+      inputEl.dispatchEvent(event);
+      return {
+        value: inputEl.value,
+        hasDuplicates: inputEl.value.includes(":input :input")
+      };
+    })()`);
+    assert.strictEqual(tabCompletionCheck.hasDuplicates, false, `:input Tab completion duplicated command: '${tabCompletionCheck.value}'`);
+    assert(tabCompletionCheck.value.startsWith(":input int.mjs"), `Expected completion to start with ':input int.mjs', got: '${tabCompletionCheck.value}'`);
 
-    // Test JSON codec with float64 in browser: :input {string a, float64 n} then {"a":"Woj","n":123}
+    // Test JSON codec with float64 in browser: :input json.mjs 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");
+      await window.kRepl.executeCommand(":codec load json.mjs");
+      await window.kRepl.executeCommand(":input json.mjs");
     })()`);
-    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}`);
+    const jsonPromptCheck = await evaluateAsync(`document.getElementById("prompt-label")?.textContent`);
+    assert.strictEqual(jsonPromptCheck, "json.mjs> ", `Expected prompt 'json.mjs> ', got: '${jsonPromptCheck}'`);
 
     // Enter JSON value with float64
     const jsonResult = await evaluateAsync(`(async () => {
@@ -274,33 +310,54 @@ if (chromiumBin) {
       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}`);
+    assert(jsonResult.includes('json.mjs: {"a":"Woj","n":123}'), `Expected json.mjs: {"a":"Woj","n":123}, got: ${jsonResult}`);
 
     // Verify Reset button is removed from navbar
     const hasResetBtn = await evaluateAsync(`Boolean(document.getElementById("btn-reset"))`);
     assert.strictEqual(hasResetBtn, false, "Reset button should be removed from navbar");
 
-    // Test explicit pattern expression :input ? {string a, float64 n} json
+    // Test one-line codec input: :input json.mjs {"a":"Test","n":456}
     await evaluateAsync(`(async () => {
-      await window.kRepl.executeCommand(":input ? {string a, float64 n} json");
-      await window.kRepl.executeCommand('{"a":"Test","n":456}');
+      await window.kRepl.executeCommand(':input json.mjs {"a":"Test","n":456}');
     })()`);
     const patternResult = await evaluateAsync(`(() => {
       const lines = Array.from(document.querySelectorAll(".entry-line")).map(el => el.textContent);
       return lines[lines.length - 1];
     })()`);
-    assert(patternResult.includes('json: {"a":"Test","n":456}'), `Expected json: {"a":"Test","n":456}, got: ${patternResult}`);
+    assert(patternResult.includes('json.mjs: {"a":"Test","n":456}'), `Expected json.mjs: {"a":"Test","n":456}, got: ${patternResult}`);
+
+    // Test integer list input: :input int.mjs [0,1,2]
+    await evaluateAsync(`(async () => {
+      await window.kRepl.executeCommand(":input int.mjs [0,1,2]");
+    })()`);
+    const listResult = await evaluateAsync(`(() => {
+      const lines = Array.from(document.querySelectorAll(".entry-line")).map(el => el.textContent);
+      return lines[lines.length - 1];
+    })()`);
+    assert(listResult.includes('int.mjs: [0,1,2]'), `Expected int.mjs: [0,1,2], got: ${listResult}`);
 
-    // Test standalone codec input :input json without pre-declared type
+    // Test utf8.mjs input: :input utf8.mjs Hello world
     await evaluateAsync(`(async () => {
-      await window.kRepl.executeCommand(":input json");
-      await window.kRepl.executeCommand('{"foo":"bar"}');
+      await window.kRepl.executeCommand(":codec load utf8.mjs");
+      await window.kRepl.executeCommand(":input utf8.mjs Hello world");
     })()`);
-    const standaloneResult = await evaluateAsync(`(() => {
+    const utf8Result = await evaluateAsync(`(() => {
       const lines = Array.from(document.querySelectorAll(".entry-line")).map(el => el.textContent);
       return lines[lines.length - 1];
     })()`);
-    assert(standaloneResult.includes('json: {"foo":"bar"}'), `Expected json: {"foo":"bar"}, got: ${standaloneResult}`);
+    assert(utf8Result.includes('utf8.mjs: Hello world'), `Expected utf8.mjs: Hello world, got: ${utf8Result}`);
+
+    // Test ieee.mjs input: :input ieee.mjs 3.14159
+    await evaluateAsync(`(async () => {
+      await window.kRepl.executeCommand(":codec load ieee.mjs");
+      await window.kRepl.executeCommand(":input ieee.mjs 3.14159");
+    })()`);
+    const ieeeResult = await evaluateAsync(`(() => {
+      const lines = Array.from(document.querySelectorAll(".entry-line")).map(el => el.textContent);
+      return lines[lines.length - 1];
+    })()`);
+    assert(ieeeResult.includes('ieee.mjs: 3.14159'), `Expected ieee.mjs: 3.14159, got: ${ieeeResult}`);
+
 
     // Verify text selection holds in output element
     const selectionCheck = await evaluateAsync(`(() => {
@@ -336,6 +393,7 @@ if (chromiumBin) {
       // Check Value section
       const valSection = container.querySelector(".k-tree-value-section");
       if (!valSection) return { error: "No value section" };
+      if (valSection.open) return { error: "Value section should be collapsed by default (open === false)" };
 
       // Check product details nodes hierarchy
       // Level 1: root product (depth 1)
@@ -355,9 +413,10 @@ if (chromiumBin) {
       if (!level4) return { error: "Level 4 product node missing" };
       if (level4.open) return { error: "Level 4 product should be collapsed (open === false)" };
 
-      // Check pattern section exists and has cycle or vardef
+      // Check pattern section exists and is collapsed by default
       const patSection = container.querySelector(".k-tree-pat-section");
       if (!patSection) return { error: "No pattern section" };
+      if (patSection.open) return { error: "Pattern section should be collapsed by default (open === false)" };
 
       // Test Mode Toggle: click Raw
       rawBtn.click();
@@ -480,11 +539,17 @@ if (chromiumBin) {
       btnHelp.click();
       const helpModalOpen = document.getElementById("help-modal")?.classList.contains("open");
       const modalText = document.getElementById("help-modal")?.textContent || "";
-      const hasRel = modalText.includes(":rel ");
+      const hasRel = modalText.includes(":rel <name>");
       const hasVal = modalText.includes(":val");
       const hasTiming = modalText.includes(":timing");
+      const hasTime = modalText.includes(":time");
+      const hasT = modalText.includes(":t <name>");
       const hasCodecDefine = modalText.includes(":codec define");
       const hasType = modalText.includes(":type <name>");
+      const hasTypes = modalText.includes(":types");
+      const hasCodes = modalText.includes(":codes");
+      const hasD = modalText.includes(":d <name>");
+      const hasEngine = modalText.includes(":engine");
       return {
         found: true,
         isVisible,
@@ -493,18 +558,48 @@ if (chromiumBin) {
         hasRel,
         hasVal,
         hasTiming,
+        hasTime,
+        hasT,
         hasCodecDefine,
-        hasType
+        hasType,
+        hasTypes,
+        hasCodes,
+        hasD,
+        hasEngine
       };
     })()`);
     assert.strictEqual(narrowNavbarCheck.found, true, "#btn-help should exist");
     assert.strictEqual(narrowNavbarCheck.isVisible, true, "#btn-help should be visible within narrow viewport");
     assert.strictEqual(narrowNavbarCheck.helpModalOpen, true, "Clicking #btn-help in narrow viewport should open help modal");
-    assert.strictEqual(narrowNavbarCheck.hasRel, false, "Help modal should not contain :rel");
+    assert.strictEqual(narrowNavbarCheck.hasRel, true, "Help modal should contain :rel <name>");
+    assert.strictEqual(narrowNavbarCheck.hasType, true, "Help modal should contain :type <name>");
+    assert.strictEqual(narrowNavbarCheck.hasTypes, true, "Help modal should contain :types");
+    assert.strictEqual(narrowNavbarCheck.hasEngine, true, "Help modal should contain :engine");
+    assert.strictEqual(narrowNavbarCheck.hasCodes, false, "Help modal should not contain :codes");
+    assert.strictEqual(narrowNavbarCheck.hasTime, false, "Help modal should not contain :time");
+    assert.strictEqual(narrowNavbarCheck.hasT, false, "Help modal should not contain :t <name>");
+    assert.strictEqual(narrowNavbarCheck.hasD, false, "Help modal should not contain :d <name>");
     assert.strictEqual(narrowNavbarCheck.hasVal, false, "Help modal should not contain :val");
     assert.strictEqual(narrowNavbarCheck.hasTiming, false, "Help modal should not contain :timing");
     assert.strictEqual(narrowNavbarCheck.hasCodecDefine, false, "Help modal should not contain :codec define");
-    assert.strictEqual(narrowNavbarCheck.hasType, true, "Help modal should contain :type <name>");
+
+    // 6. Test dual engine switching in browser (wasm <-> js)
+    const engineCheck = await evaluateAsync(`(async () => {
+      const initialEngine = window.kRepl.getEngine();
+      await window.kRepl.executeCommand(":engine js");
+      const jsEngine = window.kRepl.getEngine();
+      const badgeJsText = document.getElementById("engine-badge")?.textContent;
+      await window.kRepl.executeCommand("() | ok");
+      await window.kRepl.executeCommand(":engine wasm");
+      const wasmEngine = window.kRepl.getEngine();
+      const badgeWasmText = document.getElementById("engine-badge")?.textContent;
+      return { initialEngine, jsEngine, wasmEngine, badgeJsText, badgeWasmText };
+    })()`);
+    assert.strictEqual(engineCheck.initialEngine, "wasm");
+    assert.strictEqual(engineCheck.jsEngine, "js");
+    assert.strictEqual(engineCheck.badgeJsText, "js-in-process");
+    assert.strictEqual(engineCheck.wasmEngine, "wasm");
+    assert.strictEqual(engineCheck.badgeWasmText, "wasm-in-process");
 
     ws.close();
     console.log("   Browser execution verified successfully!");