@fraczak/k 7.0.1 → 7.1.0

package/backends/llvm/{bin → tests}/k-llvm-run.mjs

@@ -6,22 +6,35 @@ import { decodeObject } from "@fraczak/k/object.mjs";
 import { parseValue } from "@fraczak/k/valueIO.mjs";
 import { compileObjectAndRun } from "../src/executable.mjs";
 
-function usage(stream = console.error) {
+function helpText() {
   const prog = argv[1] || "k-llvm-run.mjs";
-  stream(`Usage: node ${prog} [options] object-file [input.kv]`);
-  stream("Compile and execute a k .ko/.klib object through LLVM.");
-  stream("");
-  stream("Arguments:");
-  stream("  object-file     Input .ko or .klib file.");
-  stream("  input.kv        Input value. Reads text from stdin 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("  --expect value          Expected output value JSON/k-value text, or a file containing it.");
-  stream("  -h, --help              Show this help.");
-  stream("");
-  stream("Without --expect, the runner prints the result value as compact JSON.");
+  return [
+    "Compile and execute a k .ko/.klib object through LLVM.",
+    "",
+    `Usage: ${prog} [options] object-file [input.kv]`,
+    "",
+    "Arguments:",
+    "  object-file     Input .ko or .klib file.",
+    "  input.kv        Input value. Reads text from stdin when omitted.",
+    "",
+    "Options:",
+    "  --retype rel            Relation to specialize (default: main).",
+    "  --input-pattern value   Input pattern property-list JSON or file.",
+    "  --expect value          Expected output value JSON/text or file.",
+    "  --pkir                  Lower via Polymorphic K IR (PKIR).",
+    "  -h, --help              Show this help.",
+    "",
+    "Without --expect, the runner prints the result as compact JSON.",
+    "",
+    "Examples:",
+    `  ${prog} program.ko input.kv`,
+    `  ${prog} --expect expected.kv program.ko input.kv`,
+    `  echo '{"x":"left"}' | ${prog} program.ko`
+  ].join("\n");
+}
+
+function usage(stream = console.error) {
+  stream(helpText());
 }
 
 async function readStdinText() {
@@ -33,7 +46,9 @@ async function readStdinText() {
 }
 
 function readMaybeFile(textOrPath) {
-  return fs.existsSync(textOrPath) ? fs.readFileSync(textOrPath, "utf8") : textOrPath;
+  return fs.existsSync(textOrPath)
+    ? fs.readFileSync(textOrPath, "utf8")
+    : textOrPath;
 }
 
 function readPattern(inputPattern) {
@@ -51,6 +66,7 @@ try {
   let relation = null;
   let inputPattern = null;
   let expectedText = null;
+  let usePKIR = false;
   while (args.length > 0 && args[0].startsWith("--")) {
     const option = args.shift();
     if (option === "--retype") {
@@ -58,10 +74,16 @@ try {
       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");
+      if (!inputPattern) {
+        throw new Error("--input-pattern requires JSON or a file path");
+      }
     } else if (option === "--expect") {
       expectedText = args.shift();
-      if (!expectedText) throw new Error("--expect requires a value or file path");
+      if (!expectedText) {
+        throw new Error("--expect requires a value or file path");
+      }
+    } else if (option === "--pkir") {
+      usePKIR = true;
     } else {
       throw new Error(`Unknown option: ${option}`);
     }
@@ -73,18 +95,22 @@ try {
   if (args.length > 0) throw new Error(`Unexpected argument: ${args[0]}`);
 
   const object = decodeObject(fs.readFileSync(objectPath));
-  const inputText = inputPath == null ? await readStdinText() : fs.readFileSync(inputPath, "utf8");
+  const inputText = inputPath == null
+    ? await readStdinText()
+    : fs.readFileSync(inputPath, "utf8");
   const input = parseValue(inputText);
-  const expected = expectedText == null ? null : parseValue(readMaybeFile(expectedText));
+  const expected = expectedText == null
+    ? null
+    : parseValue(readMaybeFile(expectedText));
   const result = compileObjectAndRun(object, {
     relation: relation || object.main,
     input,
     expected,
-    inputPattern: readPattern(inputPattern)
+    inputPattern: readPattern(inputPattern),
+    usePKIR
   });
   stdout.write(expected == null ? result.stdout : "OK\n");
 } catch (error) {
   console.error(error.stack || error.message || String(error));
-  usage();
   exit(1);
 }

package/backends/llvm/tests/perf-support.mjs

@@ -148,7 +148,17 @@ export function wireInput(value, pattern = value.pattern) {
   };
 }
 
-export function compileCaseExecutable({ object, relationName, relHash, inputPattern, cacheDir, sourceLabel, runtimeMode = "fast", clangOpt = "-O3" }) {
+export function compileCaseExecutable({
+  object,
+  relationName,
+  relHash,
+  inputPattern,
+  cacheDir,
+  sourceLabel,
+  runtimeMode = "fast",
+  clangOpt = "-O3",
+  usePKIR = false
+}) {
   const key = sha256([
     "k-llvm-perf-v1",
     backendFingerprint(),
@@ -157,12 +167,23 @@ export function compileCaseExecutable({ object, relationName, relHash, inputPatt
     sourceLabel,
     relationName,
     relHash,
-    JSON.stringify(inputPattern)
+    JSON.stringify(inputPattern),
+    usePKIR ? "pkir" : "kir"
   ].join("\0"));
   const exePath = path.join(cacheDir, `${key}.exe`);
   if (!fs.existsSync(exePath)) {
     const tmpPath = path.join(cacheDir, `${key}.${process.pid}.tmp`);
-    compileObjectToExecutable(cloneObjectPayload(object), tmpPath, { relation: relationName, inputPattern, runtimeMode, clangOpt });
+    compileObjectToExecutable(
+      cloneObjectPayload(object),
+      tmpPath,
+      {
+        relation: relationName,
+        inputPattern,
+        runtimeMode,
+        clangOpt,
+        usePKIR
+      }
+    );
     fs.renameSync(tmpPath, exePath);
   }
   return exePath;
@@ -216,7 +237,7 @@ export function runExecutableMainBench(exePath, inputWire, calls) {
         reject(new Error(`${exePath} --bench-main failed with status ${status}\n${text}`.trim()));
         return;
       }
-      const match = text.match(/K_(?:LLVM|ARM64)_BENCH_MAIN calls=(\d+) total_ns=(\d+) per_call_ns=([0-9.]+)/);
+      const match = text.match(/K_LLVM_BENCH_MAIN calls=(\d+) total_ns=(\d+) per_call_ns=([0-9.]+)/);
       if (!match) {
         reject(new Error(`${exePath} --bench-main did not report timing\n${text}`.trim()));
         return;
@@ -599,61 +620,7 @@ export function llvmLaneName() {
     : "LLVM Executable (persistent)";
 }
 
-export function arm64LaneName(optLevel = "-O2") {
-  const mode = process.env.ARM64_SPAWN_PER_CALL === "1"
-    ? "spawn/call"
-    : (process.env.ARM64_PIPELINE === "1" ? "persistent, pipelined" : "persistent");
-  return `Linux ARM64 ${optLevel} (${mode})`;
-}
-
-export function createARM64Runner(testSuite) {
-  const arm64Cases = testSuite.filter(tc => tc.arm64?.status === "ok");
-  if (process.env.ARM64_SPAWN_PER_CALL === "1") {
-    return {
-      run(iterations) {
-        if (arm64Cases.length === 0) return null;
-        return runTimedIterationsAsync(iterations, async () => {
-          for (const tc of arm64Cases) {
-            await runExecutable(tc.arm64.exePath, tc.inputWire);
-          }
-        });
-      },
-      close() {}
-    };
-  }
-
-  const servers = new Map();
-  function serverFor(exePath) {
-    let server = servers.get(exePath);
-    if (server == null) {
-      server = new PersistentExecutable(exePath);
-      servers.set(exePath, server);
-    }
-    return server;
-  }
 
-  return {
-    async run(iterations) {
-      if (arm64Cases.length === 0) return null;
-      return runTimedIterationsAsync(iterations, async () => {
-        if (process.env.ARM64_PIPELINE === "1") {
-          const pending = [];
-          for (const tc of arm64Cases) {
-            pending.push(serverFor(tc.arm64.exePath).request(tc.inputWire));
-          }
-          await Promise.all(pending);
-          return;
-        }
-        for (const tc of arm64Cases) {
-          await serverFor(tc.arm64.exePath).request(tc.inputWire);
-        }
-      });
-    },
-    close() {
-      for (const server of servers.values()) server.close();
-    }
-  };
-}
 
 export function average(times) {
   return times.reduce((sum, time) => sum + time, 0) / times.length;

package/backends/llvm/tests/test-llvm.mjs

@@ -1,7 +1,14 @@
 import assert from "node:assert";
 import { compileObjectBuffer, decodeObject } from "@fraczak/k/object.mjs";
-import { compileObjectToLLVM, compileLLVMArtifactFromKVM, emitLLVMModule, llvmIdentifier } from "../src/llvm.mjs";
+import {
+  compileObjectToLLVM,
+  compileLLVMArtifactFromKVM,
+  compileLLVMArtifactFromPKIR,
+  emitLLVMModule,
+  llvmIdentifier
+} from "../src/llvm.mjs";
 import { objectToKVMArtifact } from "@fraczak/k/kvm.mjs";
+import { compileRelationToPKIR } from "@fraczak/k/backend-api.mjs";
 
 function kirP(body, { patternGraph = null } = {}) {
   return {
@@ -239,11 +246,11 @@ assert.doesNotMatch(nestedUnionLLVM, /call void @k_product_set_at\(ptr %product\
 assert.doesNotMatch(nestedUnionLLVM, /ptr false/);
 
 const productRecurseObject = decodeObject(compileObjectBuffer(`
-  list = ?< {} nil, { {} car, list cdr } cons >;
-  foo = list <
+  list? = ?< {} nil, { {} car, list? cdr } cons >;
+  foo = list? <
     /nil |nil,
     /cons { .car car, .cdr foo cdr } |cons
-  > list;
+  > list?;
   foo
 `, { source: "llvm-product-recurse.k" }));
 const { llvm: productRecurseLLVM } = compileObjectToLLVM(productRecurseObject, {
@@ -270,4 +277,18 @@ assert.match(kvmLLVM, /source_filename = "k-llvm:__main__"/);
 assert.match(kvmLLVM, /define %k_result @k_main/);
 assert.match(kvmLLVM, /store ptr %product_fields\d+, ptr %ptr_slot\d+/);
 
+// Test PKIR lowering via compileObjectToLLVM with usePKIR: true
+const pkirObjectLLVM = compileObjectToLLVM(productObject, {
+  usePKIR: true
+});
+assert.match(pkirObjectLLVM.llvm, /source_filename = "k-llvm:__main__"/);
+assert.match(pkirObjectLLVM.llvm, /define %k_result @k_main/);
+
+// Test compileLLVMArtifactFromPKIR directly
+const mainRel = productObject.rels[productObject.main || "__main__"];
+const pkirFromRel = compileRelationToPKIR(mainRel, "__main__");
+const pkirLLVM = compileLLVMArtifactFromPKIR(pkirFromRel);
+assert.match(pkirLLVM, /source_filename = "k-llvm:__main__"/);
+assert.match(pkirLLVM, /define %k_result @k_main/);
+
 console.log("OK");

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

@@ -9,22 +9,39 @@ import {
   resolveProgramInput
 } from "../src/cli.mjs";
 
-function usage(stream = console.error) {
+function helpText() {
   const prog = argv[1] || "k-wasm-compile.mjs";
-  stream(`Usage: node ${prog} [options] [source-snippet | input-file [wasm-file]]`);
-  stream("Compile k source, .ko, or .kvm input into a standalone WebAssembly artifact.");
-  stream("");
-  stream("Arguments:");
-  stream("  source-snippet  Inline k source, in the same style as k.mjs.");
-  stream("  input-file      Source .k, .ko, or .kvm file. Reads UTF-8 source from stdin when omitted.");
-  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'.");
-  stream("  -h, --help       Show this help.");
+  return [
+    "Compile k source, .ko, .kvm, or .pkir into a WebAssembly (.wasm)",
+    "artifact.",
+    "",
+    `Usage: ${prog} [options]`,
+    "       [source-snippet | input-file [output-wasm]]",
+    "",
+    "Arguments:",
+    "  source-snippet   Inline k source snippet (in the style of k.mjs).",
+    "  input-file       Source .k, .ko, .kvm, or .pkir file.",
+    "                   Reads UTF-8 source from stdin when omitted.",
+    "  output-wasm      Output .wasm path. Writes to stdout if omitted.",
+    "",
+    "Options:",
+    "  -o, --output path  Specify output file path explicitly.",
+    "  --pkir             Lower via Polymorphic K IR (PKIR).",
+    "  --lib file         Load one .klib or .k library before compiling.",
+    "  --export spec      Export library alias into scope. Repeatable.",
+    "                     spec is 'name' or 'libname:localname'.",
+    "  -h, --help         Show this help.",
+    "",
+    "Examples:",
+    `  ${prog} 'x = |x; x x' program.wasm`,
+    `  ${prog} program.k -o program.wasm`,
+    `  ${prog} --pkir program.k -o program.wasm`,
+    `  ${prog} --lib core.klib --export add program.k program.wasm`
+  ].join("\n");
+}
+
+function usage(stream = console.error) {
+  stream(helpText());
 }
 
 try {
@@ -41,18 +58,28 @@ try {
     if (arg === "-o" || arg === "--output") {
       args.shift();
       explicitOutput = args.shift();
-      if (!explicitOutput) throw new Error("-o/--output requires a file argument");
+      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 { libraries, exportSpecs, usePKIR } =
+    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 });
+  const artifact = await compileProgramInput(input, {
+    libraries,
+    exportSpecs,
+    stdin,
+    usePKIR
+  });
   if (outputPath == null) {
     stdout.write(artifact);
   } else {
@@ -60,6 +87,5 @@ try {
   }
 } catch (error) {
   console.error(error.stack || error.message || String(error));
-  usage();
   exit(1);
 }

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

@@ -5,31 +5,54 @@ import { argv, exit, stdin, stdout, stderr } from "node:process";
 
 import { instantiateWasmArtifact } from "../src/wasm.mjs";
 
-function usage(stream = console.error) {
+function helpText() {
   const prog = argv[1] || "k-wasm-run.mjs";
-  stream(`Usage: node ${prog} [ --server ] wasm-file [ input-file ]`);
-  stream("Run a standalone k WebAssembly artifact over a binary pattern+value stream.");
-  stream("");
-  stream("Arguments:");
-  stream("  wasm-file   Input .wasm artifact produced by k-wasm-compile.");
-  stream("  input-file  Optional binary input stream. Reads stdin when omitted.");
-  stream("");
-  stream("Options:");
-  stream("  --server    Run as a persistent server reading framed requests from stdin.");
-  stream("  -h, --help  Show this help.");
+  return [
+    "Run a standalone WebAssembly (.wasm) artifact over a binary",
+    "pattern+value wire stream.",
+    "",
+    `Usage: ${prog} [options] wasm-file [ input-wire-file ]`,
+    "",
+    "Arguments:",
+    "  wasm-file        Input .wasm artifact produced by k-wasm-compile.",
+    "  input-wire-file  Optional binary wire input (default: stdin).",
+    "",
+    "Options:",
+    "  --server    Run as persistent server reading framed requests from",
+    "              stdin.",
+    "  -h, --help  Show this help.",
+    "",
+    "Environment Variables:",
+    "  K_TRACE, TRACE  When '1', output phase tracing metrics to stderr.",
+    "",
+    "Examples:",
+    `  echo '"hello"' | k-json --parse | \\`,
+    `    ${prog} prog.wasm | k-json --print`,
+    `  ${prog} prog.wasm input.wire > output.wire`,
+    `  ${prog} --server prog.wasm`
+  ].join("\n");
+}
+
+function usage(stream = console.error) {
+  stream(helpText());
 }
 
 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);
   });
 }
 
 async function runServer(runner) {
-  const tracing = process.env.K_TRACE === "1" || process.env.TRACE === "1";
+  const tracing =
+    process.env.K_TRACE === "1" || process.env.TRACE === "1";
   let inBuffer = Buffer.alloc(0);
   let readStartNs = 0n;
 
@@ -82,10 +105,17 @@ async function runServer(runner) {
           const encodeNs = trace.encodeNs;
           const ipcWriteNs = Number(tEnd - writeStart);
           const totalNs = Number(tEnd - (readStartNs > 0n ? readStartNs : t1));
-          stderr.write(`K_TRACE_PHASES backend=wasm ipc_read_ns=${ipcReadNs} decode_ns=${decodeNs} flat_in_ns=${flatInNs} eval_ns=${evalNs} flat_out_ns=${flatOutNs} encode_ns=${encodeNs} ipc_write_ns=${ipcWriteNs} total_ns=${totalNs}\n`);
+          stderr.write(
+            `K_TRACE_PHASES backend=wasm ipc_read_ns=${ipcReadNs} ` +
+              `decode_ns=${decodeNs} flat_in_ns=${flatInNs} ` +
+              `eval_ns=${evalNs} flat_out_ns=${flatOutNs} ` +
+              `encode_ns=${encodeNs} ipc_write_ns=${ipcWriteNs} ` +
+              `total_ns=${totalNs}\n`
+          );
         }
       } catch (err) {
-        stderr.write(`Wasm server error: ${err.stack || err.message || String(err)}\n`);
+        const msg = err.stack || err.message || String(err);
+        stderr.write(`Wasm server error: ${msg}\n`);
         exit(1);
       }
 
@@ -102,7 +132,7 @@ async function main() {
   }
 
   const isServer = rawArgs.includes("--server");
-  const args = rawArgs.filter(a => a !== "--server");
+  const args = rawArgs.filter((a) => a !== "--server");
 
   const wasmPath = args.shift();
   if (!wasmPath) throw new Error("Missing .wasm artifact path");
@@ -111,7 +141,9 @@ async function main() {
   const runner = await instantiateWasmArtifact(artifact);
 
   if (isServer) {
-    if (args.length > 0) throw new Error("Too many arguments for --server mode");
+    if (args.length > 0) {
+      throw new Error("Too many arguments for --server mode");
+    }
     await runServer(runner);
     return;
   }
@@ -119,14 +151,23 @@ async function main() {
   const inputPath = args.shift();
   if (args.length > 0) throw new Error("Too many arguments");
 
-  const input = await readAll(inputPath == null ? stdin : fs.createReadStream(inputPath));
-  const tracing = process.env.K_TRACE === "1" || process.env.TRACE === "1";
+  const inputStream =
+    inputPath == null ? stdin : fs.createReadStream(inputPath);
+  const input = await readAll(inputStream);
+  const tracing =
+    process.env.K_TRACE === "1" || process.env.TRACE === "1";
   if (tracing) {
     const res = runner.execute(input, { trace: true });
     stdout.write(res.outputWire);
     if (res.trace) {
       const trace = res.trace;
-      stderr.write(`K_TRACE_PHASES backend=wasm ipc_read_ns=0 decode_ns=${trace.decodeNs} flat_in_ns=${trace.flatInNs} eval_ns=${trace.evalNs} flat_out_ns=${trace.flatOutNs} encode_ns=${trace.encodeNs} ipc_write_ns=0 total_ns=${trace.evalNs}\n`);
+      stderr.write(
+        `K_TRACE_PHASES backend=wasm ipc_read_ns=0 ` +
+          `decode_ns=${trace.decodeNs} flat_in_ns=${trace.flatInNs} ` +
+          `eval_ns=${trace.evalNs} flat_out_ns=${trace.flatOutNs} ` +
+          `encode_ns=${trace.encodeNs} ipc_write_ns=0 ` +
+          `total_ns=${trace.evalNs}\n`
+      );
     }
   } else {
     stdout.write(runner.execute(input));

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

@@ -12,16 +12,40 @@ import {
 } from "../src/cli.mjs";
 import { runWasmArtifact } from "../src/wasm.mjs";
 
-function usage(stream = console.error) {
+function helpText() {
   const prog = argv[1] || "k-wasm.mjs";
-  stream(`Usage: node ${prog} [options] ( source-snippet | input-file ) [ input-file ]`);
-  stream("Compile k source, .ko, or .kvm input to WebAssembly in memory and run it over a binary pattern+value stream.");
-  stream("");
-  stream("Options:");
-  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.");
+  return [
+    "Compile k source, .ko, .kvm, or .pkir to WebAssembly in memory",
+    "and run it over a binary pattern+value wire stream.",
+    "",
+    `Usage: ${prog} [options]`,
+    "       ( source-snippet | input-file ) [ input-wire-file ]",
+    "",
+    "Arguments:",
+    "  source-snippet   Inline k source snippet (in the style of k.mjs).",
+    "  input-file       Source .k, .ko, .kvm, or .pkir file.",
+    "  input-wire-file  Optional binary wire input (default: stdin).",
+    "",
+    "Options:",
+    "  --lib file        Load one .klib or .k library before compiling.",
+    "  --export spec     Export library alias into scope. Repeatable.",
+    "                    spec is 'name' or 'libname:localname'.",
+    "  --pkir            Lower via Polymorphic K IR (PKIR).",
+    "  -h, --help        Show this help.",
+    "",
+    "Environment Variables:",
+    "  K_TRACE, TRACE    When '1', output phase tracing to stderr.",
+    "",
+    "Examples:",
+    `  echo '"abc"' | k-parse | ${prog} '{.1 0}' | k-print`,
+    `  echo '{"x":1,"y":2}' | k-json --parse | \\`,
+    `    ${prog} --lib Examples/poly.k --export concat \\`,
+    `      's={()xs,()ys}concat; s' | k-json --print`
+  ].join("\n");
+}
+
+function usage(stream = console.error) {
+  stream(helpText());
 }
 
 async function main() {
@@ -31,19 +55,29 @@ async function main() {
     return;
   }
 
-  const { libraries, exportSpecs } = parseCompileOptions(args);
+  const { libraries, exportSpecs, usePKIR } = parseCompileOptions(args);
   const programInput = resolveProgramInput(args);
   const inputPath = args.shift();
   if (args.length > 0) throw new Error("Too many arguments");
 
-  const inputBuffer = await readAll(inputPath == null ? stdin : fs.createReadStream(inputPath));
+  const inputBuffer = await readAll(
+    inputPath == null ? stdin : fs.createReadStream(inputPath)
+  );
+  if (inputBuffer.length === 0) {
+    throw new Error("No input wire data received on stdin");
+  }
+
   const { pattern: inputEnvelopePattern } = decodeWire(inputBuffer);
-  const artifact = await compileProgramInput(programInput, { libraries, exportSpecs, inputEnvelopePattern });
+  const artifact = await compileProgramInput(programInput, {
+    libraries,
+    exportSpecs,
+    inputEnvelopePattern,
+    usePKIR
+  });
   stdout.write(await runWasmArtifact(artifact, inputBuffer));
 }
 
 main().catch((error) => {
   console.error(error.stack || error.message || String(error));
-  usage();
   exit(1);
 });