@fraczak/k 6.6.0 → 6.8.0

package/DOCS/REPL.md

@@ -33,29 +33,23 @@ complete.
 | Command | Meaning |
 | --- | --- |
 | `:help` | Show command summary |
-| `:type name = <...>` | Define a type alias |
 | `:type name` | Show the canonical definition of a type |
 | `:code name` | Alias for `:C name` |
-| `:rel name = expr` | Define a relation alias |
-| `:def name = expr` | Alias for `:rel` |
 | `:run expr` | Evaluate `expr` on the current value |
 | `:eval expr` | Alias for `:run` |
 | `:time expr` | Evaluate `expr` and report compilation and execution time |
-| `:timing [on\|off]` | Toggle compilation and execution timing reporting for all evaluations |
 | `:t name` | Show relation input/output filters |
 | `:d name` | Show relation definition |
 | `:C name` | Show canonical code definition |
 | `:codes` | List type aliases |
 | `:rels` | List relation aliases |
 | `:codec load name\|file` | Load a built-in codec (`int`, `utf8`, `json`, `ieee`, `unit`) or an ES module file |
-| `:codec define n t b` | Define an inline custom codec: `name type { parse: ..., print: ... }` |
 | `:codec unload name` | Unload a registered codec |
 | `:codec list` | List loaded REPL codecs (alias: `:codecs`) |
-| `:input type [codec]` | Read the next line as codec input for a type |
+| `:input [<filter=(...)> [codec]]` | Read next input line using specified codec (opens dialog in browser) |
 | `:load [--no-alias] file` | Load `.k` source or `.klib` into the current state |
 | `:klib file` | Export the active relation closure as a `.klib` library |
 | `:ko file expr` | Export a `.ko` executable with `expr` as main |
-| `:val` | Print current value and JSON form |
 | `:reset` | Reset interpreter state |
 | `:quit` / `:exit` | Exit |
 
@@ -143,8 +137,8 @@ Tab completion covers:
 Type aliases also complete in `$name` position inside raw k input.
 
 For codec commands, completion covers `:codec load`, `:codec list`, file paths
-after `:codec load`, type names after `:input`, and loaded codec names
-after the input type.
+after `:codec load`, type names or codec names after `:input`, and loaded codec names
+after the input pattern or type.
 
 ## Loading
 
@@ -193,44 +187,39 @@ property-list pattern that can be canonicalized to a code hash, and that hash is
 recalculated by the REPL. A universal codec exports `universal = true` instead
 of `codes` or `patterns`.
 
-### `:codec define name type { parse: ..., print: ... }`
-
-Registers a dynamic custom codec directly from the REPL:
-
-```k
-> :type bool = <{} true, {} false>
-> :codec define yn bool ({ parse: (t) => Value.variant(t.trim() === 'yes' ? 'true' : 'false', Value.product({})), print: (v) => v.tag === 'true' ? 'YES' : 'NO' })
-```
 
 ### `:codec unload name`
 
 Unloads a previously registered codec by name.
 
-### `:input type [codec]`
+### `:input [<filter=(...)> [codec]]`
 
-Resolves `type` to a canonical code hash, selects the registered codec, and
-consumes the next line verbatim as codec input. `type` may be a type alias, a
-canonical code hash, or an inline type expression such as
-`<{} true, {} false>`. The parsed value is validated against that type before
-becoming the current value.
+Resolves a pattern expression (e.g. `? {string a, float64 n}`, `? (...)`, `? <{} true, {} false>`), a type alias, or a canonical code hash, selects the registered codec, and consumes the next line verbatim as codec input.
 
-## Timing and Profiling
+If only a universal codec is specified (e.g. `:input json`), no pre-declared type or pattern is required; input is parsed directly and derives its pattern from the input payload.
 
-### `:time expr`
+When a pattern expression or type is provided, the parsed value is validated and constrained against that pattern before becoming the current value:
 
-Evaluates `expr` and reports the elapsed time broken down into compilation
-(type derivation + WebAssembly lowering/compilation) and runtime execution:
+```text
+> :input ? {string a, float64 n} json
+input ? {string a, float64 n} using json: enter value text
+json> {"a": "Woj", "n": 123}
+```
+
+## Timing and Profiling
+
+Timing reporting is enabled by default for all evaluations, reporting elapsed time
+broken down into compilation (type derivation + WebAssembly lowering/compilation) and runtime execution:
 
 ```text
-> :time {10 int x, 5 int y} plus
+> {10 int x, 5 int y} plus
 {}|_|1|1|1|1|+ ?<{} _, ...>
 /* comp: 12.4ms, exec: 0.8ms */
 ```
 
