@fraczak/k 6.5.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/arm64/src/runtime.c

@@ -5,7 +5,21 @@
 #include <string.h>
 #include <time.h>
 
-#define ARENA_CAPACITY (64 * 1024 * 1024)
+#define DEFAULT_ARENA_CAPACITY (256 * 1024 * 1024)
+
+static int parse_size_arg(const char *text, size_t *out);
+
+static size_t get_arena_capacity(void) {
+  const char *env = getenv("K_ARENA_CAPACITY_MB");
+  if (!env || !*env) env = getenv("K_ARENA_MB");
+  if (env && *env) {
+    size_t mb = 0;
+    if (parse_size_arg(env, &mb) && mb > 0) {
+      return mb * 1024 * 1024;
+    }
+  }
+  return DEFAULT_ARENA_CAPACITY;
+}
 
 typedef enum {
   K_VALUE_UNIT,
@@ -601,8 +615,10 @@ static int run_bench_main(void *arena_mem, const char *count_text) {
 int main(int argc, char **argv) {
   init_tag_registry();
 
+  size_t arena_capacity = get_arena_capacity();
+
   if (argc == 2 && strcmp(argv[1], "--server") == 0) {
-    void *arena_mem = malloc(ARENA_CAPACITY);
+    void *arena_mem = malloc(arena_capacity);
     if (!arena_mem) return 1;
     int rc = run_server(arena_mem);
     free(arena_mem);
@@ -610,7 +626,7 @@ int main(int argc, char **argv) {
   }
 
   if (argc == 3 && strcmp(argv[1], "--bench-main") == 0) {
-    void *arena_mem = malloc(ARENA_CAPACITY);
+    void *arena_mem = malloc(arena_capacity);
     if (!arena_mem) return 1;
     int rc = run_bench_main(arena_mem, argv[2]);
     free(arena_mem);
@@ -647,7 +663,7 @@ int main(int argc, char **argv) {
     }
   }
 
-  void *arena_mem = malloc(ARENA_CAPACITY);
+  void *arena_mem = malloc(arena_capacity);
   if (!arena_mem) {
     if (in_fp != stdin) fclose(in_fp);
     return 1;

package/backends/arm64/tests/integration.sh

@@ -105,7 +105,7 @@ node "$K_ROOT/backends/arm64/bin/k-arm64-compile.mjs" \
   '{succ int x,int y}+' \
   -o "$TMP_DIR/lib-add"
 
-node "$K_ROOT/codecs/k-parse.mjs" <<< '{"x":{"succ":"zero"},"y":{"succ":{"succ":"zero"}}}' |
+node "$K_ROOT/codecs/k-parse.mjs" <<< '{"x":{"0":"_"},"y":{"+":{"0":"_"}}}' |
   "$TMP_DIR/lib-add" --json |
   grep -Fxq '{"+":{"1":"_"}}'
 

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