@fraczak/k 7.0.0 → 7.0.2

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

@@ -1,93 +0,0 @@
-#!/usr/bin/env node
-
-import fs from "node:fs";
-import { argv, exit, stdin, stdout } from "node:process";
-
-import {
-  compileProgramInput,
-  parseCompileOptions,
-  resolveProgramInput
-} from "../src/cli.mjs";
-
-function usage(stream = console.error) {
-  const prog = argv[1] || "k-arm64-compile.mjs";
-  stream(`Usage: node ${prog} [options] [source-snippet | input-file [output-file]]`);
-  stream("Compile k source, .ko, or .kvm input into a standalone Linux ARM64 executable or assembly.");
-  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("  output-file     Output file path. Writes to stdout when omitted and --assembly is set.");
-  stream("");
-  stream("Options:");
-  stream("  -S, --assembly   Emit GNU ARM64 assembly (.s) instead of an executable binary.");
-  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.");
-}
-
-try {
-  const args = argv.slice(2);
-  if (args.includes("-h") || args.includes("--help")) {
-    usage(console.log);
-    exit(0);
-  }
-
-  let emitAssembly = false;
-  let explicitOutput = null;
-  // Extract ARM64-specific flags
-  const remainingArgs = [];
-  while (args.length > 0) {
-    const arg = args[0];
-    if (arg === "-S" || arg === "--assembly") {
-      emitAssembly = true;
-      args.shift();
-    } else 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 result = await compileProgramInput(input, {
-    libraries,
-    exportSpecs,
-    stdin,
-    emit: emitAssembly ? "assembly" : null,
-    outputPath: (!emitAssembly && outputPath) ? outputPath : null
-  });
-
-  if (emitAssembly) {
-    const asmText = typeof result === "string" ? result : result.assembly;
-    if (outputPath == null) {
-      stdout.write(asmText);
-    } else {
-      fs.writeFileSync(outputPath, asmText, "utf8");
-    }
-  } else {
-    if (outputPath == null) {
-      if (Buffer.isBuffer(result)) {
-        stdout.write(result);
-      } else if (typeof result === "string") {
-        stdout.write(fs.readFileSync(result));
-      }
-    } else if (Buffer.isBuffer(result)) {
-      fs.writeFileSync(outputPath, result, { mode: 0o755 });
-    }
-  }
-} catch (error) {
-  console.error(error.stack || error.message || String(error));
-  usage();
-  exit(1);
-}

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

@@ -1,58 +0,0 @@
-#!/usr/bin/env node
-
-import fs from "node:fs";
-import { argv, exit, stdin, stdout } from "node:process";
-
-import { readAll } from "../src/cli.mjs";
-import { runARM64Artifact } from "../src/arm64.mjs";
-
-function usage(stream = console.error) {
-  const prog = argv[1] || "k-arm64-run.mjs";
-  stream(`Usage: node ${prog} [options] executable-file [input-file]`);
-  stream("Run a standalone k Linux ARM64 executable over a binary wire stream.");
-  stream("");
-  stream("Arguments:");
-  stream("  executable-file  Input compiled ELF binary produced by k-arm64-compile.");
-  stream("  input-file       Optional binary input wire file. Reads stdin when omitted.");
-  stream("");
-  stream("Options:");
-  stream("  --json           Format output as JSON instead of binary wire format.");
-  stream("  -h, --help       Show this help.");
-}
-
-async function main() {
-  const args = argv.slice(2);
-  if (args.includes("-h") || args.includes("--help")) {
-    usage(console.log);
-    return;
-  }
-
-  let json = false;
-  const filteredArgs = [];
-  for (const arg of args) {
-    if (arg === "--json") {
-      json = true;
-    } else {
-      filteredArgs.push(arg);
-    }
-  }
-
-  const execPath = filteredArgs.shift();
-  if (!execPath) throw new Error("Missing executable artifact path");
-  const inputPath = filteredArgs.shift();
-  if (filteredArgs.length > 0) throw new Error("Too many arguments");
-
-  const input = await readAll(inputPath == null ? stdin : fs.createReadStream(inputPath));
-  const result = runARM64Artifact(execPath, input, { json });
-  if (json) {
-    stdout.write(result);
-  } else {
-    stdout.write(result);
-  }
-}
-
-main().catch((error) => {
-  console.error(error.stack || error.message || String(error));
-  usage();
-  exit(1);
-});

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

@@ -1,88 +0,0 @@
-#!/usr/bin/env node
-
-import fs from "node:fs";
-import { argv, exit, stdin, stdout } from "node:process";
-import { decodeWire } from "../../../backend-api.mjs";
-
-import {
-  compileProgramInput,
-  parseCompileOptions,
-  readAll,
-  resolveProgramInput
-} from "../src/cli.mjs";
-import { runARM64Artifact } from "../src/arm64.mjs";
-
-function usage(stream = console.error) {
-  const prog = argv[1] || "k-arm64.mjs";
-  stream(`Usage: node ${prog} [options] ( source-snippet | input-file ) [ input-file ]`);
-  stream("Compile k source, .ko, or .kvm input to ARM64 in memory and run it over a binary pattern+value stream.");
-  stream("");
-  stream("Options:");
-  stream("  --json           Format output as JSON instead of binary wire format.");
-  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'.");
-  stream("  -h, --help       Show this help.");
-}
-
-async function main() {
-  const args = argv.slice(2);
-  if (args.includes("-h") || args.includes("--help")) {
-    usage(console.log);
-    return;
-  }
-
-  let json = false;
-  let entry = null;
-  const remainingArgs = [];
-  while (args.length > 0) {
-    const arg = args[0];
-    if (arg === "--json") {
-      json = true;
-      args.shift();
-    } else if (arg === "--entry") {
-      args.shift();
-      entry = args.shift();
-      if (!entry) throw new Error("--entry requires a name argument");
-    } else {
-      remainingArgs.push(args.shift());
-    }
-  }
-
-  const { libraries, exportSpecs } = parseCompileOptions(remainingArgs);
-  const programInput = resolveProgramInput(remainingArgs);
-  const inputPath = remainingArgs.shift();
-  if (remainingArgs.length > 0) throw new Error("Too many arguments");
-
-  const inputBuffer = await readAll(inputPath == null ? stdin : fs.createReadStream(inputPath));
-  let inputEnvelopePattern = null;
-  if (inputBuffer.length > 0) {
-    try {
-      const decoded = decodeWire(inputBuffer);
-      inputEnvelopePattern = decoded.pattern;
-    } catch {
-      // Not a valid wire buffer or empty
-    }
-  }
-
-  const artifact = await compileProgramInput(programInput, {
-    libraries,
-    exportSpecs,
-    inputEnvelopePattern,
-    entry
-  });
-
-  const output = runARM64Artifact(artifact, inputBuffer, { json });
-  if (json) {
-    stdout.write(output);
-  } else {
-    stdout.write(output);
-  }
-}
-
-main().catch((error) => {
-  console.error(error.stack || error.message || String(error));
-  usage();
-  exit(1);
-});

package/backends/arm64/scripts/run-tests.mjs

@@ -1,57 +0,0 @@
-#!/usr/bin/env node
-
-import path from "node:path";
-import { spawnSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
-
-const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-const node = process.execPath;
-
-function printHelp() {
-  console.log(`Usage: node backends/arm64/scripts/run-tests.mjs [options]
-
-Runs ARM64 backend test suite and integration tests.
-
-Options:
-  -h, --help
-      Show this help message and exit.`);
-}
-
-if (process.argv.includes("-h") || process.argv.includes("--help")) {
-  printHelp();
-  process.exit(0);
-}
-
-const tests = [
-  ["tests/test-arm64.mjs", node, ["tests/test-arm64.mjs"]],
-  ["tests/integration.sh", path.join(root, "tests/integration.sh"), []]
-];
-
-function formatDuration(milliseconds) {
-  if (milliseconds < 1000) return `${milliseconds.toFixed(0)} ms`;
-  return `${(milliseconds / 1000).toFixed(2)} s`;
-}
-
-const suiteStarted = performance.now();
-for (const [name, command, args] of tests) {
-  console.log(`\n==> ${name}`);
-  const started = performance.now();
-  const result = spawnSync(command, args, {
-    cwd: root,
-    stdio: "inherit"
-  });
-  const duration = formatDuration(performance.now() - started);
-
-  if (result.error) {
-    console.error(`<== ${name} FAILED (${duration})`);
-    console.error(result.error.message);
-    process.exit(1);
-  }
-  if (result.status !== 0) {
-    console.error(`<== ${name} FAILED (${duration})`);
-    process.exit(result.status ?? 1);
-  }
-  console.log(`<== ${name} passed (${duration})`);
-}
-
-console.log(`\nAll ARM64 tests passed (${formatDuration(performance.now() - suiteStarted)})`);

package/backends/arm64/src/arm64.mjs

@@ -1,229 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-import { execFileSync, spawnSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
-
-import {
-  decodeObject,
-  decodeWire,
-  objectToKVMArtifact,
-  specializeKVM
-} from "../../../backend-api.mjs";
-import { compileLibrary, compileObjectBuffer, loadLibrary } from "../../../object.mjs";
-
-import {
-  compileKVMModuleToARM64,
-  emitMetadataC,
-  getTagEntries,
-  resetTagIds
-} from "./kvm2arm64.mjs";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const RUNTIME_C_PATH = path.resolve(__dirname, "runtime.c");
-const KRT_C_PATH = path.resolve(__dirname, "../../llvm/runtime/krt.c");
-const KRT_H_DIR = path.resolve(__dirname, "../../llvm/runtime");
-
-export const ARTIFACT_FORMAT = "k-arm64";
-export const ARTIFACT_VERSION = 1;
-
-function buildExportPreamble(exports = [], libraries = []) {
-  if (exports.length === 0) return "";
-  const aliasMap = {};
-  for (const lib of libraries) {
-    for (const [name, hash] of Object.entries(lib.relAlias || {})) {
-      if (name !== "__main__") aliasMap[name] = hash;
-    }
-    for (const [hash, entry] of Object.entries(lib.meta || {})) {
-      if (entry?.type !== "rel") continue;
-      for (const origin of entry?.origins || []) {
-        if (origin?.name && origin.name !== "__main__") {
-          aliasMap[origin.name] = hash;
-        }
-      }
-    }
-  }
-  const lines = [];
-  for (const spec of exports) {
-    const [libName, localName] = spec.includes(":") ? spec.split(":", 2) : [spec, spec];
-    const hash = aliasMap[libName];
-    if (!hash) throw new Error(`--export: '${libName}' not found in loaded libraries`);
-    const body = hash.startsWith("@") ? hash.slice(1) : hash;
-    lines.push(`${localName} = @${body};`);
-  }
-  return lines.join("\n") + "\n";
-}
-
-export function compileARM64ArtifactFromKVM(kvmInput, options = {}) {
-  let kvm = kvmInput;
-  if (kvm?.format === "k-vm") {
-    if (kvm.layer === "KVM-P" && options.inputEnvelopePattern) {
-      kvm = specializeKVM(kvm, options.inputEnvelopePattern);
-    }
-  }
-
-  const functions = kvm.functions || (typeof kvm === "object" && !Array.isArray(kvm) ? kvm : null);
-  if (!functions || typeof functions !== "object") {
-    throw new Error("Expected .kvm input to contain a functions object");
-  }
-
-  const entry = options.entry || kvm.entry || "__main__";
-  const entryFunc = functions[entry];
-  if (!entryFunc) {
-    throw new Error(`kVM entry relation '${entry}' not found in program`);
-  }
-
-  const inputPattern = options.inputPattern || entryFunc.inputPattern || [];
-  const outputPattern = options.outputPattern || entryFunc.outputPattern || [];
-
-  resetTagIds();
-  const profile = Boolean(options.profile ?? (process.env.K_PROFILE === "1" || process.env.PROFILE === "1"));
-  const { assembly, entryName, profileFunctions } = compileKVMModuleToARM64(entry, functions, {
-    inputPattern,
-    outputPattern,
-    profile
-  });
-  const tags = getTagEntries();
-  const metadataC = emitMetadataC(tags, inputPattern, outputPattern, profileFunctions);
-
-  if (options.emit === "assembly" || options.assembly) {
-    return {
-      assembly,
-      metadataC,
-      entryName,
-      tags,
-      inputPattern,
-      outputPattern
-    };
-  }
-
-  // Compile to native ELF executable using gcc
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "k-arm64-"));
-  const asmPath = path.join(tmpDir, "prog.s");
-  const metaPath = path.join(tmpDir, "meta.c");
-  const outPath = options.outputPath || path.join(tmpDir, "prog");
-
-  try {
-    fs.writeFileSync(asmPath, assembly, "utf8");
-    fs.writeFileSync(metaPath, metadataC, "utf8");
-
-    const gcc = options.gcc || process.env.CC || "gcc";
-    const optLevel = options.optLevel ?? "-O2";
-    const args = [
-      optLevel,
-      `-DENTRY_NAME=${entryName}`,
-      asmPath,
-      metaPath,
-      RUNTIME_C_PATH,
-      KRT_C_PATH,
-      `-I${KRT_H_DIR}`,
-      "-o",
-      outPath
-    ];
-
-    execFileSync(gcc, args, { stdio: "pipe" });
-
-    if (options.outputPath) {
-      return outPath;
-    }
-
-    const binaryBuffer = fs.readFileSync(outPath);
-    return binaryBuffer;
-  } finally {
-    try {
-      if (fs.existsSync(asmPath)) fs.unlinkSync(asmPath);
-      if (fs.existsSync(metaPath)) fs.unlinkSync(metaPath);
-      if (!options.outputPath && fs.existsSync(outPath)) fs.unlinkSync(outPath);
-      if (!options.outputPath) fs.rmdirSync(tmpDir);
-    } catch {
-      // Ignore cleanup errors in temporary directory
-    }
-  }
-}
-
-export function compileARM64ArtifactFromObject(object, options = {}) {
-  const kvm = objectToKVMArtifact(object, options.entry, null, options);
-  return compileARM64ArtifactFromKVM(kvm, options);
-}
-
-export function compileARM64Artifact(source, options = {}) {
-  const libraries = (options.libraries || []).map((lib) => {
-    if (lib?.rels || lib?.meta || lib?.relAlias) return lib;
-    if (typeof lib === "string") {
-      const ext = path.extname(lib).toLowerCase();
-      if (ext === ".k") {
-        return loadLibrary(compileLibrary(fs.readFileSync(lib, "utf8"), { source: lib }));
-      }
-      return loadLibrary(decodeObject(fs.readFileSync(lib)));
-    }
-    if (Buffer.isBuffer(lib)) {
-      return loadLibrary(decodeObject(lib));
-    }
-    return lib;
-  });
-  const preamble = buildExportPreamble(options.exports || options.exportSpecs || [], libraries);
-  const fullSource = preamble + source;
-
-  const objBuffer = compileObjectBuffer(fullSource, {
-    libraries,
-    source: options.source || null
-  });
-  const object = decodeObject(objBuffer);
-  return compileARM64ArtifactFromObject(object, options);
-}
-
-export function runARM64Artifact(executablePathOrBuffer, inputBuffer, options = {}) {
-  let execPath = executablePathOrBuffer;
-  let tmpFile = null;
-
-  if (Buffer.isBuffer(executablePathOrBuffer)) {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "k-arm64-run-"));
-    tmpFile = path.join(tmpDir, "k-exec");
-    fs.writeFileSync(tmpFile, executablePathOrBuffer, { mode: 0o755 });
-    execPath = tmpFile;
-  }
-
-  try {
-    const args = [];
-    if (options.json) {
-      args.push("--json");
-    }
-
-    const result = spawnSync(execPath, args, {
-      input: inputBuffer,
-      maxBuffer: options.maxBuffer || 64 * 1024 * 1024
-    });
-
-    if (result.error) {
-      throw result.error;
-    }
-
-    if (result.status !== 0) {
-      const stderr = result.stderr?.toString("utf8") || "";
-      throw new Error(`ARM64 executable failed with exit status ${result.status}: ${stderr}`);
-    }
-
-    if (options.json) {
-      return result.stdout.toString("utf8");
-    }
-    return result.stdout;
-  } finally {
-    if (tmpFile) {
-      try {
-        fs.unlinkSync(tmpFile);
-        fs.rmdirSync(path.dirname(tmpFile));
-      } catch {
-        // Ignore temporary cleanup errors
-      }
-    }
-  }
-}
-
-export default {
-  ARTIFACT_FORMAT,
-  ARTIFACT_VERSION,
-  compileARM64ArtifactFromKVM,
-  compileARM64ArtifactFromObject,
-  compileARM64Artifact,
-  runARM64Artifact
-};

