@fraczak/k 6.6.0 → 6.7.0

package/backends/arm64/README.md

@@ -78,7 +78,6 @@ All tools accept `--help`.
 
 - `-S, --assembly`: Emit GNU ARM64 assembly text (`.s`) instead of an ELF binary.
 - `-o, --output <file>`: Specify the output file path.
-- `--entry <name>`: Specify the entry relation (defaults to `__main__`).
 - `--lib <file>`: Load one `.klib` or `.k` library dependency.
 - `--export <spec>`: Export library symbols into source scope (`name` or `libname:localname`).
 - `--json`: Format output as JSON instead of binary wire format.

package/backends/arm64/bin/k-arm64-compile.mjs

@@ -22,7 +22,6 @@ function usage(stream = console.error) {
   stream("Options:");
   stream("  -S, --assembly   Emit GNU ARM64 assembly (.s) instead of an executable binary.");
   stream("  -o, --output     Specify output file path explicitly.");
-  stream("  --entry name     Specify entry relation name.");
   stream("  --lib file       Load one .klib dependency before compiling.");
   stream("  --export spec    Export a library alias into source scope. May be repeated.");
   stream("                   spec is 'name' or 'libname:localname'.");
@@ -38,8 +37,6 @@ try {
 
   let emitAssembly = false;
   let explicitOutput = null;
-  let entry = null;
-
   // Extract ARM64-specific flags
   const remainingArgs = [];
   while (args.length > 0) {
@@ -51,10 +48,6 @@ try {
       args.shift();
       explicitOutput = args.shift();
       if (!explicitOutput) throw new Error("-o/--output requires a file argument");
-    } else if (arg === "--entry") {
-      args.shift();
-      entry = args.shift();
-      if (!entry) throw new Error("--entry requires a name argument");
     } else {
       remainingArgs.push(args.shift());
     }
@@ -71,7 +64,6 @@ try {
     libraries,
     exportSpecs,
     stdin,
-    entry,
     emit: emitAssembly ? "assembly" : null,
     outputPath: (!emitAssembly && outputPath) ? outputPath : null
   });

package/backends/llvm/README.md

@@ -23,7 +23,7 @@ backend from `backends/llvm`:
 npm install
 cd backends/llvm
 node ../../objects/compile.mjs '()' /tmp/id.ko
-node ./bin/k-llvm-compile.mjs --input-pattern '[["open-product",[]]]' /tmp/id.ko /tmp/id.ll
+node ./bin/k-llvm-compile.mjs /tmp/id.ko /tmp/id.ll
 ```
 
 The generated `.ll` embeds the envelope-specialized KIR-P contract as module
@@ -44,24 +44,26 @@ status in `k_result`. These operations can compose through KIR `comp`.
 ## CLI
 
 ```sh
-k-llvm-build [options] object.ko output-exe
-k-llvm-compile [options] object.ko [output.ll]
+k-llvm-build [options] [source-snippet | input-file [output-exe]]
+k-llvm-compile [options] [source-snippet | input-file [output.ll]]
 k-llvm-jit [options] object.ko
 k-llvm-run [options] object.ko [input.kv]
 ```
 
 Options:
 
-- `--retype rel`: current option spelling for the relation to
-  envelope-specialize; defaults to the object's `main`.
-- `--input-pattern json-or-file`: KIR property-list input pattern; required
-  for `k-llvm-build`.
-- `--expect value-or-file`: for `k-llvm-run`, compare the output value against
-  expected value text.
+- `-o, --output path`: specify output file path explicitly.
+- `--lib file`: load one `.klib` or `.k` dependency before compiling.
+- `--export spec`: export a library alias into source scope (`name` or `libname:localname`). May be repeated.
+- `--input-pattern json-or-file`: for `k-llvm-run`, KIR property-list input pattern.
+- `--retype rel`: for `k-llvm-run`, relation to specialize (defaults to object main).
+- `--expect value-or-file`: for `k-llvm-run`, compare the output value against expected value text.
 - `-h`, `--help`: show usage.
 
-Only `.ko` / `.klib` object input is supported in this first prototype.
-Source compilation remains owned by core `k`.
+The compile commands follow the unified k CLI input convention: pass inline
+source, an existing `.k` source file, or a `.ko`/`.klib` object. Reads UTF-8
+source from stdin when input is omitted. Output paths can be specified as a
+positional argument or explicitly with `-o, --output`.
 Without `--expect`, `k-llvm-run` prints the result value as compact JSON.
 `k-llvm-build` emits a native executable that reads and writes the binary
 k pattern+value envelope used by `codecs/k-parse.mjs` and `codecs/k-print.mjs`.

package/backends/llvm/bin/k-llvm-build.mjs

@@ -1,14 +1,22 @@
 #!/usr/bin/env node
 
-import fs from "node:fs";
-import { argv, exit } from "node:process";
-import { decodeObject } from "@fraczak/k/object.mjs";
+import { argv, exit, stdin } from "node:process";
+import {
+  compileProgramInputToObject,
+  parseCompileOptions,
+  resolveProgramInput
+} from "../src/cli.mjs";
 import { compileObjectToExecutable } from "../src/executable.mjs";
 
 function usage(stream = console.error) {
   const prog = argv[1] || "k-llvm-build.mjs";
-  stream(`Usage: node ${prog} [options] object-file output-exe`);
-  stream("Compile a k .ko/.klib object into a native executable.");
+  stream(`Usage: node ${prog} [options] [source-snippet | input-file [output-exe]]`);
+  stream("Compile k source, .ko, or .klib input into a native executable.");
+  stream("");
+  stream("Arguments:");
+  stream("  source-snippet  Inline k source, in the same style as k.mjs.");
+  stream("  input-file      Source .k, .ko, or .klib file. Reads UTF-8 source from stdin when omitted.");
+  stream("  output-exe      Output executable path.");
   stream("");
   stream("The executable reads a binary k pattern+value envelope from stdin and");
   stream("writes a binary k pattern+value envelope to stdout.");
@@ -16,18 +24,11 @@ function usage(stream = console.error) {
   stream("stdout is encoded with the compiled output pattern.");
   stream("");
   stream("Options:");
-  stream("  --retype rel            Relation to specialize. Defaults to object main.");
-  stream("  --input-pattern value   Required input pattern property-list JSON, or a file containing it.");
-  stream("  -h, --help              Show this help.");
-}
-
-function readMaybeFile(textOrPath) {
-  return fs.existsSync(textOrPath) ? fs.readFileSync(textOrPath, "utf8") : textOrPath;
-}
-
-function readPattern(inputPattern) {
-  if (inputPattern == null) return null;
-  return JSON.parse(readMaybeFile(inputPattern));
+  stream("  -o, --output path  Specify output file path explicitly.");
+  stream("  --lib file         Load one .klib dependency before compiling.");
+  stream("  --export spec      Export a library alias into source scope. May be repeated.");
+  stream("                     spec is 'name' or 'libname:localname'.");
+  stream("  -h, --help         Show this help.");
 }
 
 try {
@@ -37,33 +38,34 @@ try {
     exit(0);
   }
 
-  let relation = null;
-  let inputPattern = null;
-  while (args.length > 0 && args[0].startsWith("--")) {
-    const option = args.shift();
-    if (option === "--retype") {
-      relation = args.shift();
-      if (!relation) throw new Error("--retype requires a relation name");
-    } else if (option === "--input-pattern") {
-      inputPattern = args.shift();
-      if (!inputPattern) throw new Error("--input-pattern requires JSON or a file path");
+  let explicitOutput = null;
+  const remainingArgs = [];
+  while (args.length > 0) {
+    const arg = args[0];
+    if (arg === "-o" || arg === "--output") {
+      args.shift();
+      explicitOutput = args.shift();
+      if (!explicitOutput) throw new Error("-o/--output requires a file argument");
     } else {
-      throw new Error(`Unknown option: ${option}`);
+      remainingArgs.push(args.shift());
     }
   }
 
-  const objectPath = args.shift() || null;
-  const outputPath = args.shift() || null;
-  if (objectPath == null) throw new Error("object-file is required");
-  if (outputPath == null) throw new Error("output-exe is required");
-  if (args.length > 0) throw new Error(`Unexpected argument: ${args[0]}`);
-  if (inputPattern == null) throw new Error("--input-pattern is required for k-llvm-build");
+  const { libraries, exportSpecs } = parseCompileOptions(remainingArgs);
+  const input = resolveProgramInput(remainingArgs, { allowStdinSource: true });
+  const positionalOutput = remainingArgs.shift();
+  if (remainingArgs.length > 0) throw new Error("Too many arguments");
+
+  const outputPath = explicitOutput || positionalOutput || null;
+  if (outputPath == null) throw new Error("Output executable path is required (pass output-exe or -o/--output)");
 
-  const object = decodeObject(fs.readFileSync(objectPath));
-  compileObjectToExecutable(object, outputPath, {
-    relation: relation || object.main,
-    inputPattern: readPattern(inputPattern)
+  const object = await compileProgramInputToObject(input, {
+    libraries,
+    exportSpecs,
+    stdin
   });
+
+  compileObjectToExecutable(object, outputPath);
 } catch (error) {
   console.error(error.stack || error.message || String(error));
   usage();

package/backends/llvm/bin/k-llvm-compile.mjs

@@ -2,29 +2,30 @@
 
 import fs from "node:fs";
 import { argv, exit, stdin, stdout } from "node:process";
-import { compileBufferToLLVM } from "../src/llvm.mjs";
+import {
+  compileProgramInputToObject,
+  parseCompileOptions,
+  resolveProgramInput
+} from "../src/cli.mjs";
+import { compileObjectToLLVM } from "../src/llvm.mjs";
+import { inputPatternForObjectRelation } from "../src/executable.mjs";
 
 function usage(stream = console.error) {
   const prog = argv[1] || "k-llvm-compile.mjs";
-  stream(`Usage: node ${prog} [options] object-file [output.ll]`);
+  stream(`Usage: node ${prog} [options] [source-snippet | input-file [output.ll]]`);
   stream("Compile a k .ko/.klib object into prototype LLVM IR.");
   stream("");
   stream("Arguments:");
-  stream("  object-file     Input .ko or .klib file. Reads bytes from stdin when omitted.");
+  stream("  source-snippet  Inline k source, in the same style as k.mjs.");
+  stream("  input-file      Source .k, .ko, or .klib file. Reads UTF-8 source from stdin when omitted.");
   stream("  output.ll       Output LLVM IR path. Writes to stdout when omitted.");
   stream("");
   stream("Options:");
-  stream("  --retype rel            Relation to specialize. Defaults to object main.");
-  stream("  --input-pattern value   Input pattern property-list JSON, or a file containing it.");
-  stream("  -h, --help              Show this help.");
-}
-
-async function readStdinBytes() {
-  const chunks = [];
-  for await (const chunk of stdin) {
-    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-  }
-  return Buffer.concat(chunks);
+  stream("  -o, --output path  Specify output file path explicitly.");
+  stream("  --lib file         Load one .klib dependency before compiling.");
+  stream("  --export spec      Export a library alias into source scope. May be repeated.");
+  stream("                     spec is 'name' or 'libname:localname'.");
+  stream("  -h, --help         Show this help.");
 }
 
 try {
@@ -34,32 +35,41 @@ try {
     exit(0);
   }
 
-  let relation = null;
-  let inputPattern = null;
-  while (args.length > 0 && args[0].startsWith("--")) {
-    const option = args.shift();
-    if (option === "--retype") {
-      relation = args.shift();
-      if (!relation) throw new Error("--retype requires a relation name");
-    } else if (option === "--input-pattern") {
-      inputPattern = args.shift();
-      if (!inputPattern) throw new Error("--input-pattern requires JSON or a file path");
+  let explicitOutput = null;
+  const remainingArgs = [];
+  while (args.length > 0) {
+    const arg = args[0];
+    if (arg === "-o" || arg === "--output") {
+      args.shift();
+      explicitOutput = args.shift();
+      if (!explicitOutput) throw new Error("-o/--output requires a file argument");
     } else {
-      throw new Error(`Unknown option: ${option}`);
+      remainingArgs.push(args.shift());
     }
   }
-  if (inputPattern == null) throw new Error("--input-pattern is required");
 
-  const inputPath = args.shift() || null;
-  const outputPath = args.shift() || null;
-  if (args.length > 0) throw new Error(`Unexpected argument: ${args[0]}`);
+  const { libraries, exportSpecs } = parseCompileOptions(remainingArgs);
+  const input = resolveProgramInput(remainingArgs, { allowStdinSource: true });
+  const positionalOutput = remainingArgs.shift();
+  if (remainingArgs.length > 0) throw new Error("Too many arguments");
+
+  const outputPath = explicitOutput || positionalOutput || null;
+
+  const object = await compileProgramInputToObject(input, {
+    libraries,
+    exportSpecs,
+    stdin
+  });
+
+  const { llvm } = compileObjectToLLVM(object, {
+    relation: object.main,
+    inputPattern: inputPatternForObjectRelation(object, object.main)
+  });
 
-  const input = inputPath == null ? await readStdinBytes() : fs.readFileSync(inputPath);
-  const { llvm } = compileBufferToLLVM(input, { relation, inputPattern });
   if (outputPath == null) {
     stdout.write(llvm);
   } else {
-    fs.writeFileSync(outputPath, llvm);
+    fs.writeFileSync(outputPath, llvm, "utf8");
   }
 } catch (error) {
   console.error(error.stack || error.message || String(error));

package/backends/llvm/src/cli.mjs

@@ -0,0 +1,153 @@
+import fs from "node:fs";
+import path from "node:path";
+import { compileLibrary, compileObjectBuffer, decodeObject, loadLibrary } from "@fraczak/k/object.mjs";
+
+export 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("end", () => resolve(Buffer.concat(chunks)));
+    stream.on("error", reject);
+  });
+}
+
+export function parseCompileOptions(args) {
+  const libraries = [];
+  const exportSpecs = [];
+  let loadedLibrary = false;
+
+  while (args.length > 0) {
+    if (args[0] === "--") {
+      args.shift();
+      break;
+    }
+    if (args[0] === "--lib") {
+      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");
+      const ext = path.extname(libPath).toLowerCase();
+      if (ext === ".k") {
+        libraries.push(loadLibrary(compileLibrary(fs.readFileSync(libPath, "utf8"), { source: libPath })));
+      } else {
+        libraries.push(loadLibrary(decodeObject(fs.readFileSync(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)");
+      exportSpecs.push(spec);
+    } else if (args[0].startsWith("--")) {
+      break;
+    } else {
+      break;
+    }
+  }
+
+  return { libraries, exportSpecs };
+}
+
+export function fileInputType(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  if (ext === ".ko") return "ko";
+  if (ext === ".kvm") return "kvm";
+  if (ext === ".klib") return "klib";
+  return "source-file";
+}
+
+export function resolveProgramInput(args, { allowStdinSource = false } = {}) {
+  const inputArg = args.shift() ?? null;
+  if (inputArg == null) {
+    if (!allowStdinSource) throw new Error("Missing script argument");
+    return { kind: "stdin-source", sourceName: "<stdin>" };
+  }
+
+  const ext = path.extname(inputArg).toLowerCase();
+  if (fs.existsSync(inputArg)) {
+    const kind = fileInputType(inputArg);
+    return { kind, path: inputArg, sourceName: inputArg };
+  }
+
+  if ([".k", ".ko", ".kvm", ".klib"].includes(ext)) {
+    throw new Error(`Input file not found: ${inputArg}`);
+  }
+
+  return { kind: "inline-source", source: inputArg, sourceName: "<inline>" };
+}
+
+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 async function compileProgramInputToObject(
+  input,
+  { libraries = [], exportSpecs = [], stdin = null } = {}
+) {
+  let object;
+  if (input.kind === "inline-source") {
+    const preamble = buildExportPreamble(exportSpecs, libraries);
+    const objBuffer = compileObjectBuffer(preamble + input.source, {
+      libraries,
+      source: input.sourceName
+    });
+    object = decodeObject(objBuffer);
+  } else if (input.kind === "stdin-source") {
+    if (!stdin) throw new Error("stdin source requested without a stdin stream");
+    const source = (await readAll(stdin)).toString("utf8");
+    const preamble = buildExportPreamble(exportSpecs, libraries);
+    const objBuffer = compileObjectBuffer(preamble + source, {
+      libraries,
+      source: input.sourceName
+    });
+    object = decodeObject(objBuffer);
+  } else if (input.kind === "source-file") {
+    const source = fs.readFileSync(input.path, "utf8");
+    const preamble = buildExportPreamble(exportSpecs, libraries);
+    const objBuffer = compileObjectBuffer(preamble + source, {
+      libraries,
+      source: input.sourceName
+    });
+    object = decodeObject(objBuffer);
+  } else if (input.kind === "ko" || input.kind === "klib") {
+    object = decodeObject(fs.readFileSync(input.path));
+  } else if (input.kind === "kvm") {
+    throw new Error("Compiling directly from .kvm to LLVM is not yet supported; use .k or .ko input.");
+  } else {
+    throw new Error(`Unsupported input kind: ${input.kind}`);
+  }
+
+  return object;
+}
+
+export default {
+  buildExportPreamble,
+  compileProgramInputToObject,
+  fileInputType,
+  parseCompileOptions,
+  readAll,
+  resolveProgramInput
+};

package/backends/llvm/src/executable.mjs

@@ -531,7 +531,7 @@ export function compileLLVMToExecutable(llvm, outputPath, { driver = stdioDriver
       driverPath,
       llPath,
       "-o",
-      outputPath
+      path.resolve(outputPath)
     ]);
   } finally {
     fs.rmSync(tmpDir, { recursive: true, force: true });

package/backends/llvm/src/kvm2llvm.mjs

@@ -757,6 +757,7 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
           const fieldValues = [];
           const pSrc = getReg(inst.src);
           const pPattern = regPatterns.get(cleanReg(inst.src)) || (cleanReg(inst.src) === "in" ? regPatterns.get("in") : null);
+          let productFailed = false;
 
           for (let bIdx = 0; bIdx < N; bIdx++) {
             const branch = inst.branches[bIdx];
@@ -783,12 +784,21 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
               nextBlock: branchDone
             });
 
+            if (!branchRegValues.has(cleanReg(branchRes))) {
+              productFailed = true;
+              break;
+            }
+
             ctx.lines.push(`${branchDone}:`);
             ctx.currentBlock = branchDone;
-            const fVal = branchRegValues.get(cleanReg(branchRes)) || branchRes;
+            const fVal = branchRegValues.get(cleanReg(branchRes));
             fieldValues.push({ label: branch.label, val: fVal });
           }
 
+          if (productFailed) {
+            break;
+          }
+
           const requestedSize = K_PRODUCT_HEADER_SIZE + (K_FIELD_SIZE * N);
           const product = lowerRawAlloc(ctx, requestedSize, alignArenaSize(requestedSize));
           nullCheck(ctx, product, failTarget);

package/backends/llvm/tests/integration.sh

@@ -10,8 +10,7 @@ command -v clang >/dev/null || {
 }
 
 node ../../objects/compile.mjs '()' "$TMP_DIR/id.ko"
-printf '[["open-product",[]]]' > "$TMP_DIR/input.pattern.json"
-node ./bin/k-llvm-compile.mjs --input-pattern "$TMP_DIR/input.pattern.json" "$TMP_DIR/id.ko" "$TMP_DIR/id.ll"
+node ./bin/k-llvm-compile.mjs "$TMP_DIR/id.ko" "$TMP_DIR/id.ll"
 grep -q '@k_llvm_metadata' "$TMP_DIR/id.ll"
 grep -q 'define %k_result @k_main' "$TMP_DIR/id.ll"
 
@@ -19,32 +18,28 @@ clang -Wno-override-module -Iruntime runtime/krt.c tests/identity-driver.c "$TMP
 "$TMP_DIR/id"
 
 node ../../objects/compile.mjs '.x' "$TMP_DIR/projection.ko"
-printf '[["closed-product",[["x",1]]],["closed-product",[]]]' > "$TMP_DIR/projection.pattern.json"
-node ./bin/k-llvm-compile.mjs --input-pattern "$TMP_DIR/projection.pattern.json" "$TMP_DIR/projection.ko" "$TMP_DIR/projection.ll"
+node ./bin/k-llvm-compile.mjs "$TMP_DIR/projection.ko" "$TMP_DIR/projection.ll"
 grep -q 'product_fields_ptr' "$TMP_DIR/projection.ll"
 ! grep -q 'call ptr @k_product_get_at' "$TMP_DIR/projection.ll"
 clang -Wno-override-module -Iruntime runtime/krt.c tests/projection-driver.c "$TMP_DIR/projection.ll" -o "$TMP_DIR/projection"
 "$TMP_DIR/projection"
 
 node ../../objects/compile.mjs '{ .x fieldA, .y fieldB }' "$TMP_DIR/product.ko"
-printf '[["closed-product",[["x",1],["y",2]]],["closed-product",[["valA",1]]],["closed-product",[["valB",2]]]]' > "$TMP_DIR/product.pattern.json"
-node ./bin/k-llvm-compile.mjs --input-pattern "$TMP_DIR/product.pattern.json" "$TMP_DIR/product.ko" "$TMP_DIR/product.ll"
+node ./bin/k-llvm-compile.mjs "$TMP_DIR/product.ko" "$TMP_DIR/product.ll"
 grep -q 'store i32 1, ptr %i32_slot' "$TMP_DIR/product.ll"
 grep -q 'store ptr %product_fields' "$TMP_DIR/product.ll"
 clang -Wno-override-module -Iruntime runtime/krt.c tests/product-driver.c "$TMP_DIR/product.ll" -o "$TMP_DIR/product"
 "$TMP_DIR/product"
 
 node ../../objects/compile.mjs '|tag' "$TMP_DIR/variant.ko"
-printf '[["closed-product",[]]]' > "$TMP_DIR/variant.pattern.json"
-node ./bin/k-llvm-compile.mjs --input-pattern "$TMP_DIR/variant.pattern.json" "$TMP_DIR/variant.ko" "$TMP_DIR/variant.ll"
+node ./bin/k-llvm-compile.mjs "$TMP_DIR/variant.ko" "$TMP_DIR/variant.ll"
 grep -q 'call ptr @k_rt_alloc' "$TMP_DIR/variant.ll"
 grep -q 'store i32 2, ptr %i32_slot' "$TMP_DIR/variant.ll"
 clang -Wno-override-module -Iruntime runtime/krt.c tests/variant-driver.c "$TMP_DIR/variant.ll" -o "$TMP_DIR/variant"
 "$TMP_DIR/variant"
 
 node ../../objects/compile.mjs '/tag' "$TMP_DIR/variant-projection.ko"
-printf '[["closed-union",[["tag",1]]],["closed-product",[]]]' > "$TMP_DIR/variant-projection.pattern.json"
-node ./bin/k-llvm-compile.mjs --input-pattern "$TMP_DIR/variant-projection.pattern.json" "$TMP_DIR/variant-projection.ko" "$TMP_DIR/variant-projection.ll"
+node ./bin/k-llvm-compile.mjs "$TMP_DIR/variant-projection.ko" "$TMP_DIR/variant-projection.ll"
 grep -q 'tag_byte_ptr' "$TMP_DIR/variant-projection.ll"
 grep -q 'payload_slot' "$TMP_DIR/variant-projection.ll"
 ! grep -q 'call i32 @k_variant_tag_matches' "$TMP_DIR/variant-projection.ll"
@@ -53,24 +48,21 @@ clang -Wno-override-module -Iruntime runtime/krt.c tests/variant-projection-driv
 "$TMP_DIR/variant-projection"
 
 node ../../objects/compile.mjs '(.x .y)' "$TMP_DIR/composition.ko"
-printf '[["closed-product",[["x",1]]],["closed-product",[["y",2]]],["closed-product",[]]]' > "$TMP_DIR/composition.pattern.json"
-node ./bin/k-llvm-compile.mjs --input-pattern "$TMP_DIR/composition.pattern.json" "$TMP_DIR/composition.ko" "$TMP_DIR/composition.ll"
+node ./bin/k-llvm-compile.mjs "$TMP_DIR/composition.ko" "$TMP_DIR/composition.ll"
 grep -q 'product_fields_ptr' "$TMP_DIR/composition.ll"
 ! grep -q 'call ptr @k_product_get_at' "$TMP_DIR/composition.ll"
 clang -Wno-override-module -Iruntime runtime/krt.c tests/composition-driver.c "$TMP_DIR/composition.ll" -o "$TMP_DIR/composition"
 "$TMP_DIR/composition"
 
 node ../../objects/compile.mjs 'pick = .x; {.a pick left, .b pick right}' "$TMP_DIR/relation.ko"
-printf '[["open-product",[["a",1],["b",2]]],["open-product",[["x",3]]],["open-product",[["x",4]]],["closed-product",[]],["closed-product",[]]]' > "$TMP_DIR/relation.pattern.json"
-node ./bin/k-llvm-compile.mjs --input-pattern "$TMP_DIR/relation.pattern.json" "$TMP_DIR/relation.ko" "$TMP_DIR/relation.ll"
+node ./bin/k-llvm-compile.mjs "$TMP_DIR/relation.ko" "$TMP_DIR/relation.ll"
 grep -q 'define internal %k_result @k_rel_pick' "$TMP_DIR/relation.ll"
 grep -q 'call %k_result @k_rel_pick' "$TMP_DIR/relation.ll"
 clang -Wno-override-module -Iruntime runtime/krt.c tests/relation-driver.c "$TMP_DIR/relation.ll" -o "$TMP_DIR/relation"
 "$TMP_DIR/relation"
 
 node ../../objects/compile.mjs '< /x |left, /y |right >' "$TMP_DIR/union.ko"
-printf '[["closed-union",[["x",1],["y",2]]],["closed-product",[]],["closed-product",[]]]' > "$TMP_DIR/union.pattern.json"
-node ./bin/k-llvm-compile.mjs --input-pattern "$TMP_DIR/union.pattern.json" "$TMP_DIR/union.ko" "$TMP_DIR/union.ll"
+node ./bin/k-llvm-compile.mjs "$TMP_DIR/union.ko" "$TMP_DIR/union.ll"
 grep -q 'define internal %k_result @k_union_arm_0' "$TMP_DIR/union.ll"
 grep -q 'call %k_result @k_union_arm_1' "$TMP_DIR/union.ll"
 clang -Wno-override-module -Iruntime runtime/krt.c tests/union-driver.c "$TMP_DIR/union.ll" -o "$TMP_DIR/union"
@@ -94,8 +86,7 @@ node ../../objects/compile.mjs '{ .x fieldA, .y fieldB }' "$TMP_DIR/run-product.
 printf '{"x":"left","y":"right"}' > "$TMP_DIR/run-product-input.kv"
 node ./bin/k-llvm-run.mjs "$TMP_DIR/run-product.ko" "$TMP_DIR/run-product-input.kv" | grep -qx '{"fieldA":"left","fieldB":"right"}'
 
-printf '[["closed-product",[["x",1],["y",3]]],["open-union",[["left",2]]],["closed-product",[]],["open-union",[["right",2]]]]' > "$TMP_DIR/run-envelope.pattern.json"
-node ./bin/k-llvm-build.mjs --input-pattern "$TMP_DIR/run-envelope.pattern.json" "$TMP_DIR/run.ko" "$TMP_DIR/run-exe"
+node ./bin/k-llvm-build.mjs '?{<{}=X0 left, ...> x, <X0 right, ...> y} .x' -o "$TMP_DIR/run-exe"
 printf '{"x":"left","y":"right"}' \
   | node ../../codecs/k-parse.mjs \
   | "$TMP_DIR/run-exe" \
@@ -104,15 +95,13 @@ printf '{"x":"left","y":"right"}' \
 
 printf '{"x":"left"}' | node ../../codecs/k-parse.mjs | "$TMP_DIR/run-exe" && exit 1 || test "$?" -eq 5
 
-printf '[["open-union",[["left",1],["right",1]]],["closed-product",[]]]' > "$TMP_DIR/identity-variant.pattern.json"
-node ./bin/k-llvm-build.mjs --input-pattern "$TMP_DIR/identity-variant.pattern.json" "$TMP_DIR/id.ko" "$TMP_DIR/id-exe"
+node ./bin/k-llvm-build.mjs '?<{} left, {} right, ...>' -o "$TMP_DIR/id-exe"
 node --input-type=module -e "import { stdout } from 'node:process'; import { encodeToWire } from '../../codecs/runtime/prefix-codec.mjs'; import { Value } from '../../Value.mjs'; const pattern = [[\"open-union\",[[\"left\",1],[\"right\",1]]],[\"closed-product\",[]]]; stdout.write(encodeToWire(Value.variant(\"left\", Value.product({}), pattern), pattern));" \
   | "$TMP_DIR/id-exe" \
   | node --input-type=module -e "import { stdin } from 'node:process'; import { decodeWire } from '../../codecs/runtime/prefix-codec.mjs'; const chunks = []; stdin.on('data', (chunk) => chunks.push(chunk)); stdin.on('end', () => console.log(JSON.stringify(decodeWire(Buffer.concat(chunks)).pattern)));" \
   | grep -Fqx '[["open-union",[["left",1],["right",1]]],["closed-product",[]]]'
 
-printf '[["closed-union",[["+",1],["-",1]]],["closed-union",[["0",1],["1",1],["_",2]]],["closed-product",[]]]' > "$TMP_DIR/identity-int.pattern.json"
-node ./bin/k-llvm-build.mjs --input-pattern "$TMP_DIR/identity-int.pattern.json" "$TMP_DIR/id.ko" "$TMP_DIR/id-int-exe"
+node ./bin/k-llvm-build.mjs '$bits = < {} _, bits 0, bits 1 >; $int = < bits "+", bits "-" >; $int' -o "$TMP_DIR/id-int-exe"
 printf '2' \
   | node ../../codecs/int.mjs --parse \
   | "$TMP_DIR/id-int-exe" \
@@ -121,6 +110,13 @@ printf '2' \
 
 node --input-type=module -e "import assert from 'node:assert/strict'; import { spawn } from 'node:child_process'; import { encodeToWire, decodeWire } from '../../codecs/runtime/prefix-codec.mjs'; import { parse, INT_PATTERN } from '../../codecs/int.mjs'; const input = encodeToWire(parse('2'), INT_PATTERN); const header = Buffer.alloc(4); header.writeUInt32BE(input.length); const child = spawn(process.argv[1], ['--server']); const chunks = []; const stderr = []; child.stdout.on('data', (chunk) => chunks.push(chunk)); child.stderr.on('data', (chunk) => stderr.push(chunk)); child.stdin.end(Buffer.concat([header, input])); const status = await new Promise((resolve, reject) => { child.on('error', reject); child.on('close', resolve); }); assert.equal(status, 0, Buffer.concat(stderr).toString('utf8')); const output = Buffer.concat(chunks); const length = output.readUInt32BE(0); assert.equal(output.length, 4 + length); assert.deepEqual(decodeWire(output.subarray(4)).value.toJSON(), parse('2').toJSON());" "$TMP_DIR/id-int-exe"
 
+node ./bin/k-llvm-build.mjs --lib ../../Examples/arithmetics.k --export times 's = {()x, ()y} times; s' -o "$TMP_DIR/square-exe"
+printf '987654321' \
+  | node ../../codecs/int.mjs --parse \
+  | "$TMP_DIR/square-exe" \
+  | node ../../codecs/int.mjs --print \
+  | grep -qx '975461057789971041'
+
 printf '{"x":"left","y":"right"}' \
   | node ../../codecs/k-parse.mjs \
   | node ./bin/k-llvm-jit.mjs --cache-dir "$TMP_DIR/jit-cache" "$TMP_DIR/run.ko" \

package/backends/wasm/bin/k-wasm-compile.mjs

@@ -20,6 +20,7 @@ function usage(stream = console.error) {
   stream("  wasm-file       Output .wasm path. Writes the binary artifact to stdout when omitted.");
   stream("");
   stream("Options:");
+  stream("  -o, --output     Specify output file path explicitly.");
   stream("  --lib file       Load one .klib dependency before compiling.");
   stream("  --export spec    Export a library alias into source scope. May be repeated.");
   stream("                   spec is 'name' or 'libname:localname'.");
@@ -33,10 +34,24 @@ try {
     exit(0);
   }
 
-  const { libraries, exportSpecs } = parseCompileOptions(args);
-  const input = resolveProgramInput(args, { allowStdinSource: true });
-  const outputPath = args.shift();
-  if (args.length > 0) throw new Error("Too many arguments");
+  let explicitOutput = null;
+  const remainingArgs = [];
+  while (args.length > 0) {
+    const arg = args[0];
+    if (arg === "-o" || arg === "--output") {
+      args.shift();
+      explicitOutput = args.shift();
+      if (!explicitOutput) throw new Error("-o/--output requires a file argument");
+    } else {
+      remainingArgs.push(args.shift());
+    }
+  }
+
+  const { libraries, exportSpecs } = parseCompileOptions(remainingArgs);
+  const input = resolveProgramInput(remainingArgs, { allowStdinSource: true });
+  const positionalOutput = remainingArgs.shift();
+  if (remainingArgs.length > 0) throw new Error("Too many arguments");
+  const outputPath = explicitOutput || positionalOutput || null;
   const artifact = await compileProgramInput(input, { libraries, exportSpecs, stdin });
   if (outputPath == null) {
     stdout.write(artifact);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fraczak/k",
-    "version": "6.6.0",
+    "version": "6.7.0",
     "description": "k — a language for composing first-order partial functions over algebraic data types (products and tagged unions); includes runtime, type derivation, REPL, and codec toolchain",
     "main": "index.mjs",
     "exports": {