@fraczak/k 6.10.5 → 7.0.0

package/tests/test-repl-html.mjs

@@ -139,15 +139,15 @@ if (chromiumBin) {
     const vfsList = await evaluateAsync(`window.kRepl.getAllVfsFiles().sort()`);
     const expectedFiles = [
       "arithmetics.k",
-      "codecs/ieee.mjs",
-      "codecs/int.mjs",
-      "codecs/json.mjs",
-      "codecs/unit.mjs",
-      "codecs/utf8.mjs",
       "core.k",
       "ieee.k",
+      "ieee.mjs",
+      "int.mjs",
+      "json.mjs",
       "karatsuba-mult.k",
-      "poly.k"
+      "poly.k",
+      "unit.mjs",
+      "utf8.mjs"
     ].sort();
     assert.deepStrictEqual(vfsList, expectedFiles, `getAllVfsFiles() must match curated files list, got: ${JSON.stringify(vfsList)}`);
 
@@ -581,6 +581,7 @@ if (chromiumBin) {
       const hasTime = modalText.includes(":time");
       const hasT = modalText.includes(":t <name>");
       const hasCodecDefine = modalText.includes(":codec define");
+      const hasRels = modalText.includes(":rels");
       const hasType = modalText.includes(":type <name>");
       const hasTypes = modalText.includes(":types");
       const hasCodes = modalText.includes(":codes");
@@ -592,6 +593,7 @@ if (chromiumBin) {
         rect: { left: rect.left, right: rect.right, top: rect.top, bottom: rect.bottom },
         helpModalOpen,
         hasRel,
+        hasRels,
         hasVal,
         hasTiming,
         hasTime,
@@ -608,8 +610,9 @@ if (chromiumBin) {
     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, 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.hasRels, true, "Help modal should contain :rels");
+    assert.strictEqual(narrowNavbarCheck.hasType, false, "Help modal should not contain :type <name>");
+    assert.strictEqual(narrowNavbarCheck.hasTypes, false, "Help modal should not 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");
@@ -635,7 +638,81 @@ if (chromiumBin) {
     assert.strictEqual(engineCheck.jsEngine, "js");
     assert.strictEqual(engineCheck.badgeJsText, "js-in-process");
     assert.strictEqual(engineCheck.wasmEngine, "wasm");
-    assert.strictEqual(engineCheck.badgeWasmText, "wasm-in-process");
+    // 7. Test uploading a file (adds to VFS without auto-loading)
+    const uploadCheck = await evaluateAsync(`(async () => {
+      const codecCode = \`export default {
+        name: "custom.mjs",
+        target: "(...)",
+        format: "custom",
+        parse: (raw) => raw,
+        print: (v) => "CUSTOM_VAL"
+      };\`;
+      const file = new File(
+        [codecCode],
+        "custom.mjs",
+        { type: "text/javascript" }
+      );
+      await window.kRepl.handleFileUpload(file);
+
+      const vfsContent = window.kRepl.getVfsFile("custom.mjs");
+      const inVfsList = window.kRepl.getAllVfsFiles().includes("custom.mjs");
+
+      // Verify system message showed upload confirmation
+      const systemMessages = Array.from(
+        document.querySelectorAll(".system-msg")
+      ).map(el => el.textContent);
+      const hasUploadedMsg = systemMessages.some(
+        m => m.includes("Uploaded custom.mjs into VFS")
+      );
+
+      // Verify it was NOT auto-loaded (:codecs does not list it)
+      await window.kRepl.executeCommand(":codecs");
+      const linesBefore = Array.from(
+        document.querySelectorAll(".entry-line")
+      ).map(el => el.textContent);
+      const codecsBefore = linesBefore[linesBefore.length - 1];
+
+      // Explicitly load it to prove it can be loaded as a codec
+      await window.kRepl.executeCommand(":codec load custom.mjs");
+      const linesAfter = Array.from(
+        document.querySelectorAll(".entry-line")
+      ).map(el => el.textContent);
+      const codecsAfter = linesAfter[linesAfter.length - 1];
+
+      return {
+        hasVfsContent: typeof vfsContent === "string" &&
+          vfsContent.includes("custom.mjs"),
+        inVfsList,
+        hasUploadedMsg,
+        codecsBefore,
+        codecsAfter
+      };
+    })()`);
+    assert.strictEqual(
+      uploadCheck.hasVfsContent,
+      true,
+      "Uploaded file must be present in VFS"
+    );
+    assert.strictEqual(
+      uploadCheck.inVfsList,
+      true,
+      "Uploaded file must be in getAllVfsFiles()"
+    );
+    assert.strictEqual(
+      uploadCheck.hasUploadedMsg,
+      true,
+      "Upload confirmation message must be displayed"
+    );
+    assert.strictEqual(
+      uploadCheck.codecsBefore.includes("custom.mjs"),
+      false,
+      "Upload must NOT auto-load the file"
+    );
+    assert.strictEqual(
+      uploadCheck.codecsAfter.includes("custom.mjs"),
+      true,
+      "Explicit :codec load of uploaded file must succeed"
+    );
 
     ws.close();
     console.log("   Browser execution verified successfully!");

package/tests/test-repl.mjs

@@ -24,18 +24,16 @@ import { Value } from "../Value.mjs";
 
 const state = createState();
 
-let output = await evaluateInput("$ nat = < {} zero, nat succ >;", state);
-output = await evaluateInput(":type nat", state);
-assert.match(output[0], /^\$ nat = /);
+let output = await evaluateInput("zero = {} | zero;", state);
+output = await evaluateInput(":rel zero", state);
+assert.match(output[0], /^zero = /);
 
 output = await evaluateInput("succ = | succ;", state);
 output = await evaluateInput(":rel succ", state);
 assert.match(output[0], /^succ = /);
 
-output = await evaluateInput(":types", state);
-assert.match(output[0], /^nat = @/m);
-
 output = await evaluateInput(":rels", state);
+assert.match(output[0], /^zero = @/m);
 assert.match(output[0], /^succ = @/m);
 
 output = await evaluateInput("succ", state);
@@ -54,18 +52,18 @@ assert.match(output[0], /^succ = /);
 let completions = completeInput(":he", state)[0];
 assert.deepEqual(completions, [":help"]);
 
-const canonicalPartial = state.typeAliases.nat.slice(0, 8);
+const canonicalPartial = state.relAliases.zero.slice(0, 8);
 completions = completeInput(`:rel ${canonicalPartial}`, state)[0];
-assert(completions.some((line) => line.endsWith(state.typeAliases.nat)));
+assert(completions.some((line) => line.endsWith(state.relAliases.zero)));
 
 completions = completeInput(`(${canonicalPartial}`, state)[0];
-assert(completions.includes(`(${state.typeAliases.nat}`));
+assert(completions.includes(`(${state.relAliases.zero}`));
 
 completions = completeInput(":rel su", state)[0];
 assert(completions.includes(":rel succ"));
-completions = completeInput(":ty", state)[0];
-assert(completions.includes(":types"));
-assert(completions.includes(":type"));
+completions = completeInput(":re", state)[0];
+assert(completions.includes(":rels"));
+assert(completions.includes(":rel"));
 
 await assert.rejects(
   () => evaluateInput(":run succ", state),
@@ -83,27 +81,26 @@ await assert.rejects(
 completions = completeInput(":co", state)[0];
 assert(completions.includes(":codec"));
 
-completions = completeInput("$na", state)[0];
-assert(completions.includes("$nat"));
+completions = completeInput("ze", state)[0];
+assert(completions.includes("zero"));
 
-assert.deepEqual(aliasNames(state), ["nat", "succ"]);
+assert.deepEqual(aliasNames(state), ["succ", "zero"]);
 assert.equal(lineTerminatesSnippet(";"), true);
 assert.equal(lineTerminatesSnippet("  ;   "), true);
 assert.equal(lineTerminatesSnippet("  ;   -- comment"), false);
 assert.equal(lineTerminatesSnippet("succ"), false);
-assert.equal(explicitSnippetTerminated("$ bool = <{} true, {} false>;"), true);
+assert.equal(explicitSnippetTerminated("bool = <{} true, {} false>;"), true);
 assert.equal(lineHasExplicitContinuation("succ \\"), true);
-assert.equal(analyzeRawSnippet("$ bool = <{} true, {} false>").kind, "incomplete");
-assert.equal(analyzeAcceptedSnippet("$ bool = <{} true, {} false>;", true).kind, "definitionsOnly");
+assert.equal(analyzeRawSnippet("bool = <{} true, {} false>").kind, "incomplete");
+assert.equal(analyzeAcceptedSnippet("bool = <{} true, {} false>;", true).kind, "definitionsOnly");
 assert.equal(analyzeRawSnippet("a =").kind, "incomplete");
 assert.equal(analyzeRawSnippet("{} | succ").kind, "withMain");
 
 const offsetState = createState();
-await evaluateInput("$ ab = < {} 1, {} 2 >;", offsetState);
-await evaluateInput("$ bool = < {} true, {} false >;", offsetState);
+await evaluateInput("zero = {} | zero;\nsucc = | succ;", offsetState);
 await assert.rejects(
-  () => evaluateInput("$ab", offsetState),
-  /Type Error in 'filter' \(lines 1:1\.\.\.1:4\)/
+  () => evaluateInput("{} .x", offsetState),
+  /Type Error in 'comp' \(lines 1:1\.\.\.1:6\)/
 );
 
 const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "k-repl-"));
@@ -117,13 +114,12 @@ output = await evaluateInput(`:klib ${libPath}`, state);
 assert.equal(output[0], `saved ${libPath}`);
 
 const recursiveState = createState();
-await evaluateInput("$ nat = < {} _, nat 0, nat 1 >;", recursiveState);
-await evaluateInput("0? = $ nat < / _ {} | 0, / 0 0? >;", recursiveState);
+await evaluateInput("0? = ?< {} _, X 0, X 1 > = X < / _ {} | 0, / 0 0? >;", recursiveState);
 const staleZeroHash = recursiveState.relAliases["0?"];
-await evaluateInput("0? = $ nat < / _ {} | _, / 0 0? >;", recursiveState);
+await evaluateInput("0? = ?< {} _, X 0, X 1 > = X < / _ {} | _, / 0 0? >;", recursiveState);
 const zeroHash = recursiveState.relAliases["0?"];
 assert.notEqual(zeroHash, staleZeroHash);
-await evaluateInput("{}|_|0|0 $nat", recursiveState);
+await evaluateInput("{}|_|0|0 0?", recursiveState);
 assert.deepEqual(
   Object.keys(recursiveState.rels).sort(),
   [staleZeroHash, zeroHash].sort()
@@ -144,28 +140,21 @@ const objectFn = objectToFunction(decodeObject(fs.readFileSync(koPath)));
 const objectResult = objectFn(Value.product({}, [["closed-product", []]]));
 assert.equal(objectResult.toJSON(), "succ");
 
-fs.writeFileSync(sourcePath, "$ nat = <{} zero, nat succ>;\nsucc = $nat |succ $nat;\ntwice = succ succ;\n");
+fs.writeFileSync(sourcePath, "succ = |succ;\ntwice = succ succ;\n");
 const loadedSource = createState();
 output = await evaluateInput(`:load ${sourcePath}`, loadedSource);
 assert.equal(output[0], `loaded ${sourcePath}`);
-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(":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 >;  -- @/);
+assert.match(output[0], /^twice = .*succ succ.*;  -- @/);
 
 const codecState = createState();
-output = await evaluateInput("$ bool = < {} true, {} false >;", codecState);
-const boolHash = codecState.typeAliases.bool;
 const valueModuleUrl = pathToFileURL(path.resolve("Value.mjs")).href;
 fs.writeFileSync(codecPath, `
 import { Value } from ${JSON.stringify(valueModuleUrl)};
 
 export const name = "yn";
-export const codes = [${JSON.stringify(boolHash)}];
 
 export function parse(text) {
   const tag = text.trim();
@@ -249,11 +238,9 @@ const reloaded = createState();
 output = await evaluateInput(`:load ${libPath}`, reloaded);
 assert.equal(output[0], `loaded ${libPath}`);
 
-output = await evaluateInput(":types", reloaded);
-assert.match(output[0], /^nat = @/m);
-
 output = await evaluateInput(":rels", reloaded);
 assert.match(output[0], /^succ = @/m);
+assert.match(output[0], /^zero = @/m);
 
 output = await evaluateInput("succ", reloaded);
 assert.equal(output[0], "{}|succ ?<{} succ, ...>");
@@ -261,25 +248,22 @@ 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(":types", noAliasReloaded);
-assert.equal(output[0], "(none)");
 output = await evaluateInput(":rels", noAliasReloaded);
 assert.equal(output[0], "(none)");
 
 const shorthand = createState();
-output = await evaluateInput("$ nat = <{} zero, nat succ>\n; succ = |succ\n;", shorthand);
+output = await evaluateInput("zero = {} | zero\n; succ = |succ\n;", shorthand);
 assert.match(output[0], /\/\* comp: .* \*\//);
-output = await evaluateInput(":types", shorthand);
-assert.match(output[0], /^nat = @/m);
 output = await evaluateInput(":rels", shorthand);
+assert.match(output[0], /^zero = @/m);
 assert.match(output[0], /^succ = @/m);
-output = await evaluateInput("$ bool = <{} true, {} false>\n; not = $bool </true | false, {} | true >\n; {} | true not", shorthand);
+output = await evaluateInput("not = </true | false, /false | true >\n; {} | true not", shorthand);
 assert.match(output[0], /^\{\}\|false \?</);
 assert.match(output[0], / false/);
 assert.match(output[0], / true/);
-output = await evaluateInput("$ maybe = <{} none, {} some>;", shorthand);
+output = await evaluateInput("maybe = < /none {} | none, /some | some >;", shorthand);
 assert.match(output[0], /\/\* comp: .* \*\//);
-output = await evaluateInput(":types", shorthand);
+output = await evaluateInput(":rels", shorthand);
 assert.match(output[0], /^maybe = @/m);
 output = await evaluateInput("{} | true not", shorthand);
 assert.match(output[0], /^\{\}\|false \?</);
@@ -291,8 +275,7 @@ await assert.rejects(
 
 // Verify WebAssembly in-process backend supports TCO / stack safety on deep recursion
 const tcoState = createState();
-await evaluateInput("$ nat = < {} zero, nat succ >;", tcoState);
-await evaluateInput("countdown = $ nat < / zero {} | zero, / succ countdown >;", tcoState);
+await evaluateInput("countdown = ?< {} zero, X succ > = X < / 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++) {
@@ -336,7 +319,7 @@ 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);
+output = await evaluateInput("bool = < /true {} | true, /false {} | false >;", codecTestState);
 registerCodec(codecTestState, {
   name: "yn.mjs",
   parse: (text) => Value.variant(text.trim() === "yes" ? "true" : "false", Value.product({})),
@@ -390,7 +373,9 @@ const ieeeAutoState = createState();
 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.codecs["ieee.mjs"], "ieee codec should be registered");
+output = await evaluateInput(":input ieee.mjs 1.5", ieeeAutoState);
+assert.match(output[0], /ieee\.mjs: 1\.5/);
 
 const jsonInputState = createState();
 await evaluateInput(":load core.k", jsonInputState);
@@ -453,7 +438,7 @@ 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");
+assert.ok(polyAutoState.relAliases.int, "arithmetics int should be auto-loaded");
 
 // Verify timing reporting is always on and reflects active engine
 const timingState = createState();
@@ -510,11 +495,11 @@ assert(completions.includes(":engine js"));
 const jsState = createState({ engine: "js" });
 assert.equal(jsState.engine, "js");
 
-output = await evaluateInput("$ nat = < {} zero, nat succ >;\nsucc = | succ;\n{} | zero succ succ", jsState);
+output = await evaluateInput("succ = | 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);
+output = await evaluateInput("not = </true | false, /false | true >;\n{} | true not", jsState);
 assert.match(output[0], /^\{\}\|false/);
 assert.match(output[1], /\(js\)/);
 

package/tests/test.mjs

@@ -22,9 +22,8 @@ import k from "../index.mjs";
 
 
 let k_expression = `
-  $ bool = < {} true, {} false >;
-  true = {} | true $bool;
-  false = {} | false $bool;
+  true = {} | true;
+  false = {} | false;
   
   list? = ?< {} nil, {X car, Y cdr} cons > = Y;
   nil = {}|nil list?;