@fraczak/k 6.7.0 → 6.9.0

package/tests/test-repl.mjs

@@ -16,18 +16,21 @@ import {
   isMainEntrypoint,
   lineHasExplicitContinuation,
   lineTerminatesSnippet,
-  promptForState
+  promptForState,
+  registerCodec
 } from "../repl.mjs";
 import { decodeObject, objectToFunction } from "../object.mjs";
 import { Value } from "../Value.mjs";
 
 const state = createState();
 
-let output = await evaluateInput(":type nat = <{} zero, nat succ>", state);
-assert.match(output[0], /^\$ nat = @/);
+let output = await evaluateInput("$ nat = < {} zero, nat succ >;", state);
+output = await evaluateInput(":type nat", state);
+assert.match(output[0], /^\$ nat = /);
 
-output = await evaluateInput(":rel succ = |succ", state);
-assert.match(output[0], /^succ = @/);
+output = await evaluateInput("succ = | succ;", state);
+output = await evaluateInput(":d succ", state);
+assert.match(output[0], /^succ = /);
 
 output = await evaluateInput(":codes", state);
 assert.match(output[0], /^nat = @/m);
@@ -82,8 +85,8 @@ assert.equal(analyzeRawSnippet("a =").kind, "incomplete");
 assert.equal(analyzeRawSnippet("{} | succ").kind, "withMain");
 
 const offsetState = createState();
-await evaluateInput(":type ab = <{} 1, {} 2>", offsetState);
-await evaluateInput(":type bool = <{} true, {} false>", offsetState);
+await evaluateInput("$ ab = < {} 1, {} 2 >;", offsetState);
+await evaluateInput("$ bool = < {} true, {} false >;", offsetState);
 await assert.rejects(
   () => evaluateInput("$ab", offsetState),
   /Type Error in 'filter' \(lines 1:1\.\.\.1:4\)/
@@ -100,10 +103,10 @@ 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);
+await evaluateInput("$ nat = < {} _, nat 0, nat 1 >;", recursiveState);
+await evaluateInput("0? = $ nat < / _ {} | 0, / 0 0? >;", recursiveState);
 const staleZeroHash = recursiveState.relAliases["0?"];
-await evaluateInput(":rel 0? = $ nat < / _ {}|_, / 0 0? >;", recursiveState);
+await evaluateInput("0? = $ nat < / _ {} | _, / 0 0? >;", recursiveState);
 const zeroHash = recursiveState.relAliases["0?"];
 assert.notEqual(zeroHash, staleZeroHash);
 await evaluateInput("{}|_|0|0 $nat", recursiveState);
@@ -141,8 +144,7 @@ output = await evaluateInput(":C nat", loadedSource);
 assert.match(output[0], /^\$ nat = < nat succ, @[^ ]+ zero >;  -- @/);
 
 const codecState = createState();
-output = await evaluateInput(":type bool = <{} true, {} false>", codecState);
-assert.match(output[0], /^\$ bool = @/);
+output = await evaluateInput("$ bool = < {} true, {} false >;", codecState);
 const boolHash = codecState.typeAliases.bool;
 const valueModuleUrl = pathToFileURL(path.resolve("Value.mjs")).href;
 fs.writeFileSync(codecPath, `
@@ -158,6 +160,9 @@ export function parse(text) {
 }
 
 export function print(value) {
+  if (!value || (value.tag !== "true" && value.tag !== "false")) {
+    throw new Error("expected true or false");
+  }
   return value.tag;
 }
 `);
@@ -170,59 +175,52 @@ assert(completions.includes(":codec list"));
 completions = completeInput(`:codec load ${tmpDir}/bool`, codecState)[0];
 assert(completions.includes(`:codec load ${codecPath}`));
 output = await evaluateInput(`:codec load ${codecPath}`, codecState);
-assert.equal(output[0], `loaded codec yn for ${boolHash}`);
+assert.equal(output[0], `loaded codec bool-codec.mjs`);
 output = await evaluateInput(":codec list", codecState);
