@fraczak/k 6.2.4 → 6.3.2

package/kvm.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import fs from "node:fs";
 import { argv, stdin, exit, stdout } from "node:process";
-import { Product, Variant, composePattern, withPattern } from "./Value.mjs";
+import { Value, composePattern, withPattern, isProduct, isVariant } from "./Value.mjs";
 import { exportPatternGraph } from "./codecs/runtime/codec.mjs";
 import { patternToPropertyList } from "./codecs/runtime/pattern-json.mjs";
 import {
@@ -17,6 +17,42 @@ import { decodeObject, loadLibrary } from "./object.mjs";
 import codes from "./codes.mjs";
 import { isMainEntrypoint } from "./codecs/runtime/cli-entry.mjs";
 
+function isFile(filePath) {
+  try {
+    return fs.statSync(filePath).isFile();
+  } catch (error) {
+    if (error?.code === "ENOENT" || error?.code === "ENOTDIR") return false;
+    throw error;
+  }
+}
+
+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";
+}
+
 class KVMBuilder {
   constructor(typePatternGraph) {
     this.typePatternGraph = typePatternGraph;
@@ -281,7 +317,7 @@ function executeInstruction(inst, registers, context) {
     }
     case "project_field": {
       const val = registers.get(inst.src);
-      if (!(val instanceof Product)) return undefined;
+      if (!isProduct(val)) return undefined;
       const fieldVal = val.product[inst.label];
       if (fieldVal === undefined) return undefined;
 
@@ -295,7 +331,7 @@ function executeInstruction(inst, registers, context) {
     }
     case "project_variant": {
       const val = registers.get(inst.src);
-      if (!(val instanceof Variant) || val.tag !== inst.tag) return undefined;
+      if (!isVariant(val) || val.tag !== inst.tag) return undefined;
 
       if (options.envelopeFree) {
         registers.set(inst.dest, val.value);
@@ -308,11 +344,11 @@ function executeInstruction(inst, registers, context) {
     case "make_variant": {
       const val = registers.get(inst.src);
       if (options.envelopeFree) {
-        registers.set(inst.dest, new Variant(inst.tag, val));
+        registers.set(inst.dest, Value.variant(inst.tag, val));
       } else {
         registers.set(
           inst.dest,
-          new Variant(inst.tag, val, composePattern("open-union", [[inst.tag, val.pattern]]))
+          Value.variant(inst.tag, val, composePattern("open-union", [[inst.tag, val.pattern]]))
         );
       }
       return { type: "continue" };
@@ -375,13 +411,13 @@ function executeInstruction(inst, registers, context) {
       }
       let productValue;
       if (options.envelopeFree) {
-        productValue = new Product(result);
+        productValue = Value.product(result);
       } else {
         const staticOutputPattern = inst.pattern;
         if (staticOutputPattern) {
-          productValue = new Product(result, staticOutputPattern);
+          productValue = Value.product(result, staticOutputPattern);
         } else {
-          productValue = new Product(result, composePattern("closed-product", patternEntries));
+          productValue = Value.product(result, composePattern("closed-product", patternEntries));
         }
       }
       registers.set(inst.dest, productValue);
@@ -428,9 +464,10 @@ export default {
 
 function usage() {
   const prog = argv[1] || "kvm.mjs";
-  console.error(`Usage: node ${prog} [ options ] ( k-expr | -k file ) [ input-file ]`);
+  console.error(`Usage: node ${prog} [ options ] ( k-expr | input-file ) [ input-file ]`);
   console.error("Options:");
   console.error("  --lib file          Load one .klib dependency before compiling.");
+  console.error("  --export spec       Export a library alias into scope. 'name' or 'libname:localname'. May be repeated.");
   console.error("  --envelope-free     Run the interpreter in envelope-free mode.");
   console.error("  -h, --help          Show this help.");
 }
@@ -444,6 +481,7 @@ async function main() {
 
   let envelopeFree = false;
   const libraries = [];
+  const exports = [];
 
   // Parse options
   while (args.length > 0) {
@@ -457,22 +495,44 @@ async function main() {
       if (libraries.length > 0) throw new Error("--lib may be specified at most once");
       const libBuffer = fs.readFileSync(libPath);
       libraries.push(loadLibrary(decodeObject(libBuffer)));
+    } else if (args[0] === "--export") {
+      args.shift();
+      const spec = args.shift();
+      if (!spec) throw new Error("--export requires a spec argument");
+      exports.push(spec);
+    } else if (args[0].startsWith("--")) {
+      throw new Error(`Unknown option: ${args[0]}`);
     } else {
       break;
     }
   }
 
-  let kScriptStr = (function (arg) {
+  const programInput = (function (arg) {
     if (arg == null) {
       throw new Error("Missing script argument");
     }
     if (arg === "-k") {
-      const fileArg = args.shift();
-      if (!fileArg) throw new Error("-k requires a file argument");
-      return fs.readFileSync(fileArg, "utf8");
-    } else {
-      return arg;
+      throw new Error("-k is no longer supported; pass the source/object file path directly");
+    }
+    if (isFile(arg)) {
+      const buffer = fs.readFileSync(arg);
+      try {
+        const object = decodeObject(buffer);
+        if (object.main == null) {
+          throw new Error("Cannot run a .klib library without a main relation; load it with --lib.");
+        }
+        return { kind: "object", defs: { rels: object.rels }, main: object.main };
+      } catch (error) {
+        if (error.message === "Cannot run a .klib library without a main relation; load it with --lib.") {
+          throw error;
+        }
+        return {
+          kind: "source",
+          source: buildExportPreamble(exports, libraries) + buffer.toString("utf8")
+        };
+      }
     }
+    return { kind: "source", source: buildExportPreamble(exports, libraries) + arg };
   })(args.shift());
 
   const inputStream = (function (arg) {
@@ -482,13 +542,20 @@ async function main() {
     return fs.createReadStream(arg);
   })(args.shift());
 
-  const defs = annotate(kScriptStr, { libraries });
-  const mainRel = defs.rels.__main__;
+  if (args.length > 0) {
+    throw new Error(`Unexpected argument: ${args[0]}`);
+  }
+
+  const defs = programInput.kind === "object"
+    ? programInput.defs
+    : annotate(programInput.source, { libraries });
+  const mainRelName = programInput.kind === "object" ? programInput.main : "__main__";
+  const mainRel = defs.rels[mainRelName];
   if (!mainRel) {
-    throw new Error("No main relation (__main__) defined in script");
+    throw new Error(`No main relation (${mainRelName}) defined in script`);
   }
 
-  const kvmFunc = lowerToKVM(mainRel, "__main__");
+  const kvmFunc = lowerToKVM(mainRel, mainRelName);
 
   const buffer = [];
   inputStream.on("data", (data) => buffer.push(Buffer.isBuffer(data) ? data : Buffer.from(data)));

package/package.json

@@ -1,11 +1,14 @@
 {
     "name": "@fraczak/k",
-    "version": "6.2.4",
+    "version": "6.3.2",
     "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",
     "scripts": {
         "prepare": "jiwson -m es6 parser.jison -o parser.mjs; jiwson -m es6 valueParser.jison -o valueParser.mjs; ",
         "test": "node scripts/run-tests.mjs",
+        "benchmark": "node scripts/benchmark.mjs",
+        "benchmark:html": "node scripts/render-benchmark.mjs",
+        "hooks:install": "git config core.hooksPath scripts/git-hooks",
         "perf:idempotency": "node scripts/benchmark-idempotency.mjs",
         "deps:graph": "node scripts/generate-dependency-graph.mjs"
     },

package/repl.mjs

@@ -10,7 +10,7 @@ import { argv, exit, stdin, stdout } from "node:process";
 import { annotate, parse } from "./index.mjs";
 import run from "./run.mjs";
 import codes from "./codes.mjs";
-import { Product } from "./Value.mjs";
+import { Value } from "./Value.mjs";
 import { patterns2filters, prettyCode, prettyRel } from "./pretty.mjs";
 import {
   compileObject,
@@ -50,7 +50,7 @@ function cloneJSON(value) {
 }
 
 function emptyValue() {
-  return new Product({}, [["closed-product", []]]);
+  return Value.product({}, [["closed-product", []]]);
 }
 
 function createState() {

package/run.mjs

@@ -1,5 +1,5 @@
 import assert from "assert";
-import { Product, Variant, edgeSubpattern, composePattern, withPattern } from "./Value.mjs"
+import { Value, edgeSubpattern, composePattern, withPattern, isProduct, isVariant } from "./Value.mjs"
 import { exportPatternGraph, intersectPropertyListPatterns } from "./codecs/runtime/codec.mjs";
 import { patternToPropertyList } from "./codecs/runtime/pattern-json.mjs";
 
@@ -261,14 +261,14 @@ function compiledExp(findCode, exp, typePatternGraph) {
             ` - product envelope: ${patternPreview(dynamicOutputPattern)}`
           );
         }
-        return new Product(result, pattern);
+        return Value.product(result, pattern);
       };
       break;
     }
     case "vid":
       fn = (value) => {
         if (value === undefined) return undefined;
-        return new Variant(exp.vid, value, composePattern("open-union", [[exp.vid, value.pattern]]));
+        return Value.variant(exp.vid, value, composePattern("open-union", [[exp.vid, value.pattern]]));
       };
       break;
     default:
@@ -375,13 +375,13 @@ function compiledConvergedExp(findCode, exp, typePatternGraph, options = {}) {
       break;
     case "dot":
       fn = (value) => {
-        if (value === undefined || !(value instanceof Product)) return undefined;
+        if (value === undefined || !isProduct(value)) return undefined;
         return Object.hasOwn(value.product, exp.dot) ? value.product[exp.dot] : undefined;
       };
       break;
     case "div":
       fn = (value) => {
-        if (value === undefined || !(value instanceof Variant) || value.tag !== exp.div) return undefined;
+        if (value === undefined || !isVariant(value) || value.tag !== exp.div) return undefined;
         return value.value;
       };
       break;
@@ -419,12 +419,12 @@ function compiledConvergedExp(findCode, exp, typePatternGraph, options = {}) {
           if (r === undefined) return undefined;
           result[labels[i]] = r;
         }
-        return new Product(result);
+        return Value.product(result);
       };
       break;
     }
     case "vid":
-      fn = (value) => value === undefined ? undefined : new Variant(exp.vid, value);
+      fn = (value) => value === undefined ? undefined : Value.variant(exp.vid, value);
       break;
     default:
       assert(false,`Unknown operation: '${exp.op}'`);
@@ -440,7 +440,7 @@ function verify(findCode, code, value) {
   code = findCode(code);
   switch (code.code) {
     case "product":
-      if (! (value instanceof Product)) return false;
+      if (!isProduct(value)) return false;
       else {
         const fields = Object.keys(value.product);
         if (fields.length !== Object.keys(code.product).length) return false;
@@ -449,7 +449,7 @@ function verify(findCode, code, value) {
         );
       }
     case "union":
-      if (! (value instanceof Product)) return false;
+      if (!isProduct(value)) return false;
       else {
         const fields = Object.keys(value.product);
         if (fields.length !== 1) return false;

package/scripts/benchmark.mjs

@@ -0,0 +1,393 @@
+#!/usr/bin/env node
+
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { performance } from "node:perf_hooks";
+
+import {
+  codes,
+  createState,
+  evaluateInput,
+  executeKVM,
+  lowerToKVM,
+  parseFloat64,
+  run,
+  run_converged,
+  valueForCode,
+  Value
+} from "../backend-api.mjs";
+import { parse as parseIntValue } from "../codecs/int.mjs";
+
+const scriptPath = fileURLToPath(import.meta.url);
+const root = path.resolve(path.dirname(scriptPath), "..");
+const resultsPath = path.join(root, "benchmark-results.json");
+
+const bigA = "1234567890".repeat(22);
+const bigB = "9876543210".repeat(22);
+const gcdFactor = 1234567890123456789012345678901234567890n;
+const gcdA = (gcdFactor * 123456789012345678901234567890123456789012345678901n).toString();
+const gcdB = (gcdFactor * 987654321098765432109876543210987654321098765432109n).toString();
+
+const cases = [
+  { name: "ieee.add", suite: "ieee", rel: "add", input: { x: "0.5", y: "0.25" } },
+  { name: "ieee.sub", suite: "ieee", rel: "sub", input: { x: "2", y: "4" } },
+  { name: "ieee.mul", suite: "ieee", rel: "mul", input: { x: "-2", y: "4" } },
+  { name: "ieee.div", suite: "ieee", rel: "div", input: { x: "1", y: "2" } },
+  { name: "int.times.220d", suite: "arithmetics", rel: "times", input: { shape: "int-pair", x: bigA, y: bigB } },
+  { name: "int.gcd.90d", suite: "arithmetics", rel: "gcd", input: { shape: "bits-pair", x: gcdA, y: gcdB } },
+  { name: "int.factorial.101", suite: "arithmetics", rel: "factorial", input: { shape: "int", x: "101" } },
+  { name: "int.factorial.242", suite: "arithmetics", rel: "factorial", input: { shape: "int", x: "242" } },
+  { name: "int.factorial.1174", suite: "arithmetics", rel: "factorial", input: { shape: "int", x: "1174" } }
+];
+
+const modes = [
+  { name: "Native JS (Envelope-Aware)", kind: "native-aware" },
+  { name: "Native JS (Envelope-Free)", kind: "native-free" },
+  { name: "kVM Interpreter (Env-Free)", kind: "kvm-free" }
+];
+
+function csvEnv(name, fallback) {
+  return (process.env[name] || fallback)
+    .split(",")
+    .map(item => item.trim())
+    .filter(Boolean);
+}
+
+function selectedCases() {
+  const selected = csvEnv("BENCHMARK_CASES", cases.map(testCase => testCase.name).join(","));
+  const byName = new Map(cases.map(testCase => [testCase.name, testCase]));
+  return selected.map((name) => {
+    const testCase = byName.get(name);
+    if (!testCase) throw new Error(`Unknown benchmark case '${name}'`);
+    return testCase;
+  });
+}
+
+function selectedModes() {
+  const selected = csvEnv("BENCHMARK_MODES", modes.map(mode => mode.name).join(","));
+  const byName = new Map(modes.map(mode => [mode.name, mode]));
+  return selected.map((name) => {
+    const mode = byName.get(name);
+    if (!mode) throw new Error(`Unknown benchmark mode '${name}'`);
+    return mode;
+  });
+}
+
+function mean(values) {
+  return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+
+function maxRssMiB(maxRSS) {
+  return process.platform === "darwin" ? maxRSS / 1024 / 1024 : maxRSS / 1024;
+}
+
+function digestValue(value) {
+  const json = JSON.stringify(value);
+  return {
+    digest: crypto.createHash("sha256").update(json).digest("hex").slice(0, 16),
+    bytes: Buffer.byteLength(json)
+  };
+}
+
+function formatMs(value) {
+  return value == null ? "-" : value.toFixed(2);
+}
+
+function formatMiB(value) {
+  return value == null ? "-" : value.toFixed(1);
+}
+
+function pad(value, width) {
+  const text = String(value);
+  return text.length >= width ? text : text + " ".repeat(width - text.length);
+}
+
+async function prepareState(suite) {
+  const state = createState();
+  const source = suite === "ieee" ? "Examples/ieee.k" : "Examples/arithmetics.k";
+  await evaluateInput(`:load ${path.join(root, source)}`, state);
+  return state;
+}
+
+function ieeeInput(testCase, state) {
+  const float64Hash = state.typeAliases.float64;
+  const floatPairHash = state.typeAliases.float_pair;
+  const float64 = text => valueForCode(parseFloat64(text), float64Hash, codes.find);
+  return valueForCode(Value.product({
+    x: float64(testCase.input.x),
+    y: float64(testCase.input.y)
+  }), floatPairHash, codes.find);
+}
+
+function arithmeticInput(testCase) {
+  const { shape } = testCase.input;
+  if (shape === "int") {
+    return parseIntValue(testCase.input.x);
+  }
+  if (shape === "int-pair") {
+    return Value.product({
+      x: parseIntValue(testCase.input.x),
+      y: parseIntValue(testCase.input.y)
+    });
+  }
+  if (shape === "bits-pair") {
+    return Value.product({
+      x: parseIntValue(testCase.input.x).value,
+      y: parseIntValue(testCase.input.y).value
+    });
+  }
+  throw new Error(`Unknown arithmetic input shape '${shape}'`);
+}
+
+function prepareRelation(testCase, state) {
+  const hash = state.relAliases[testCase.rel];
+  if (!hash) throw new Error(`Relation '${testCase.rel}' not found`);
+  const relDef = state.rels[hash];
+  if (!relDef) throw new Error(`Relation hash '${hash}' not found`);
+  return {
+    relDef,
+    kvmFunc: lowerToKVM(relDef, testCase.rel)
+  };
+}
+
+function runOnce(job, prepared) {
+  const { relDef, kvmFunc, inputVal, state } = prepared;
+  run.defs = state;
+  run_converged.defs = state;
+
+  if (job.mode.kind === "native-aware") {
+    return run(codes.find, relDef.def, inputVal, relDef.typePatternGraph);
+  }
+
+  if (job.mode.kind === "native-free") {
+    return run_converged(codes.find, relDef.def, inputVal, relDef.typePatternGraph);
+  }
+
+  if (job.mode.kind === "kvm-free") {
+    return executeKVM(kvmFunc, inputVal, {
+      rels: state.rels,
+      findCode: codes.find,
+      options: { envelopeFree: true }
+    });
+  }
+
+  throw new Error(`Unknown benchmark mode '${job.mode.name}'`);
+}
+
+async function workerMain() {
+  const job = JSON.parse(process.env.K_BENCHMARK_JOB);
+  const setupStartedAt = performance.now();
+  const state = await prepareState(job.case.suite);
+  const relation = prepareRelation(job.case, state);
+  const inputVal = job.case.suite === "ieee" ? ieeeInput(job.case, state) : arithmeticInput(job.case);
+  const prepared = { ...relation, inputVal, state };
+  const setupMs = performance.now() - setupStartedAt;
+
+  const samples = [];
+  let lastResult;
+  const runStartedHeap = process.memoryUsage().heapUsed;
+  for (let i = 0; i < job.samples; i++) {
+    const startedAt = performance.now();
+    lastResult = runOnce(job, prepared);
+    samples.push(performance.now() - startedAt);
+    if (lastResult === undefined) {
+      throw new Error("benchmark operation returned undefined");
+    }
+  }
+
+  const resultInfo = digestValue(lastResult);
+  const memory = process.memoryUsage();
+  const usage = process.resourceUsage();
+  process.stdout.write(JSON.stringify({
+    status: "ok",
+    mode: job.mode.name,
+    case: job.case.name,
+    samples,
+    avgMs: mean(samples),
+    minMs: Math.min(...samples),
+    maxMs: Math.max(...samples),
+    setupMs,
+    maxRssMiB: maxRssMiB(usage.maxRSS),
+    heapUsedMiB: memory.heapUsed / 1024 / 1024,
+    heapDeltaMiB: (memory.heapUsed - runStartedHeap) / 1024 / 1024,
+    resultDigest: resultInfo.digest,
+    resultBytes: resultInfo.bytes
+  }) + "\n");
+}
+
+function spawnJob(job, timeoutMs) {
+  return new Promise((resolve) => {
+    const child = spawn(process.execPath, [scriptPath, "--worker"], {
+      cwd: root,
+      env: {
+        ...process.env,
+        K_BENCHMARK_WORKER: "1",
+        K_BENCHMARK_JOB: JSON.stringify(job)
+      },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      setTimeout(() => {
+        if (!child.killed) child.kill("SIGKILL");
+      }, 1000).unref();
+    }, timeoutMs);
+
+    child.stdout.on("data", chunk => { stdout += chunk.toString("utf8"); });
+    child.stderr.on("data", chunk => { stderr += chunk.toString("utf8"); });
+    child.on("close", (code, signal) => {
+      clearTimeout(timer);
+      if (timedOut) {
+        resolve({ status: "timeout", mode: job.mode.name, case: job.case.name, timeoutMs });
+        return;
+      }
+      if (code !== 0) {
+        resolve({
+          status: "failed",
+          mode: job.mode.name,
+          case: job.case.name,
+          code,
+          signal,
+          stderr: stderr.trim() || stdout.trim()
+        });
+        return;
+      }
+      try {
+        resolve(JSON.parse(stdout.trim().split("\n").at(-1)));
+      } catch (error) {
+        resolve({
+          status: "failed",
+          mode: job.mode.name,
+          case: job.case.name,
+          stderr: `Could not parse worker output: ${error.message}\n${stdout}\n${stderr}`
+        });
+      }
+    });
+  });
+}
+
+async function runPool(jobs, concurrency, timeoutMs) {
+  const results = [];
+  let next = 0;
+
+  async function worker() {
+    while (next < jobs.length) {
+      const job = jobs[next++];
+      const result = await spawnJob(job, timeoutMs);
+      results.push(result);
+      const label = `${result.mode}/${result.case}`;
+      if (result.status === "ok") {
+        console.log(`[ok]      ${label} ${formatMs(result.avgMs)} ms avg, ${formatMiB(result.maxRssMiB)} MiB max RSS`);
+      } else {
+        console.log(`[${result.status}] ${label}`);
+      }
+    }
+  }
+
+  await Promise.all(Array.from({ length: concurrency }, worker));
+  return results;
+}
+
+function resultDocument(results, metadata) {
+  const sorted = [...results].sort((a, b) => a.case.localeCompare(b.case) || a.mode.localeCompare(b.mode));
+  return {
+    generatedAt: new Date().toISOString(),
+    node: process.version,
+    platform: `${process.platform} ${process.arch}`,
+    cpuCount: os.availableParallelism(),
+    samples: metadata.samples,
+    timeoutMs: metadata.timeoutMs,
+    parallelJobs: metadata.concurrency,
+    results: sorted
+  };
+}
+
+function writeResultsFile(document) {
+  fs.writeFileSync(resultsPath, JSON.stringify(document, null, 2) + "\n");
+}
+
+function printSummary(document) {
+  console.log("\n==================== K BENCHMARK SUMMARY ====================");
+  console.log(`samples/job: ${document.samples}`);
+  console.log(`timeout/job: ${(document.timeoutMs / 1000 / 60).toFixed(1)} min`);
+  console.log(`parallel jobs: ${document.parallelJobs}`);
+  console.log(`results file: ${path.relative(root, resultsPath)}`);
+  console.log("-------------------------------------------------------------");
+  console.log(`${pad("case", 20)} ${pad("mode", 24)} ${pad("status", 8)} ${pad("avg ms", 10)} ${pad("min", 9)} ${pad("max", 9)} ${pad("rss MiB", 9)} ${pad("heap MiB", 9)} digest`);
+  for (const result of document.results) {
+    console.log([
+      pad(result.case, 20),
+      pad(result.mode, 24),
+      pad(result.status, 8),
+      pad(formatMs(result.avgMs), 10),
+      pad(formatMs(result.minMs), 9),
+      pad(formatMs(result.maxMs), 9),
+      pad(formatMiB(result.maxRssMiB), 9),
+      pad(formatMiB(result.heapUsedMiB), 9),
+      result.resultDigest || ""
+    ].join(" "));
+  }
+
+  const failures = document.results.filter(result => result.status !== "ok");
+  if (failures.length > 0) {
+    console.log("-------------------------------------------------------------");
+    console.log("Failures:");
+    for (const failure of failures) {
+      console.log(`- ${failure.mode}/${failure.case}: ${failure.status}`);
+      if (failure.stderr) console.log(failure.stderr.split("\n").slice(0, 12).map(line => `  ${line}`).join("\n"));
+    }
+  }
+  console.log("=============================================================\n");
+}
+
+async function main() {
+  if (process.env.K_BENCHMARK_WORKER === "1" || process.argv.includes("--worker")) {
+    await workerMain();
+    return;
+  }
+
+  const selected = selectedCases();
+  const selectedBenchmarkModes = selectedModes();
+  const samples = process.env.BENCHMARK_SAMPLES ? Number(process.env.BENCHMARK_SAMPLES) : 3;
+  const timeoutMs = process.env.BENCHMARK_TIMEOUT_MS ? Number(process.env.BENCHMARK_TIMEOUT_MS) : 2 * 60 * 1000;
+  const requestedJobs = process.env.BENCHMARK_JOBS ? Number(process.env.BENCHMARK_JOBS) : os.availableParallelism();
+  const concurrency = Math.max(1, Math.min(requestedJobs, os.availableParallelism(), selected.length * selectedBenchmarkModes.length));
+
+  if (!Number.isInteger(samples) || samples <= 0) throw new Error("BENCHMARK_SAMPLES must be a positive integer");
+  if (!Number.isInteger(timeoutMs) || timeoutMs <= 0) throw new Error("BENCHMARK_TIMEOUT_MS must be a positive integer");
+
+  const jobs = [];
+  for (const testCase of selected) {
+    for (const mode of selectedBenchmarkModes) {
+      jobs.push({ case: testCase, mode, samples });
+    }
+  }
+
+  console.log("==> k benchmark");
+  console.log(`cases: ${selected.map(testCase => testCase.name).join(", ")}`);
+  console.log(`modes: ${selectedBenchmarkModes.map(mode => mode.name).join(", ")}`);
+  console.log(`jobs: ${jobs.length}; parallelism: ${concurrency}; timeout/job: ${timeoutMs} ms`);
+
+  const results = await runPool(jobs, concurrency, timeoutMs);
+  const document = resultDocument(results, { samples, timeoutMs, concurrency });
+  writeResultsFile(document);
+  printSummary(document);
+
+  if (process.env.BENCHMARK_STRICT === "1" && results.some(result => result.status !== "ok")) {
+    process.exitCode = 1;
+  }
+}
+
+main().catch((error) => {
+  console.error(error.stack || error.message || String(error));
+  process.exit(1);
+});