@fraczak/k 7.0.2 → 7.1.0

package/backends/wasm/src/cli.mjs

@@ -1,26 +1,112 @@
 import fs from "node:fs";
 import path from "node:path";
 
-import { decodeObject, loadLibrary } from "@fraczak/k/backend-api.mjs";
+import {
+  compileLibrary,
+  decodeObject,
+  loadLibrary
+} from "@fraczak/k/backend-api.mjs";
 import {
   compileWasmArtifact,
   compileWasmArtifactFromKVM,
-  compileWasmArtifactFromObject
+  compileWasmArtifactFromObject,
+  compileWasmArtifactFromPKIR
 } from "./wasm.mjs";
 
 function readAll(stream) {
   return new Promise((resolve, reject) => {
     const chunks = [];
-    stream.on("data", (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+    stream.on("data", (chunk) => {
+      chunks.push(
+        Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)
+      );
+    });
     stream.on("end", () => resolve(Buffer.concat(chunks)));
     stream.on("error", reject);
   });
 }
 
+export function buildExportPreamble(exports = [], libraries = []) {
+  if (exports.length === 0) return "";
+  const aliasMap = {};
+  for (const lib of libraries) {
+    for (const [name, hash] of Object.entries(lib.relAlias || {})) {
+      if (name !== "__main__") aliasMap[name] = hash;
+    }
+    for (const [hash, entry] of Object.entries(lib.meta || {})) {
+      if (entry?.type !== "rel") continue;
+      for (const origin of entry?.origins || []) {
+        if (origin?.name && origin.name !== "__main__") {
+          aliasMap[origin.name] = hash;
+        }
+      }
+    }
+  }
+  const lines = [];
+  for (const spec of exports) {
+    const [libName, localName] = spec.includes(":")
+      ? spec.split(":", 2)
+      : [spec, spec];
+    const hash = aliasMap[libName];
+    if (!hash) {
+      throw new Error(
+        `--export: '${libName}' not found in loaded libraries`
+      );
+    }
+    const body = hash.startsWith("@") ? hash.slice(1) : hash;
+    lines.push(`${localName} = @${body};`);
+  }
+  return lines.join("\n") + "\n";
+}
+
+export function loadLibraryFromPath(libPath) {
+  const ext = path.extname(libPath).toLowerCase();
+  if (ext === ".klib" || ext === ".ko") {
+    return loadLibrary(decodeObject(fs.readFileSync(libPath)));
+  }
+  if (ext === ".k") {
+    let depLibs = [];
+    const baseName = path.basename(libPath);
+    if (baseName === "poly.k") {
+      const dir = path.dirname(libPath);
+      const arithPath = path.join(dir, "arithmetics.k");
+      if (fs.existsSync(arithPath)) {
+        const arithLib = loadLibrary(
+          compileLibrary(fs.readFileSync(arithPath, "utf8"), {
+            source: arithPath
+          })
+        );
+        depLibs.push(arithLib);
+      }
+    }
+    const rawSource = fs.readFileSync(libPath, "utf8");
+    if (depLibs.length > 0) {
+      const neededExports = [
+        "0", "int", "inc", "dec", "nat", "zero_int?", "neg?", "GT"
+      ];
+      const preamble = buildExportPreamble(neededExports, depLibs);
+      const compiled = compileLibrary(preamble + rawSource, {
+        source: libPath,
+        libraries: depLibs
+      });
+      const mergedLib = loadLibrary(compiled);
+      for (const dep of depLibs) {
+        for (const [k, v] of Object.entries(dep.relAlias || {})) {
+          if (!mergedLib.relAlias[k]) mergedLib.relAlias[k] = v;
+        }
+      }
+      return mergedLib;
+    }
+    return loadLibrary(compileLibrary(rawSource, { source: libPath }));
+  }
+  throw new Error(`Unsupported library extension: ${ext}`);
+}
+
 function parseCompileOptions(args) {
   const libraries = [];
   const exportSpecs = [];
   let loadedLibrary = false;
+  let usePKIR = false;
 
   while (args.length > 0) {
     if (args[0] === "--") {
@@ -28,25 +114,34 @@ function parseCompileOptions(args) {
       break;
     }
     if (args[0] === "--lib") {
-      if (loadedLibrary) throw new Error("--lib may only be specified once");
+      if (loadedLibrary) {
+        throw new Error("--lib may only be specified once");
+      }
       args.shift();
       const libPath = args.shift();
       if (!libPath) throw new Error("--lib requires a file argument");
-      libraries.push(loadLibrary(decodeObject(fs.readFileSync(libPath))));
+      libraries.push(loadLibraryFromPath(libPath));
       loadedLibrary = true;
     } else if (args[0] === "--export") {
       args.shift();
       const spec = args.shift();
-      if (!spec) throw new Error("--export requires a spec argument (name or libname:localname)");
+      if (!spec) {
+        throw new Error(
+          "--export requires a spec argument (name or libname:localname)"
+        );
+      }
       exportSpecs.push(spec);
+    } else if (args[0] === "--pkir") {
+      args.shift();
+      usePKIR = true;
     } else if (args[0].startsWith("--")) {
-      throw new Error(`Unknown option: ${args[0]}`);
+      break;
     } else {
       break;
     }
   }
 
-  return { libraries, exportSpecs };
+  return { libraries, exportSpecs, usePKIR };
 }
 
 function fileInputType(filePath) {
@@ -54,6 +149,7 @@ function fileInputType(filePath) {
   if (ext === ".ko") return "ko";
   if (ext === ".kvm") return "kvm";
   if (ext === ".klib") return "klib";
+  if (ext === ".pkir") return "pkir";
   return "source-file";
 }
 
@@ -68,38 +164,55 @@ function resolveProgramInput(args, { allowStdinSource = false } = {}) {
   if (fs.existsSync(inputArg)) {
     const kind = fileInputType(inputArg);
     if (kind === "klib") {
-      throw new Error("Cannot compile a .klib library to WebAssembly without a main relation; load it with --lib.");
+      throw new Error(
+        "Cannot compile a .klib library to WebAssembly without a main " +
+          "relation; load it with --lib."
+      );
     }
     return { kind, path: inputArg, sourceName: inputArg };
   }
 
-  if ([".k", ".ko", ".kvm", ".klib", ".wasm"].includes(ext)) {
+  if ([".k", ".ko", ".kvm", ".klib", ".wasm", ".pkir"].includes(ext)) {
     throw new Error(`Input file not found: ${inputArg}`);
   }
 
-  return { kind: "inline-source", source: inputArg, sourceName: "<inline>" };
+  return {
+    kind: "inline-source",
+    source: inputArg,
+    sourceName: "<inline>"
+  };
 }
 
 async function compileProgramInput(
   input,
-  { libraries = [], exportSpecs = [], stdin = null, inputEnvelopePattern = null } = {}
+  {
+    libraries = [],
+    exportSpecs = [],
+    stdin = null,
+    inputEnvelopePattern = null,
+    usePKIR = false
+  } = {}
 ) {
   if (input.kind === "inline-source") {
     return compileWasmArtifact(input.source, {
       libraries,
       exports: exportSpecs,
       source: input.sourceName,
-      inputEnvelopePattern
+      inputEnvelopePattern,
+      usePKIR
     });
   }
 
   if (input.kind === "stdin-source") {
-    if (!stdin) throw new Error("stdin source requested without a stdin stream");
+    if (!stdin) {
+      throw new Error("stdin source requested without a stdin stream");
+    }
     return compileWasmArtifact((await readAll(stdin)).toString("utf8"), {
       libraries,
       exports: exportSpecs,
       source: input.sourceName,
-      inputEnvelopePattern
+      inputEnvelopePattern,
+      usePKIR
     });
   }
 
@@ -108,18 +221,27 @@ async function compileProgramInput(
       libraries,
       exports: exportSpecs,
       source: input.sourceName,
-      inputEnvelopePattern
+      inputEnvelopePattern,
+      usePKIR
     });
   }
 
   if (input.kind === "ko") {
-    return compileWasmArtifactFromObject(decodeObject(fs.readFileSync(input.path)), {
-      inputEnvelopePattern
+    const obj = decodeObject(fs.readFileSync(input.path));
+    return compileWasmArtifactFromObject(obj, {
+      inputEnvelopePattern,
+      usePKIR
     });
   }
 
+  if (input.kind === "pkir") {
+    const pkir = JSON.parse(fs.readFileSync(input.path, "utf8"));
+    return compileWasmArtifactFromPKIR(pkir);
+  }
+
   if (input.kind === "kvm") {
-    return compileWasmArtifactFromKVM(JSON.parse(fs.readFileSync(input.path, "utf8")));
+    const kvm = JSON.parse(fs.readFileSync(input.path, "utf8"));
+    return compileWasmArtifactFromKVM(kvm);
   }
 
   throw new Error(`Unsupported input kind: ${input.kind}`);

package/backends/wasm/src/wasm.mjs

@@ -14,7 +14,9 @@ import {
   propertyListToPattern,
   Value,
   specializeKVM,
-  specializeObjectRelations
+  specializeObjectRelations,
+  compileRelationToPKIR,
+  lowerPKIRToKVM
 } from "@fraczak/k/backend-api.mjs";
 import { intersectPropertyListPatterns } from "@fraczak/k/codecs/runtime/codec.mjs";
 import { propertyListToFilter } from "@fraczak/k/codecs/runtime/show-value.mjs";
@@ -283,7 +285,7 @@ function cloneKVMFunction(kvmFunc) {
   };
 }
 
-function compileModule(mainRelName, defs) {
+function compileModule(mainRelName, defs, { usePKIR = false } = {}) {
   const compiled = new Set();
   const queue = [mainRelName];
   const wats = [];
@@ -299,8 +301,14 @@ function compileModule(mainRelName, defs) {
       throw new Error(`Relation ${name} not found`);
     }
 
-    const kvmFunc = lowerToKVM(relDef, name);
-    kvmFunc.typePatternGraph = relDef.typePatternGraph;
+    let kvmFunc;
+    if (usePKIR) {
+      const pkir = compileRelationToPKIR(relDef, name);
+      kvmFunc = lowerPKIRToKVM(pkir);
+    } else {
+      kvmFunc = lowerToKVM(relDef, name);
+      kvmFunc.typePatternGraph = relDef.typePatternGraph;
+    }
     scanCalls(kvmFunc.body, compiled, queue);
 
     kvmFunc.name = nameMap.get(name) || cleanName(name);
@@ -502,7 +510,7 @@ function buildExportPreamble(exportSpecs, libraries) {
 async function compileWasmArtifactFromDefs(
   defs,
   mainRelName = "__main__",
-  { typingMode = "generic" } = {}
+  { typingMode = "generic", usePKIR = false } = {}
 ) {
   resetTagIds();
   const mainRel = defs.rels[mainRelName];
@@ -510,7 +518,11 @@ async function compileWasmArtifactFromDefs(
     throw new Error(`No main relation (${mainRelName}) defined in script`);
   }
 
-  const { wat: moduleWatBody, relationNames, entryName } = compileModule(mainRelName, defs);
+  const { wat: moduleWatBody, relationNames, entryName } = compileModule(
+    mainRelName,
+    defs,
+    { usePKIR }
+  );
   assertRelationsConverged(defs, relationNames);
   const fullWat = runtimeWat.trim().slice(0, -1) + "\n" + moduleWatBody + "\n)";
   const graph = mainRel.typePatternGraph;
@@ -523,7 +535,12 @@ async function compileWasmArtifactFromDefs(
     entry: entryName || cleanName(mainRelName),
     inputPattern,
     outputPattern,
-    typing: classifyTyping(inputPattern, outputPattern, relTypeStatus(defs, mainRelName), typingMode),
+    typing: classifyTyping(
+      inputPattern,
+      outputPattern,
+      relTypeStatus(defs, mainRelName),
+      typingMode
+    ),
     tags: getTagEntries()
   };
   return appendCustomSection(await compileWat(fullWat), METADATA_SECTION, JSON.stringify(metadata));
@@ -598,12 +615,17 @@ async function compileWasmArtifactFromKVM(kvmInput, options = {}) {
   return appendCustomSection(await compileWat(fullWat), METADATA_SECTION, JSON.stringify(metadata));
 }
 
-async function compileWasmArtifactFromObject(object, { entry = null, inputEnvelopePattern = null } = {}) {
+async function compileWasmArtifactFromObject(
+  object,
+  { entry = null, inputEnvelopePattern = null, usePKIR = false } = {}
+) {
   if (!object?.rels) {
     throw new Error("Expected .ko input to contain k object relations");
   }
   if (object.main == null) {
-    throw new Error("Cannot compile a .klib library to WebAssembly without a main relation");
+    throw new Error(
+      "Cannot compile a .klib library to WebAssembly without a main relation"
+    );
   }
   const mainRelName = entry || object.main || "__main__";
   let defs = { rels: object.rels, compileStats: object.compileStats };
@@ -611,43 +633,126 @@ async function compileWasmArtifactFromObject(object, { entry = null, inputEnvelo
 
   if (inputEnvelopePattern) {
     const mainRel = object.rels[mainRelName];
-    if (!mainRel) throw new Error(`No main relation (${mainRelName}) defined in object`);
-    const inputPattern = getPatternPropertyList(mainRel.typePatternGraph, mainRel.def.patterns[0]);
-    const outputPattern = getPatternPropertyList(mainRel.typePatternGraph, mainRel.def.patterns[1]);
+    if (!mainRel) {
+      throw new Error(`No main relation (${mainRelName}) defined in object`);
+    }
+    const inputPattern = getPatternPropertyList(
+      mainRel.typePatternGraph,
+      mainRel.def.patterns[0]
+    );
+    const outputPattern = getPatternPropertyList(
+      mainRel.typePatternGraph,
+      mainRel.def.patterns[1]
+    );
     const typing = classifyTyping(inputPattern, outputPattern);
     if (typing.program === "polymorphic") {
-      const specialized = specializeObjectRelations(object, mainRelName, inputEnvelopePattern);
-      defs = { rels: specialized.rels, relAlias: specialized.relAlias, compileStats: specialized.compileStats };
+      const specialized = specializeObjectRelations(
+        object,
+        mainRelName,
+        inputEnvelopePattern
+      );
+      defs = {
+        rels: specialized.rels,
+        relAlias: specialized.relAlias,
+        compileStats: specialized.compileStats
+      };
       typingMode = "specialized";
     }
   }
 
-  return compileWasmArtifactFromDefs(defs, mainRelName, { typingMode });
+  return compileWasmArtifactFromDefs(defs, mainRelName, {
+    typingMode,
+    usePKIR
+  });
 }
 
 async function compileWasmArtifact(
   source,
-  { libraries = [], exports = [], source: sourceName = null, inputEnvelopePattern = null } = {}
+  {
+    libraries = [],
+    exports = [],
+    source: sourceName = null,
+    inputEnvelopePattern = null,
+    usePKIR = false
+  } = {}
 ) {
   const preamble = buildExportPreamble(exports, libraries);
   const fullSource = preamble + source;
-  const options = { libraries, ...(sourceName ? { source: sourceName } : {}) };
+  const options = {
+    libraries,
+    ...(sourceName ? { source: sourceName } : {})
+  };
   let defs = annotate(fullSource, options);
 
   let typingMode = "generic";
   if (inputEnvelopePattern) {
     const mainRel = defs.rels.__main__;
-    const inputPattern = getPatternPropertyList(mainRel.typePatternGraph, mainRel.def.patterns[0]);
-    const outputPattern = getPatternPropertyList(mainRel.typePatternGraph, mainRel.def.patterns[1]);
+    const inputPattern = getPatternPropertyList(
+      mainRel.typePatternGraph,
+      mainRel.def.patterns[0]
+    );
+    const outputPattern = getPatternPropertyList(
+      mainRel.typePatternGraph,
+      mainRel.def.patterns[1]
+    );
     if (classifyTyping(inputPattern, outputPattern).program === "polymorphic") {
-      const obj = { format: "k-object", rels: defs.rels, relAlias: defs.relAlias, compileStats: defs.compileStats, main: "__main__" };
-      const specialized = specializeObjectRelations(obj, "__main__", inputEnvelopePattern);
-      defs = { rels: specialized.rels, relAlias: specialized.relAlias, compileStats: specialized.compileStats };
+      const obj = {
+        format: "k-object",
+        rels: defs.rels,
+        relAlias: defs.relAlias,
+        compileStats: defs.compileStats,
+        main: "__main__"
+      };
+      const specialized = specializeObjectRelations(
+        obj,
+        "__main__",
+        inputEnvelopePattern
+      );
+      defs = {
+        rels: specialized.rels,
+        relAlias: specialized.relAlias,
+        compileStats: specialized.compileStats
+      };
       typingMode = "specialized";
     }
   }
 
-  return compileWasmArtifactFromDefs(defs, "__main__", { typingMode });
+  return compileWasmArtifactFromDefs(defs, "__main__", {
+    typingMode,
+    usePKIR
+  });
+}
+
+async function compileWasmArtifactFromPKIR(pkirInput, options = {}) {
+  let kvmProgram;
+  let entry = options.entry || "__main__";
+  if (pkirInput && typeof pkirInput === "object") {
+    if (pkirInput.format === "pk-ir" && pkirInput.functions) {
+      entry = pkirInput.entry || entry;
+      kvmProgram = {};
+      for (const [name, f] of Object.entries(pkirInput.functions)) {
+        kvmProgram[name] = lowerPKIRToKVM(f);
+      }
+    } else if (pkirInput.instructions) {
+      const kvm = lowerPKIRToKVM(pkirInput);
+      entry = kvm.name || entry;
+      kvmProgram = { [entry]: kvm };
+    } else if (pkirInput.functions) {
+      entry = pkirInput.entry || entry;
+      kvmProgram = {};
+      for (const [name, f] of Object.entries(pkirInput.functions)) {
+        kvmProgram[name] = lowerPKIRToKVM(f);
+      }
+    } else {
+      throw new Error("Invalid PKIR input for WebAssembly compilation");
+    }
+  } else {
+    throw new Error("Expected PKIR input object");
+  }
+  return compileWasmArtifactFromKVM(
+    { format: "k-vm", layer: "KVM", entry, functions: kvmProgram },
+    options
+  );
 }
 
 function createTagRegistry(entries) {
@@ -1050,6 +1155,7 @@ export {
   appendCustomSection,
   compileWasmArtifactFromKVM,
   compileWasmArtifactFromObject,
+  compileWasmArtifactFromPKIR,
   compileWasmArtifact,
   instantiateWasmArtifact,
   metadataFromModule,
@@ -1067,6 +1173,7 @@ export default {
   appendCustomSection,
   compileWasmArtifactFromKVM,
   compileWasmArtifactFromObject,
+  compileWasmArtifactFromPKIR,
   compileWasmArtifact,
   metadataFromModule,
   readArenaValue,

package/browser/repl-browser.mjs

@@ -311,13 +311,17 @@ export async function executeCommand(input) {
 function updateEngineUI() {
   const badge = document.getElementById("engine-badge");
   if (!badge) return;
-  badge.textContent = state.engine === "js" ? "js-in-process" : "wasm-in-process";
-  badge.title = `Engine: ${state.engine} (click to toggle wasm/js)`;
+  badge.classList.remove("js-mode", "pkir-mode");
   if (state.engine === "js") {
+    badge.textContent = "js-in-process";
     badge.classList.add("js-mode");
+  } else if (state.engine === "pkir") {
+    badge.textContent = "pkir-wasm";
+    badge.classList.add("pkir-mode");
   } else {
-    badge.classList.remove("js-mode");
+    badge.textContent = "wasm-in-process";
   }
+  badge.title = `Engine: ${state.engine} (click to toggle wasm/pkir/js)`;
 }
 
 function adjustInputHeight() {
@@ -979,11 +983,18 @@ export function initRepl() {
     }
   });
 
-  // Engine Badge toggle (wasm <-> js)
+  // Engine Badge toggle (wasm -> pkir -> js -> wasm)
   const engineBadge = document.getElementById("engine-badge");
   if (engineBadge) {
     engineBadge.onclick = () => {
-      const nextEngine = state.engine === "wasm" ? "js" : "wasm";
+      let nextEngine;
+      if (state.engine === "wasm") {
+        nextEngine = "pkir";
+      } else if (state.engine === "pkir") {
+        nextEngine = "js";
+      } else {
+        nextEngine = "wasm";
+      }
       executeCommand(`:engine ${nextEngine}`);
     };
   }

package/codecs/k-parse.mjs

@@ -7,10 +7,32 @@ import { isMainEntrypoint } from "./runtime/cli-entry.mjs";
 import { patternFromFilter } from "./runtime/pattern-k.mjs";
 import { encodeToWire } from "./runtime/prefix-codec.mjs";
 
-function usage(prog) {
-  console.error(`Usage: ${prog} [--input-type <type-script|type-file> | --input-pattern <pattern-script|pattern-file>] [value-file]`);
-  console.error("  Parse a textual k value and emit the self-hosted binary pattern+value stream.");
-  console.error("  If no pattern or type is provided, derive a closed pattern from the value.");
+function helpText() {
+  const prog = argv[1] || "k-parse.mjs";
+  return [
+    "Parse a textual k value and emit a binary pattern+value stream.",
+    "If no pattern or type is provided, derives a closed pattern from",
+    "the value.",
+    "",
+    `Usage: ${prog} [options] [value-file]`,
+    "",
+    "Arguments:",
+    "  value-file             Input textual k value file.",
+    "                         Reads from stdin when omitted.",
+    "",
+    "Options:",
+    "  --input-type type      Type filter script or file for pattern.",
+    "  --input-pattern json   Pattern JSON string or file.",
+    "  -h, --help             Show this help.",
+    "",
+    "Examples:",
+    `  echo '{"x": 1}' | ${prog} | k-print`,
+    `  ${prog} --input-type '<{} a, {} b>' value.kv`
+  ].join("\n");
+}
+
+function usage(stream = console.error) {
+  stream(helpText());
 }
 
 function maybeReadFile(s) {
@@ -31,11 +53,10 @@ function readAll(stream) {
 }
 
 async function main() {
-  const prog = argv[1];
   const args = argv.slice(2);
 
   if (args.includes("-h") || args.includes("--help")) {
-    usage(prog);
+    usage(console.log);
     return exit(0);
   }
 
@@ -51,13 +72,13 @@ async function main() {
     } else if (valueFile == null) {
       valueFile = args[i];
     } else {
-      usage(prog);
+      usage();
       return exit(1);
     }
   }
 
   if (inputTypeArg != null && inputPatternArg != null) {
-    usage(prog);
+    usage();
     return exit(1);
   }
 

package/codecs/k-print.mjs

@@ -5,13 +5,29 @@ import { argv, stdin, stdout } from "node:process";
 import { isMainEntrypoint } from "./runtime/cli-entry.mjs";
 import { decodeWire } from "./runtime/prefix-codec.mjs";
 
+function helpText() {
+  const prog = argv[1] || "k-print.mjs";
+  return [
+    "Read a binary pattern+value stream and print the decoded",
+    "textual value.",
+    "",
+    `Usage: ${prog} [options] [file]`,
+    "",
+    "Arguments:",
+    "  file         Input binary wire file (default: stdin).",
+    "",
+    "Options:",
+    "  --debug      Print decoded pattern and value as JSON.",
+    "  -h, --help   Show this help.",
+    "",
+    "Examples:",
+    `  echo '"hello"' | k-parse | ${prog}`,
+    `  ${prog} input.wire`
+  ].join("\n");
+}
+
 function usage(stream = console.error) {
-  stream(`Usage: ${argv[1]} [--debug] [file]`);
-  stream("  Read a binary pattern+value stream and print the decoded textual value.");
-  stream("");
-  stream("Options:");
-  stream("  --debug      Print decoded pattern and value as JSON.");
-  stream("  -h, --help   Show this help.");
+  stream(helpText());
 }
 
 function readAll(stream) {

package/codecs/runtime/codec-sdk.mjs

@@ -22,10 +22,14 @@ function printUsage(fileName, doc) {
   if (doc) {
     stdout.write(`${doc.trim()}\n\n`);
   }
-  stdout.write("Options:\n");
-  stdout.write("  --parse      Read external text from stdin, write binary pattern+value stream to stdout.\n");
-  stdout.write("  --print      Read binary pattern+value stream from stdin, write external text to stdout.\n");
-  stdout.write("  -h, --help   Show this help.\n");
+  stdout.write(
+    "Options:\n" +
+    "  --parse      Read external text from stdin, write binary\n" +
+    "               pattern+value stream to stdout.\n" +
+    "  --print      Read binary pattern+value stream from stdin,\n" +
+    "               write external text to stdout.\n" +
+    "  -h, --help   Show this help.\n"
+  );
 }
 
 function runCodecCLI(metaUrl, codec) {