-assert.match(output[0], new RegExp(`^yn ${boolHash.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`));
-completions = completeInput(":input bo", codecState)[0];
-assert(completions.includes(":input bool"));
-completions = completeInput(":input bool y", codecState)[0];
-assert(completions.includes(":input bool yn"));
-output = await evaluateInput(":input bool yn", codecState);
-assert.equal(output[0], `input ${boolHash} using yn: enter value text`);
+assert.match(output[0], /^bool-codec\.mjs/);
+completions = completeInput(":input", codecState)[0];
+assert(completions.includes(":input"));
+completions = completeInput(":input ", codecState)[0];
+assert(completions.includes(":input bool-codec.mjs"));
+completions = completeInput(":input b", codecState)[0];
+assert(completions.includes(":input bool-codec.mjs"));
+output = await evaluateInput(":input bool-codec.mjs", codecState);
+assert.equal(promptForState(codecState), "bool-codec.mjs> ");
 output = await evaluateInput("true", codecState);
 assert.match(output[0], /\{\}\|true \?</);
-assert.match(output[0], /yn: true/);
+assert.match(output[0], /bool-codec\.mjs: true/);
 output = await evaluateInput("{} | false", codecState);
-assert.doesNotMatch(output[0], /yn: false/);
+assert.match(output[0], /bool-codec\.mjs: false/);
+output = await evaluateInput("{}", codecState);
+assert.doesNotMatch(output[0], /bool-codec\.mjs:/);
 
 const utf8State = createState();
 output = await evaluateInput(":load core.k", utf8State);
 assert.equal(output[0], "loaded core.k");
 output = await evaluateInput(":codec load ./codecs/utf8.mjs", utf8State);
-assert.equal(output[0], `loaded codec utf8 for ${utf8State.typeAliases.string}`);
-output = await evaluateInput(":input string utf8", utf8State);
-assert.equal(output[0], `input ${utf8State.typeAliases.string} using utf8: enter value text`);
-output = await evaluateInput("hello", utf8State);
-assert.match(output[0], /utf8: hello/);
+assert.equal(output[0], `loaded codec utf8.mjs`);
+output = await evaluateInput(":input utf8.mjs hello", utf8State);
+assert.match(output[0], /utf8\.mjs: 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/);
+assert.match(output[0], /^loaded codec json\.mjs/);
 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> ");
+assert.match(output[0], /^json\.mjs/);
+completions = completeInput(":input j", jsonState)[0];
+assert(completions.includes(":input json.mjs"));
+output = await evaluateInput(":input json.mjs", jsonState);
+assert.equal(promptForState(jsonState), "json.mjs> ");
 output = await evaluateInput("true", jsonState);
 assert.match(output[0], /\{\}\|true \?</);
-assert.match(output[0], /json: true/);
+assert.match(output[0], /json\.mjs: 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);
+output = await evaluateInput(":input json.mjs false", jsonState);
 assert.match(output[0], /\{\}\|false \?</);
-assert.match(output[0], /json: false/);
+assert.match(output[0], /json\.mjs: 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\}/);
+output = await evaluateInput(':input json.mjs {"left":true,"right":false}', jsonState);
+assert.match(output[0], /json\.mjs: \{"left":true,"right":false\}/);
 assert.equal(promptForState(jsonState), "> ");
 
 const replPath = fileURLToPath(new URL("../repl.mjs", import.meta.url));
@@ -256,7 +254,7 @@ assert.equal(output[0], "(none)");
 
 const shorthand = createState();
 output = await evaluateInput("$ nat = <{} zero, nat succ>\n; succ = |succ\n;", shorthand);
