@fraczak/k 6.8.0 → 6.10.1

package/tests/test-repl.mjs

@@ -29,16 +29,16 @@ output = await evaluateInput(":type nat", state);
 assert.match(output[0], /^\$ nat = /);
 
 output = await evaluateInput("succ = | succ;", state);
-output = await evaluateInput(":d succ", state);
+output = await evaluateInput(":rel succ", state);
 assert.match(output[0], /^succ = /);
 
-output = await evaluateInput(":codes", state);
+output = await evaluateInput(":types", state);
 assert.match(output[0], /^nat = @/m);
 
 output = await evaluateInput(":rels", state);
 assert.match(output[0], /^succ = @/m);
 
-output = await evaluateInput(":run succ", state);
+output = await evaluateInput("succ", state);
 assert.equal(output[0], "{}|succ ?<{} succ, ...>");
 
 output = await evaluateInput("/zero", state);
@@ -48,24 +48,38 @@ assert.equal(state.value.toJSON(), "succ");
 output = await evaluateInput("succ", state);
 assert.match(output[0], /^\{\}\|succ\|succ \?</);
 
-output = await evaluateInput(":t succ", state);
-assert.match(output[0], /^succ : /);
-
-output = await evaluateInput(":d succ", state);
+output = await evaluateInput(":rel succ", state);
 assert.match(output[0], /^succ = /);
 
 let completions = completeInput(":he", state)[0];
 assert.deepEqual(completions, [":help"]);
 
 const canonicalPartial = state.typeAliases.nat.slice(0, 8);
-completions = completeInput(`:run ${canonicalPartial}`, state)[0];
+completions = completeInput(`:rel ${canonicalPartial}`, state)[0];
 assert(completions.some((line) => line.endsWith(state.typeAliases.nat)));
 
 completions = completeInput(`(${canonicalPartial}`, state)[0];
 assert(completions.includes(`(${state.typeAliases.nat}`));
 
-completions = completeInput(":run su", state)[0];
-assert(completions.includes(":run succ"));
+completions = completeInput(":rel su", state)[0];
+assert(completions.includes(":rel succ"));
+completions = completeInput(":ty", state)[0];
+assert(completions.includes(":types"));
+assert(completions.includes(":type"));
+
+await assert.rejects(
+  () => evaluateInput(":run succ", state),
+  /Unknown command ':run'/
+);
+await assert.rejects(
+  () => evaluateInput(":time ()", state),
+  /Unknown command ':time'/
+);
+await assert.rejects(
+  () => evaluateInput(":t succ", state),
+  /Unknown command ':t'/
+);
+
 completions = completeInput(":co", state)[0];
 assert(completions.includes(":codec"));
 