package/backends/arm64/src/cli.mjs

@@ -1,155 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-
-import { compileLibrary, decodeObject, loadLibrary } from "../../../backend-api.mjs";
-import {
-  compileARM64Artifact,
-  compileARM64ArtifactFromKVM,
-  compileARM64ArtifactFromObject
-} from "./arm64.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);
-    if (kind === "klib") {
-      throw new Error("Cannot compile a .klib library to ARM64 without a main relation; load it with --lib.");
-    }
-    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 async function compileProgramInput(
-  input,
-  {
-    libraries = [],
-    exportSpecs = [],
-    stdin = null,
-    inputEnvelopePattern = null,
-    entry = null,
-    emit = null,
-    outputPath = null
-  } = {}
-) {
-  const compileOptions = {
-    libraries,
-    exports: exportSpecs,
-    inputEnvelopePattern,
-    entry,
-    emit,
-    outputPath
-  };
-
-  if (input.kind === "inline-source") {
-    return compileARM64Artifact(input.source, {
-      ...compileOptions,
-      source: input.sourceName
-    });
-  }
-
-  if (input.kind === "stdin-source") {
-    if (!stdin) throw new Error("stdin source requested without a stdin stream");
-    const source = (await readAll(stdin)).toString("utf8");
-    return compileARM64Artifact(source, {
-      ...compileOptions,
-      source: input.sourceName
-    });
-  }
-
-  if (input.kind === "source-file") {
-    return compileARM64Artifact(fs.readFileSync(input.path, "utf8"), {
-      ...compileOptions,
-      source: input.sourceName
-    });
-  }
-
-  if (input.kind === "ko") {
-    return compileARM64ArtifactFromObject(
-      decodeObject(fs.readFileSync(input.path)),
-      compileOptions
-    );
-  }
-
-  if (input.kind === "kvm") {
-    return compileARM64ArtifactFromKVM(
-      JSON.parse(fs.readFileSync(input.path, "utf8")),
-      compileOptions
-    );
-  }
-
-  throw new Error(`Unsupported input kind: ${input.kind}`);
-}
-
-export default {
-  compileProgramInput,
-  fileInputType,
-  parseCompileOptions,
-  readAll,
-  resolveProgramInput
-};