-assert.deepEqual(output, []);
+assert.match(output[0], /\/\* comp: .* \*\//);
 output = await evaluateInput(":codes", shorthand);
 assert.match(output[0], /^nat = @/m);
 output = await evaluateInput(":rels", shorthand);
@@ -266,7 +264,7 @@ assert.match(output[0], /^\{\}\|false \?</);
 assert.match(output[0], / false/);
 assert.match(output[0], / true/);
 output = await evaluateInput("$ maybe = <{} none, {} some>;", shorthand);
-assert.deepEqual(output, []);
+assert.match(output[0], /\/\* comp: .* \*\//);
 output = await evaluateInput(":codes", shorthand);
 assert.match(output[0], /^maybe = @/m);
 output = await evaluateInput("{} | true not", shorthand);
@@ -279,8 +277,8 @@ await assert.rejects(
 
 // 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);
+await evaluateInput("$ nat = < {} zero, nat succ >;", tcoState);
+await evaluateInput("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++) {
@@ -301,39 +299,45 @@ 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
+// Verify codecs loading, listing, and unloading
 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(":codec load ./codecs/int.mjs", codecTestState);
+assert.match(output[0], /^loaded codec int\.mjs/);
 
 output = await evaluateInput(":codecs", codecTestState);
-assert.match(output[0], /^int @/);
+assert.match(output[0], /^int\.mjs/);
 
 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"));
+assert(completions.includes(":codec unload int.mjs"));
+completions = completeInput(":codec load ./codecs/i", codecTestState)[0];
+assert(completions.includes(":codec load ./codecs/int.mjs"));
 
-output = await evaluateInput(":codec unload int", codecTestState);
-assert.equal(output[0], "unloaded codec int");
+output = await evaluateInput(":codec unload int.mjs", codecTestState);
+assert.equal(output[0], "unloaded codec int.mjs");
 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("$ bool = < {} true, {} false >;", codecTestState);
+registerCodec(codecTestState, {
+  name: "yn.mjs",
+  parse: (text) => Value.variant(text.trim() === "yes" ? "true" : "false", Value.product({})),
+  print: (v) => {
+    if (v.tag !== "true" && v.tag !== "false") throw new Error("not a bool");
+    return v.tag === "true" ? "YES" : "NO";
+  }
+}, "yn.mjs");
+
+output = await evaluateInput(":input yn.mjs", codecTestState);
+assert.equal(promptForState(codecTestState), "yn.mjs> ");
 output = await evaluateInput("yes", codecTestState);
-assert.match(output[0], /yn: YES/);
+assert.match(output[0], /yn\.mjs: YES/);
+output = await evaluateInput(":input yn.mjs no", codecTestState);
+assert.match(output[0], /yn\.mjs: NO/);
 
 // Projection on product with variant field (avoids filter variable collisions)
 const projState = createState();
@@ -348,48 +352,88 @@ 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/);
+// Explicit loading of dependencies and codec testing (no auto-loading)
+const intState = createState();
+await evaluateInput(":load Examples/arithmetics.k", intState);
+output = await evaluateInput(":codec load ./codecs/int.mjs", intState);
+assert.match(output[0], /^loaded codec int\.mjs/);
+output = await evaluateInput(":input int.mjs", intState);
+output = await evaluateInput("123", intState);
+assert.match(output[0], /int\.mjs: 123/);
+output = await evaluateInput(":input int.mjs", intState);
+output = await evaluateInput("[0,1,2]", intState);
+assert.match(output[0], /int\.mjs: \[0,1,2\]/);
 
 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);
+await evaluateInput(":load core.k", utf8AutoState);
+output = await evaluateInput(":codec load ./codecs/utf8.mjs", utf8AutoState);
+assert.match(output[0], /^loaded codec utf8\.mjs/);
+output = await evaluateInput(":input utf8.mjs", utf8AutoState);
 output = await evaluateInput("test utf8", utf8AutoState);
-assert.match(output[0], /utf8: test utf8/);
+assert.match(output[0], /utf8\.mjs: test utf8/);
 
 const ieeeAutoState = createState();
-output = await evaluateInput(":codec load ieee", ieeeAutoState);
-assert.match(output[0], /auto-loaded (?:Examples\/)?ieee\.k/);
+await evaluateInput(":load Examples/ieee.k", ieeeAutoState);
+output = await evaluateInput(":codec load ./codecs/ieee.mjs", ieeeAutoState);
+assert.match(output[0], /^loaded codec ieee\.mjs/);
 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\}/);