-### `:timing [on|off]`
+### `:time expr`
 
-Toggles automatic timing reporting for every snippet or expression evaluated in
-the session.
+Evaluates `expr` with explicit timing and records performance metrics in session state.
 
 ## Web REPL (Studio)
 
@@ -279,11 +268,9 @@ Evaluated values print in k syntax together with the inferred envelope:
 ## Example Session
 
 ```text
-> :type nat = <{} 0, nat +1>
-$ nat = @...
-> :rel inc = |+1
-inc = @...
-> {} |0
+> $ nat = < {} 0, nat +1 >;
+> inc = | +1;
+> {} | 0
 {}|0 ?<{} 0, ...>
 > :t inc
 inc : ?X0  -->  ?<X0 +1, ...>  (@...)

package/TODO.md

@@ -0,0 +1,112 @@
+# Web REPL Improvements & Conceptual Cleanup Plan
+
+This document details the issues, conceptual improvements, and completed enhancements for the `k` Web REPL (`browser/repl-browser.mjs`, `scripts/build-repl-html.mjs`, and `repl.html`).
+
+---
+
+## 1. General Branding & Visual Cleanup
+
+### Removal of `λ` (Lambda) Symbol
+- [x] Remove `<span class="brand-lambda">λ</span>` from the navbar in `scripts/build-repl-html.mjs`.
+- [x] Remove the `.brand-lambda` CSS class.
+- [x] Update welcome banner in `browser/repl-browser.mjs` to `k interactive repl`.
+- [x] Replace `λ` in string codec sample inputs with ASCII/Unicode text samples (e.g. `"abc"`).
+
+---
+
+## 2. Help Modal (`? Help` / `:help`) Overhaul
+
+### Language Overview & Grammar Categorization
+- [x] **Language Overview**: Short, positive, accessible description: `k` is a concise language of types and relations (functions) over tree-like (JSON-like) documents.
+- [x] **Content-Addressed Identity**: Functions and types are identified by their canonical content hash (`@...`) derived directly from their structure; local names are just temporary aliases used for recursion and readability.
+- [x] **Three Clean Grammar Categories**:
+   1. **Definitions (Local Aliases)**:
+     - `name = relExpr;` &mdash; Relation alias (e.g. `swap = { . y x, . x y };`).
+     - `$ name = typeExpr;` &mdash; Type alias (e.g. `$ bool = < {} true, {} false >;`).
+  2. **Type Expressions (`typeExpr`)**: Schemas describing tree-like documents:
+     - `{ Type_1 label_1, ..., Type_k label_k }` &mdash; Product type of arity $k$ (labeled records, e.g. `{float64 x, string n}`; special case: `{}` is the 0-ary product).
+     - `< Type_1 tag_1, ..., Type_k tag_k >` &mdash; Union type of arity $k$ (tagged sum of variants, e.g. `<int ok, string err>`).
+     - `name` / `@hash` &mdash; Type reference.
+  3. **Relation Expressions (`relExpr`)**: Functions transforming an input document to an output document:
+     - `{ rel_1 label_1, ..., rel_k label_k }` &mdash; Product of arity $k$ (evaluates relations into record fields; special case: `{}` evaluates 0 relations, producing empty record `{}`).
+     - `< rel_1, ..., rel_k >` &mdash; Union / ordered choice of arity $k$ (evaluates relations in order until one succeeds).
+     - `( rel_1 ... rel_k )` &mdash; Composition of arity $k$ (sequentially composes relations; special case: `()` is the 0-ary composition denoting identity; parentheses can be omitted when non-empty: `f g`).
+     - `. label` &mdash; Field projection (extracts field `label`).
+     - `/ tag` &mdash; Variant branch projection (extracts payload of variant `tag`).
+     - `| tag` &mdash; Variant constructor (wraps document into variant `tag`).
+     - `$ typeExpr` &mdash; Type constraint (asserts input matches schema; compile-time Type Error on mismatch).
+     - `name` / `@hash` &mdash; Relation reference.
+- [x] **Simplified Intro**:
+  - Made arbitrary arity explicit across products `{...}`, unions `<...>`, and compositions `(...)`; explained `{}` and `()` as the natural 0-ary special cases; omitted the pattern/filter expressions table from the introductory reference.
+- [x] **Replaced Misleading Expressions & Snippets**:
+  - Removed phantom concepts (`10` as literal, "bit-path", `{10 int x, 5 int y} plus` in default state).
+  - Added self-contained snippets (`{} | ok`, `not = < / true | false, / false | true >;`, `$ bool = < {} true, {} false >;`, `not = $ bool < / true | false, {} | true > $ bool;`, `swap = { . y x, . x y };`).
+- [x] **Command Reference Table**:
+  - Added `:time <expr>`.
+  - Removed obsolete commands: `:rel <name> = expr`, `:val`, `:timing [on|off]`, `:codec define n t b`.
+  - Updated `:type <name>` to purely inspect and display type definitions (type definition is native via `$ name = typeExpr;`).
+  - Timing is now always enabled by default across all evaluations.
+  - Updated `:input` documentation to note the interactive browser dialog.
+  - Clarified `:codes` (type aliases/hashes) and `:rels` (relation aliases).
+
+---
+
+## 3. Codecs Modal Overhaul
+
+### Concept Correction: External Format Adapters
+- [x] Reframed codecs as format adapters translating external text to/from $k$ values defined as pairs `(filter, tree)`.
+- [x] **Type-Specific Codecs**:
+  - `int`: Converts decimal integers to/from `$ int = < bits '+', bits '-' >`.
+  - `ieee`: Converts decimal floats to/from `$ float64` records (`sign`, `exponent`, `fraction`).
+  - `utf8`: Converts text to/from `$ string` (aliased to `$ utf8`), a list of Unicode scalar values (`$ unicode`) partitioned by Unicode planes.
+  - `unit`: Converts to/from `{}`.
+- [x] **Parameterized Codecs**:
+  - `json`: JSON text is untyped; deserializing JSON requires a target $k$ type schema parameter (e.g. `:input {float64 x, string n} json`).
+- [x] **Custom Codec Studio**:
+  - Updated explanation to emphasize pairs `(filter, tree)`.
+  - Fixed `yn` preset to provide self-contained type definition `$ bool = < {} true, {} false >;`.
+  - Fixed `blank` preset with proper Value payload formatting.
+
+---
+
+## 4. 'Input' Modal Overhaul
+
+- [x] **Parameterized Codec Support**:
+  - Converted "Target Type" control into an editable combobox / text input with datalist autocomplete for known aliases, while allowing arbitrary composite type expressions (`{float64 x, string n}`, `<int ok, string err>`).
+  - Integrated `resolveInputTypeHash(state, rawType)` into live validation and modal submit.
+  - Marked `json` as a Parameterized Codec requiring a target type schema.
+  - Added composite quick samples demonstrating type + JSON payload pairs (e.g. `{float64 x, string n}` with `{"x":12, "n":"Woj"}`).
+  - Preserved CLI-specified type expressions when opening via `:input <type> [codec]`.
+
+---
+
+## 5. Welcome Banner
+
+- [x] Shortened initial welcome message to just the title line: `k interactive repl`.
+- [x] Removed secondary description and quick link lists to keep the terminal prompt clean and uncluttered.
+
+---
+
+## 6. Curated VFS & Navbar Examples Dropdown
+
+- [x] Added `poly.k` to `verifiedExamples` and `#example-select`.
+- [x] Structured Navbar Examples dropdown into self-contained basic expressions vs. library-dependent workflows.
+- [x] Removed `:val` from example dropdown list.
+- [x] Fixed `() ()` option display text.
+
+---
+
+## 7. Responsive Navbar & Obsolete Command Removal
+
+- [x] **Responsive Navbar on Narrow Screens**:
+  - Changed `.navbar` from fixed `height: 48px;` to `min-height: 48px; height: auto; flex-wrap: wrap; padding: 6px 16px; gap: 8px 12px;`.
+  - Styled `.nav-right` with `flex-wrap: wrap; justify-content: flex-end; min-width: 0;` so controls wrap smoothly without overflowing or clipping buttons (such as `? Help`).
+  - Added comprehensive responsive media query for narrow screens ($\le 768\text{px}$) with full width wrapping and adaptable control inputs.
+  - Verified via headless Chromium CDP automated tests that `#btn-help` is completely visible and interactable at narrow viewport widths (e.g. 600px).
+- [x] **Removed Obsolete Commands**:
+  - Removed `:rel <name> = expr` and `:def` (relations are defined using native syntax `name = expr;`).
+  - Removed `:type <name> = <...>` definition syntax from `:type` (types are defined using native syntax `$ name = typeExpr;`; `:type <name>` remains for inspecting type definitions).
+  - Removed `:val` completely.
+  - Removed `:timing [on|off]` (timing reporting is now permanently enabled by default for all evaluations; `:time <expr>` remains for explicit timing).
+  - Removed `:codec define n t b` (custom codecs are created using the browser Custom Codec Studio UI or loaded from modules via `:codec load`).
+

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