@@ -134,11 +148,11 @@ fs.writeFileSync(sourcePath, "$ nat = <{} zero, nat succ>;\nsucc = $nat |succ $n
 const loadedSource = createState();
 output = await evaluateInput(`:load ${sourcePath}`, loadedSource);
 assert.equal(output[0], `loaded ${sourcePath}`);
-output = await evaluateInput(":codes", loadedSource);
+output = await evaluateInput(":types", loadedSource);
 assert.match(output[0], /^nat = @/m);
 output = await evaluateInput(":rels", loadedSource);
 assert.match(output[0], /^succ = @/m);
-output = await evaluateInput(":d twice", loadedSource);
+output = await evaluateInput(":rel twice", loadedSource);
 assert.match(output[0], /^twice = \$nat succ succ \$nat;  -- @/);
 output = await evaluateInput(":C nat", loadedSource);
 assert.match(output[0], /^\$ nat = < nat succ, @[^ ]+ zero >;  -- @/);
@@ -160,6 +174,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;
 }
 `);
@@ -172,58 +189,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("$ bool = < {} true, {} false >;", jsonState);
 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));
@@ -238,7 +249,7 @@ const reloaded = createState();
 output = await evaluateInput(`:load ${libPath}`, reloaded);
 assert.equal(output[0], `loaded ${libPath}`);
 
-output = await evaluateInput(":codes", reloaded);
+output = await evaluateInput(":types", reloaded);
 assert.match(output[0], /^nat = @/m);
 
 output = await evaluateInput(":rels", reloaded);
@@ -250,7 +261,7 @@ assert.equal(output[0], "{}|succ ?<{} succ, ...>");
 const noAliasReloaded = createState();
 output = await evaluateInput(`:load --no-alias ${libPath}`, noAliasReloaded);
 assert.equal(output[0], `loaded ${libPath}`);
-output = await evaluateInput(":codes", noAliasReloaded);
+output = await evaluateInput(":types", noAliasReloaded);
 assert.equal(output[0], "(none)");
 output = await evaluateInput(":rels", noAliasReloaded);
 assert.equal(output[0], "(none)");
@@ -258,7 +269,7 @@ assert.equal(output[0], "(none)");
 const shorthand = createState();
 output = await evaluateInput("$ nat = <{} zero, nat succ>\n; succ = |succ\n;", shorthand);
 assert.match(output[0], /\/\* comp: .* \*\//);
-output = await evaluateInput(":codes", shorthand);
+output = await evaluateInput(":types", shorthand);
 assert.match(output[0], /^nat = @/m);
 output = await evaluateInput(":rels", shorthand);
 assert.match(output[0], /^succ = @/m);
@@ -268,7 +279,7 @@ assert.match(output[0], / false/);
 assert.match(output[0], / true/);
 output = await evaluateInput("$ maybe = <{} none, {} some>;", shorthand);
 assert.match(output[0], /\/\* comp: .* \*\//);
-output = await evaluateInput(":codes", shorthand);
+output = await evaluateInput(":types", shorthand);
 assert.match(output[0], /^maybe = @/m);
 output = await evaluateInput("{} | true not", shorthand);
 assert.match(output[0], /^\{\}\|false \?</);
@@ -302,41 +313,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, 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("$ bool = < {} true, {} false >;", codecTestState);
 registerCodec(codecTestState, {
-  name: "yn",
-  codes: [codecTestState.typeAliases.bool],
-  universal: false,
+  name: "yn.mjs",
   parse: (text) => Value.variant(text.trim() === "yes" ? "true" : "false", Value.product({})),
-  print: (v) => v.tag === "true" ? "YES" : "NO"
-}, "<test>");
-
-output = await evaluateInput(":input bool yn", codecTestState);
+  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();
@@ -351,103 +366,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\}/);
-
-// Verify pattern expressions and standalone codec input
-const patternInputState = createState();
-await evaluateInput(":codec load json", patternInputState);
-
-// 1. Explicit pattern expression: ? {string a, float64 n} json
-output = await evaluateInput(":input ? {string a, float64 n} json", patternInputState);
-assert.match(output[0], /input \? \{string a, float64 n\} using json: enter value text/);
-output = await evaluateInput('{"a":"Woj","n":123}', patternInputState);
-assert.match(output[0], /json: \{"a":"Woj","n":123\}/);
-
-// 2. Wildcard pattern expression: ? (...) json
-output = await evaluateInput(":input ? (...) json", patternInputState);
-assert.match(output[0], /enter value text/);
-output = await evaluateInput('{"anything": [1, 2, 3]}', patternInputState);
-assert.match(output[0], /json: \{"anything":\[1,2,3\]\}/);
-
-// 3. Standalone codec input: :input json (no predefined type or pattern required)
-output = await evaluateInput(":input json", patternInputState);
-assert.match(output[0], /input json: enter value text/);
-output = await evaluateInput('{"hello":"world"}', patternInputState);
-assert.match(output[0], /json: \{"hello":"world"\}/);
-
-// 4. Pattern mismatch detection
-output = await evaluateInput(":input ? {string a, float64 n} json", patternInputState);
-await assert.rejects(
-  () => evaluateInput('{"wrong_key": 999}', patternInputState),
-  /Closed product pattern does not match value fields/
-);
-
-// 5. Bare :input defaults to :input (...) with auto-loaded json codec
+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();
-assert.equal(promptForState(bareInputState), "> ");
 output = await evaluateInput(":input", bareInputState);
-assert.deepEqual(output, ["input (...): enter value text"]);
-assert.equal(promptForState(bareInputState), "json> ");
-output = await evaluateInput('{"test": 123}', bareInputState);
-assert.match(output[0], /json: \{"test":123\}/);
-assert.equal(promptForState(bareInputState), "> ");
-
-// 6. Pattern as type prefixed by dollar
-const dollarPatternState = createState();
-await evaluateInput(":load arithmetics.k", dollarPatternState);
-output = await evaluateInput(":input $ int", dollarPatternState);
-assert.deepEqual(output, ["input $ int: enter value text"]);
-assert.equal(promptForState(dollarPatternState), "int> ");
-output = await evaluateInput("42", dollarPatternState);
-assert.match(output[0], /int: 42/);
-
-await evaluateInput("$ bool = <{} true, {} false>;", dollarPatternState);
-output = await evaluateInput(":input $ bool json", dollarPatternState);
-assert.deepEqual(output, ["input $ bool using json: enter value text"]);
-assert.equal(promptForState(dollarPatternState), "json> ");
-output = await evaluateInput("true", dollarPatternState);
-assert.match(output[0], /json: true/);
+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);
@@ -455,21 +455,75 @@ 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 reporting is always on and :time command
+// Verify timing reporting is always on and reflects active engine
 const timingState = createState();
 assert.equal(timingState.showTiming, true);
+assert.equal(timingState.engine, "wasm");
 
 output = await evaluateInput("()", timingState);
 assert.equal(output[0], "{} ?{}");
-assert.match(output[1], /\/\* comp: .*, exec: .* \*\//);
-
-output = await evaluateInput(":time ()", timingState);
-assert.equal(output[0], "{} ?{}");
-assert.match(output[1], /\/\* comp: .*, exec: .* \*\//);
+assert.match(output[1], /\/\* comp: .*, exec: .* \(wasm\) \*\//);
 assert.ok(timingState.lastTiming);
+assert.equal(timingState.lastTiming.engine, "wasm");
 assert.ok(typeof timingState.lastTiming.compileMs === "number");
 assert.ok(typeof timingState.lastTiming.executeMs === "number");
 
+// Verify :engine command and switching between wasm and js engines
+output = await evaluateInput(":engine", timingState);
+assert.equal(output[0], "Current engine: wasm");
+
+output = await evaluateInput(":engine js", timingState);
+assert.equal(output[0], "engine set to js");
+assert.equal(timingState.engine, "js");
+
+output = await evaluateInput("()", timingState);
+assert.equal(output[0], "{} ?{}");
+assert.match(output[1], /\/\* comp: .*, exec: .* \(js\) \*\//);
+assert.equal(timingState.lastTiming.engine, "js");
+
+// Verify shortcuts :wasm and :js
+output = await evaluateInput(":wasm", timingState);
+assert.equal(output[0], "engine set to wasm");
+assert.equal(timingState.engine, "wasm");
+
+output = await evaluateInput(":js", timingState);
+assert.equal(output[0], "engine set to js");
+assert.equal(timingState.engine, "js");
+
+// Verify :reset preserves the active engine
+output = await evaluateInput(":reset", timingState);
+assert.equal(output[0], "reset");
+assert.equal(timingState.engine, "js");
+
+// Verify invalid engine error
+await assert.rejects(
+  () => evaluateInput(":engine invalid", timingState),
+  /Invalid engine 'invalid'\. Valid engines: wasm, js/
+);
+
+// Verify autocompletion for :engine
+completions = completeInput(":engine ", timingState)[0];
+assert(completions.includes(":engine wasm"));
+assert(completions.includes(":engine js"));
+
+// Verify evaluating expressions in JS engine
+const jsState = createState({ engine: "js" });
+assert.equal(jsState.engine, "js");
+
+output = await evaluateInput("$ nat = < {} zero, nat succ >;\nsucc = | succ;\n{} | zero succ succ", jsState);
+assert.match(output[0], /^\{\}\|zero\|succ\|succ/);
+assert.match(output[1], /\(js\)/);
+
+output = await evaluateInput("$ bool = < {} true, {} false >;\nnot = $bool </true | false, {} | true >;\n{} | true not", jsState);
+assert.match(output[0], /^\{\}\|false/);
+assert.match(output[1], /\(js\)/);
+
+output = await evaluateInput(":load Examples/arithmetics.k", jsState);
+assert.equal(output[0], "loaded Examples/arithmetics.k");
+output = await evaluateInput("{ 10 int x, 5 int y } plus", jsState);
+assert.match(output[0], /^\{\}\|_\|1\|1\|1\|1\|\+/);
+assert.match(output[1], /\(js\)/);
+
 fs.rmSync(tmpDir, { recursive: true, force: true });
 fs.rmSync(symlinkPath, { force: true });
 console.log("OK");

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.");