+await evaluateInput(":load Examples/ieee.k", jsonInputState);
+await evaluateInput(":codec load ./codecs/json.mjs", jsonInputState);
+output = await evaluateInput(':input json.mjs {"a":"Woj","n":123}', jsonInputState);
+assert.match(output[0], /json\.mjs: \{"a":"Woj","n":123\}/);
+
+// Verify standalone codec input, one-line and interactive modes, and multi-codec printing
+const multiCodecState = createState();
+await evaluateInput(":codec load ./codecs/json.mjs", multiCodecState);
+await evaluateInput(":codec load ./codecs/utf8.mjs", multiCodecState);
+await evaluateInput(":codec load ./codecs/int.mjs", multiCodecState);
+
+// 1. One-line JSON input: :input json.mjs {"hello":"world"}
+output = await evaluateInput(':input json.mjs {"hello":"world"}', multiCodecState);
+assert.match(output[0], /json\.mjs: \{"hello":"world"\}/);
+
+// 2. Interactive JSON input: :input json.mjs then {"anything": [1, 2, 3]}
+output = await evaluateInput(":input json.mjs", multiCodecState);
+assert.equal(promptForState(multiCodecState), "json.mjs> ");
+output = await evaluateInput('{"anything": [1, 2, 3]}', multiCodecState);
+assert.match(output[0], /json\.mjs: \{"anything":\[1,2,3\]\}/);
+assert.equal(promptForState(multiCodecState), "> ");
+
+// 3. Integer scalar and list input
+output = await evaluateInput(":input int.mjs 42", multiCodecState);
+assert.match(output[0], /int\.mjs: 42/);
+
+output = await evaluateInput(":input int.mjs [0,1,2]", multiCodecState);
+assert.match(output[0], /int\.mjs: \[0,1,2\]/);
+
+// 4. Bare :input displays usage and loaded codecs
+const bareInputState = createState();
+output = await evaluateInput(":input", bareInputState);
+assert.match(output[0], /^Usage: :input <codec\.mjs> \[text\]/);
+assert.match(output[1], /Loaded codecs:/);
+
+// 5. Codec with leading dollar sign is accepted
+output = await evaluateInput(":input $ int.mjs 42", multiCodecState);
+assert.match(output[0], /int\.mjs: 42/);
+output = await evaluateInput(":input $int.mjs 100", multiCodecState);
+assert.match(output[0], /int\.mjs: 100/);
+
+// 6. Unknown codec throws descriptive error
+await assert.rejects(
+  () => evaluateInput(":input nonexistent 123", multiCodecState),
+  /Codec 'nonexistent' is not loaded/
+);
 
 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(":codec load ./codecs/unit.mjs", unitState);
+assert.match(output[0], /^loaded codec unit\.mjs/);
+output = await evaluateInput(":input unit.mjs", unitState);
+assert.equal(promptForState(unitState), "unit.mjs> ");
 output = await evaluateInput("{}", unitState);
-assert.match(output[0], /unit: \{\}/);
+assert.match(output[0], /unit\.mjs: \{\}/);
 
 const polyAutoState = createState();
 output = await evaluateInput(":load Examples/poly.k", polyAutoState);
@@ -397,28 +441,20 @@ 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
+// Verify timing reporting is always on and :time command
 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);
+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");
 
 fs.rmSync(tmpDir, { recursive: true, force: true });
 fs.rmSync(symlinkPath, { force: true });

package/tests/test-structural-values.mjs

@@ -25,3 +25,20 @@ assert.equal(valueToK(foreignTwo), "{}|_|0|1|+");
 
 const decoded = decodeWire(encodeToWire(foreignTwo, INT_PATTERN)).value;
 assert.equal(printInt(decoded), "2");
+
+const { INT_LIST_PATTERN, parse: parseIntCodec } = await import("../codecs/int.mjs");
+const { valueWithEnvelopeToK } = await import("../codecs/runtime/show-value.mjs");
+
+const parsedList = parseIntCodec("[0,1,2]");
+const listWire = encodeToWire(parsedList, INT_LIST_PATTERN);
+const decodedList = decodeWire(listWire).value;
+assert.equal(
+  valueWithEnvelopeToK(decodedList),
+  "{{}|_|0|+ car, {{}|_|1|+ car, {{}|_|0|1|+ car, {}|nil cdr}|cons cdr}|cons cdr}|cons ?<{<<X1 0, X1 1, {}=X2 _>=X1 +, X1 -> car, X0 cdr} cons, X2 nil>=X0"
+);
+assert.equal(printInt(decodedList), "[0,1,2]");
+
+const emptyList = parseIntCodec("[]");
+const emptyWire = encodeToWire(emptyList, INT_LIST_PATTERN);
+const decodedEmpty = decodeWire(emptyWire).value;
+assert.equal(printInt(decodedEmpty), "[]");

package/tests/test-tree-view.mjs

@@ -172,6 +172,7 @@ assert.strictEqual(patTree.open, true, "Root pattern node must be open");
 assert(patTree.textContent.includes("recursive"), "Recursive cycle must be detected and marked 'recursive'");
 
 // 5. Test createOutputEntryElement
+variantVal.pattern = recursivePattern;
 const entryEl = createOutputEntryElement({
   value: variantVal,
   rawText: "{}|_|1|0|1|+ ?<<X0 0, X0 1, {} _>=X0 +, X0 ->\nint: 11",
@@ -180,6 +181,8 @@ const entryEl = createOutputEntryElement({
 
 assert(entryEl.querySelector(".k-tree-view"), "Tree view container must exist");
 assert(entryEl.querySelector(".k-raw-view"), "Raw view container must exist");
+assert.strictEqual(entryEl.querySelector(".k-tree-value-section")?.open, false, "Value section must be collapsed by default");
+assert.strictEqual(entryEl.querySelector(".k-tree-pat-section")?.open, false, "Pattern section must be collapsed by default");
 assert(entryEl.textContent.includes("int: 11"), "Codec output must be visible in container");
 
 console.log("OK - All tree view unit tests passed.");

package/codecs/example-pipeline.mjs

@@ -1,163 +0,0 @@
-#!/usr/bin/env node
-/**
- * Example: Demonstrating the codec pipeline
- * 
- * Shows how to:
- * 1. Define types with canonical names
- * 2. Create values
- * 3. Encode to binary
- * 4. Pass through "compiled program" (identity)
- * 5. Decode from binary
- * 6. Print result
- */
-
-import { deriveClosedPattern } from './runtime/codec.mjs';
-import { encodeToWire, decodeWire } from './runtime/prefix-codec.mjs';
-import { patternToPropertyList } from './runtime/pattern-json.mjs';
-import { Value, isVariant } from '../Value.mjs';
-import hash from '../hash.mjs';
-import { argv, exit } from 'node:process';
-
-function usage() {
-  console.log(`Usage: ${argv[1]}`);
-  console.log("       Run a self-contained demonstration of the codec pipeline.");
-  console.log("");
-  console.log("Options:");
-  console.log("  -h, --help   Show this help.");
-}
-
-if (argv.slice(2).includes("-h") || argv.slice(2).includes("--help")) {
-  usage();
-  exit(0);
-}
-
-console.log('=== K Codec Pipeline Example ===\n');
-
-// ============================================================================
-// Step 1: Define types (normally from compiler)
-// ============================================================================
-
-const types = {};
-
-// Unit: {}
-const unitDef = { code: 'product', product: {} };
-const unitName = hash('$C0={};');
-types[unitName] = unitDef;
-
-// Bool: <{} false, {} true>
-const boolDef = {
-  code: 'union',
-  union: { false: unitName, true: unitName }
-};
-const boolName = hash(`$C0=<${unitName}"false",${unitName}"true">;`);
-types[boolName] = boolDef;
-
-// Maybe: <{} nothing, Bool something>
-const maybeDef = {
-  code: 'union',
-  union: { nothing: unitName, something: boolName }
-};
-const maybeName = hash(
-  `$C0=<${unitName}"nothing",${boolName}"something">;`
-);
-types[maybeName] = maybeDef;
-
-console.log('Types defined:');
-console.log('  unit:', unitName);
-console.log('  bool:', boolName);
-console.log('  maybe:', maybeName);
-console.log();
-
-// ============================================================================
-// Step 2: Type resolver
-// ============================================================================
-
-function resolveType(typeName) {
-  const def = types[typeName];
-  if (!def) {
-    throw new Error(`Unknown type: ${typeName}`);
-  }
-  return def;
-}
-
-// ============================================================================
-// Step 3: Create input value: Maybe Bool = something(true)
-// ============================================================================
-
-const inputValue = Value.variant(
-  'something',
-  Value.variant('true', Value.product({}))
-);
-
-console.log('Input value:', inputValue.toString());
-console.log();
-
-const maybePattern = patternToPropertyList(
-  deriveClosedPattern(maybeName, maybeDef, resolveType)
-);
-
-// ============================================================================
-// Step 4: Parse (TEXT → BINARY)
-// ============================================================================
-
-console.log('--- PARSE (text → binary) ---');
-const binaryInput = encodeToWire(inputValue, maybePattern);
-console.log('Binary size:', binaryInput.length, 'bytes');
-console.log('  Bytes:', binaryInput.toString('hex'));
-console.log();
-
-// ============================================================================
-// Step 5: Compiled k-program (BINARY → BINARY)
-// ============================================================================
-
-console.log('--- COMPILED PROGRAM (binary → binary) ---');
-
-// Simulate a compiled k-program: decode → transform → encode
-const { value: programInput } = decodeWire(binaryInput);
-
-console.log('Program sees value:', programInput.toString());
-
-// Example transformation: NOT operation (flip bool inside Maybe)
-let programOutput;
-if (isVariant(programInput) && programInput.tag === 'something') {
-  const innerBool = programInput.value;
-  if (isVariant(innerBool)) {
-    const flipped = Value.variant(
-      innerBool.tag === 'true' ? 'false' : 'true',
-      innerBool.value
-    );
-    programOutput = Value.variant('something', flipped);
-  }
-} else {
-  programOutput = programInput; // nothing → nothing
-}
-
-console.log('Program output value:', programOutput.toString());
-
-// Encode output
-const binaryOutput = encodeToWire(programOutput, maybePattern);
-
-console.log('Binary output size:', binaryOutput.length, 'bytes');
-console.log('  Bytes:', binaryOutput.toString('hex'));
-console.log();
-
-// ============================================================================
-// Step 6: Print (BINARY → TEXT)
-// ============================================================================
-
-console.log('--- PRINT (binary → text) ---');
-const { value: finalValue } = decodeWire(binaryOutput);
-
-console.log('Output value:', finalValue.toString());
-console.log();
-
-// ============================================================================
-// Summary
-// ============================================================================
-
-console.log('=== Pipeline Summary ===');
-console.log('Input:  ', inputValue.toString(), '(true inside Maybe)');
-console.log('Transform: NOT operation on inner bool');
-console.log('Output: ', finalValue.toString(), '(false inside Maybe)');
-console.log();
-console.log('Binary representations are canonical and type-safe!');

package/codecs/runtime/ieee-pattern.mjs

@@ -1,30 +0,0 @@
-import fs from "node:fs";
-import { parse as parseScript } from "../../parser.mjs";
-import codes from "../../codes.mjs";
-import { deriveClosedPattern } from "./codec.mjs";
-import { patternToPropertyList } from "./pattern-json.mjs";
-
-const IEEE_SCRIPT = fs.readFileSync(new URL("../../Examples/ieee.k", import.meta.url), "utf8");
-
-function loadFloat64Pattern() {
-  const { defs } = parseScript(IEEE_SCRIPT);
-  const { codes: finalizedCodes, representatives } = codes.finalize(defs.codes);
-  const typeName = representatives.float64 || "float64";
-  const typeInfo = finalizedCodes[typeName];
-  if (!typeInfo) {
-    throw new Error("Could not resolve float64 type from Examples/ieee.k");
-  }
-  const resolveType = (name) => {
-    const type = finalizedCodes[name];
-    if (!type) {
-      throw new Error(`Unknown IEEE helper type '${name}'`);
-    }
-    return type;
-  };
-  return patternToPropertyList(deriveClosedPattern(typeName, typeInfo, resolveType));
-}
-
-const FLOAT64_PATTERN = loadFloat64Pattern();
-
-export { FLOAT64_PATTERN, loadFloat64Pattern };
-export default { FLOAT64_PATTERN, loadFloat64Pattern };