@cimplify/cli 0.15.3 → 0.17.0

package/dist/kernel-IC4ZC54Z.mjs

@@ -0,0 +1,662 @@
+#!/usr/bin/env node
+import { kernelProgram, findSites, tunableConsts, tunableLiteral, compileSite, KernelError, metaOf } from './chunk-454RQ6NR.mjs';
+import { ENGINE_RUNTIME_ROUTE, ENGINE_RUNTIME_FILES_ROUTE } from './chunk-QVR6V6QP.mjs';
+import { locateToolchain, engineCacheRoot, validManifest, canonicalBytes } from './chunk-N2WZJX5P.mjs';
+import './chunk-EYEMPIMP.mjs';
+import './chunk-BGM7CH5G.mjs';
+import { isDigest, sha256 } from './chunk-25ZPFHLF.mjs';
+import './chunk-SGT5IJVW.mjs';
+import { parseArgs, flagString, flagBool } from './chunk-XQAHREKO.mjs';
+import { ApiClient } from './chunk-XBQ4LO2N.mjs';
+import { readAuthOrNull } from './chunk-GGPN4QYQ.mjs';
+import { CliError, CLI_ERROR_CODE, info, dim, bold, warn, success, result, isCliError } from './chunk-I7GEHLDD.mjs';
+import { promises, existsSync, readFileSync } from 'fs';
+import path5 from 'path';
+import { spawnSync } from 'child_process';
+import { trainMlp, trainMoe, importMoe, importMlp, kernelIsa, readOnnx, plainNet } from '@cimplify/sdk/game';
+import ts from 'typescript';
+import { randomBytes, createPublicKey, verify } from 'crypto';
+
+var TUNER_ENV = "CIMPLIFY_KERNEL_TUNER";
+var OBJECTIVE_NAME = "objective";
+var TUNER_CRATE = path5.join("crates", "engine_kernel_grad", "Cargo.toml");
+var MAX_F32_DIGITS = 9;
+var DIFF_CONTEXT = 2;
+var TUNER_BUFFER = 1 << 28;
+function fileOf(source) {
+  const bytes = Buffer.from(source.text, "utf8");
+  return { path: source.path, bytes, digest: "", size: bytes.length };
+}
+function pickSite(sites, name, what) {
+  const kernels = sites.filter((s) => s.kind === "kernel");
+  if (name !== null) {
+    const hit = kernels.find((s) => s.name === name);
+    if (hit === void 0) throw new Error(`no kernel named ${name} in the ${what} file; kernels there: ${kernels.map((s) => s.name).join(", ") || "none"}`);
+    return hit;
+  }
+  if (kernels.length === 1) return kernels[0];
+  throw new Error(`the ${what} file declares ${kernels.length} kernels; name one (${kernels.map((s) => s.name).join(", ") || "none"})`);
+}
+function literalValue(node) {
+  const lit = tunableLiteral(node);
+  if (lit === null) throw new Error("not a number literal");
+  if (ts.isNumericLiteral(lit)) return Number(lit.text);
+  const inner = lit.operand;
+  let e = inner;
+  while (ts.isParenthesizedExpression(e)) e = e.expression;
+  const value = Number(e.text);
+  return lit.operator === ts.SyntaxKind.MinusToken ? -value : value;
+}
+function compileOne(site, checker, tunable) {
+  try {
+    return compileSite(site, checker, tunable);
+  } catch (error) {
+    if (error instanceof KernelError) {
+      const sf = error.node.getSourceFile();
+      const lc = sf.getLineAndCharacterOfPosition(error.node.getStart(sf));
+      throw new Error(`${site.path}:${lc.line + 1}:${lc.character + 1}: ${error.message}; ${error.fix}`);
+    }
+    throw error;
+  }
+}
+function compileForTuning(kernel, kernelName, objective, objectiveName, params, toolchain) {
+  if (params.length === 0) throw new Error("name at least one constant to tune");
+  const { program, checker, toSource } = kernelProgram([fileOf(kernel), fileOf(objective)], "canvas", toolchain);
+  let kernelSf = null;
+  let objectiveSf = null;
+  for (const sf of program.getSourceFiles()) {
+    const p = toSource.get(sf.fileName);
+    if (p === kernel.path) kernelSf = sf;
+    if (p === objective.path) objectiveSf = sf;
+  }
+  if (kernelSf === null || objectiveSf === null) throw new Error("the kernel or objective file is not part of the program");
+  const site = pickSite(findSites(kernelSf, kernel.path), kernelName, "kernel");
+  const objectiveSites = findSites(objectiveSf, objective.path);
+  const objectiveSite = pickSite(objectiveSites, objectiveName ?? (objectiveSites.some((s) => s.name === OBJECTIVE_NAME) ? OBJECTIVE_NAME : null), "objective");
+  const consts = tunableConsts(kernelSf);
+  const values = params.map((name) => {
+    const decl = consts.get(name);
+    if (decl?.initializer === void 0 || tunableLiteral(decl.initializer) === null) throw new Error(`${name} is not a top-level const with a number literal in ${kernel.path}`);
+    return { name, value: Math.fround(literalValue(decl.initializer)) };
+  });
+  return {
+    tunable: compileOne(site, checker, new Set(params)),
+    shipped: compileOne(site, checker),
+    objective: compileOne(objectiveSite, checker),
+    params: values
+  };
+}
+function specOf(kernel) {
+  const meta = metaOf(kernel, 0);
+  return {
+    program: Buffer.from(kernel.bytes).toString("base64"),
+    slots: meta.slots.map((s) => ({ field: s.field, component: s.component, kind: s.kind })),
+    args: meta.args.map((a) => ({ name: a.name, kind: a.kind, width: a.width }))
+  };
+}
+function tuneJob(compiled, inputs, options, bounds2 = /* @__PURE__ */ new Map()) {
+  return {
+    kernel: specOf(compiled.tunable),
+    objective: specOf(compiled.objective),
+    params: compiled.params.map((p) => ({ ...p, ...bounds2.get(p.name) ?? {} })),
+    inputs,
+    options
+  };
+}
+function shortestF32(x) {
+  const f = Math.fround(x);
+  if (!Number.isFinite(f)) throw new Error(`${x} is not a finite f32`);
+  for (let p = 1; p <= MAX_F32_DIGITS; p++) {
+    const candidate = Number(f.toPrecision(p));
+    if (Math.fround(candidate) === f) return String(candidate);
+  }
+  return String(f);
+}
+function writeBack(source, values) {
+  const sf = ts.createSourceFile(source.path, source.text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  const consts = tunableConsts(sf);
+  const replacements = [];
+  for (const [name, value] of values) {
+    const decl = consts.get(name);
+    const lit = decl?.initializer === void 0 ? null : tunableLiteral(decl.initializer);
+    if (lit === null) throw new Error(`${name} is not a top-level const with a number literal in ${source.path}`);
+    const start = lit.getStart(sf);
+    const before = source.text.slice(start, lit.end);
+    const after = shortestF32(value);
+    const line = sf.getLineAndCharacterOfPosition(start).line + 1;
+    replacements.push({ start, end: lit.end, text: after, edit: { name, line, before, after } });
+  }
+  replacements.sort((a, b) => b.start - a.start);
+  let text = source.text;
+  for (const r of replacements) text = text.slice(0, r.start) + r.text + text.slice(r.end);
+  return { text, edits: replacements.map((r) => r.edit).sort((a, b) => a.line - b.line) };
+}
+function unifiedDiff(file, before, after) {
+  const a = before.split("\n");
+  const b = after.split("\n");
+  if (a.length !== b.length) throw new Error("constant edits never add or remove lines");
+  const changed = [];
+  for (let k = 0; k < a.length; k++) if (a[k] !== b[k]) changed.push(k);
+  if (changed.length === 0) return "";
+  const hunks = [];
+  for (const k of changed) {
+    const lo = Math.max(0, k - DIFF_CONTEXT);
+    const hi = Math.min(a.length - 1, k + DIFF_CONTEXT);
+    const last = hunks[hunks.length - 1];
+    if (last !== void 0 && lo <= last[1] + 1) last[1] = hi;
+    else hunks.push([lo, hi]);
+  }
+  const out = [`--- a/${file}`, `+++ b/${file}`];
+  for (const [lo, hi] of hunks) {
+    const n = hi - lo + 1;
+    out.push(`@@ -${lo + 1},${n} +${lo + 1},${n} @@`);
+    for (let k = lo; k <= hi; k++) {
+      if (a[k] === b[k]) out.push(` ${a[k]}`);
+      else out.push(`-${a[k]}`, `+${b[k]}`);
+    }
+  }
+  return `${out.join("\n")}
+`;
+}
+function words(bytes) {
+  return new Uint32Array(bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength));
+}
+function sameButConstants(before, after) {
+  const x = words(before);
+  const y = words(after);
+  if (x.length !== y.length) return false;
+  for (let k = 0; k < kernelIsa.PROGRAM_HEADER_WORDS; k++) if (x[k] !== y[k]) return false;
+  const start = kernelIsa.PROGRAM_HEADER_WORDS + x[kernelIsa.H_SLOTS] + x[kernelIsa.H_ARGS];
+  const end = start + x[kernelIsa.H_CONSTANTS];
+  for (let k = 0; k < x.length; k++) if ((k < start || k >= end) && x[k] !== y[k]) return false;
+  return true;
+}
+function upward(from, relative2) {
+  let dir = path5.resolve(from);
+  for (; ; ) {
+    if (existsSync(path5.join(dir, relative2))) return dir;
+    const parent = path5.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function tunerCommand(explicit, cwd) {
+  const chosen = explicit ?? process.env[TUNER_ENV] ?? null;
+  if (chosen !== null && chosen !== "") return [chosen];
+  const root = upward(cwd, TUNER_CRATE);
+  if (root === null) return null;
+  return ["cargo", "run", "--release", "--quiet", "--manifest-path", path5.join(root, "Cargo.toml"), "-p", "engine_kernel_grad", "--bin", "kernel-tune", "--"];
+}
+function runTuner(command, job) {
+  const [program, ...rest] = command;
+  const child = spawnSync(program, [...rest, "-"], { input: JSON.stringify(job), encoding: "utf8", maxBuffer: TUNER_BUFFER });
+  if (child.error !== void 0) throw new Error(`the tuner did not start: ${child.error.message}`);
+  if (child.status !== 0) throw new Error(`the tuner failed: ${child.stderr.trim() || `exit ${child.status}`}`);
+  return JSON.parse(child.stdout);
+}
+var KERNEL_TUNE = "kernel-tune";
+var TOOLS_DIR = "tools";
+var TOOL_INDEX_PATH = `${TOOLS_DIR}/tools.json`;
+var TOOL_SIGNATURE_CONTEXT = "cimplify.tools.v1\n";
+var TOOL_PLATFORMS = ["darwin-arm64", "darwin-x64", "linux-x64", "linux-arm64", "windows-x64"];
+var TRUSTED_TOOL_KEYS = {
+  "86fa65e460043f11": "xsFQOcIapIbz1I02WRMczcaWAtPhcGAGDVtf6NlKIL4="
+};
+var WINDOWS_PLATFORM = "windows-x64";
+var EXE = ".exe";
+var ED25519_SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
+var RAW_PUBLIC_KEY_BYTES = 32;
+var PLATFORM_OF = {
+  "darwin-arm64": "darwin-arm64",
+  "darwin-x64": "darwin-x64",
+  "linux-x64": "linux-x64",
+  "linux-arm64": "linux-arm64",
+  "win32-x64": "windows-x64"
+};
+function toolPlatform(platform = process.platform, arch = process.arch) {
+  return PLATFORM_OF[`${platform}-${arch}`] ?? null;
+}
+function toolPath(platform) {
+  return `${TOOLS_DIR}/${platform}/${KERNEL_TUNE}${platform === WINDOWS_PLATFORM ? EXE : ""}`;
+}
+function toolMessage(index) {
+  const entries = [...index.entries].sort((a, b) => a.platform < b.platform ? -1 : a.platform > b.platform ? 1 : 0);
+  const lines = [`tool=${index.tool}`, `version=${index.version}`, ...entries.map((e) => `${e.platform} ${e.path} ${e.sha256} ${e.bytes}`)];
+  return Buffer.concat([Buffer.from(TOOL_SIGNATURE_CONTEXT, "ascii"), Buffer.from(`${lines.join("\n")}
+`, "utf8")]);
+}
+function verifyRawEd25519(rawPublicKey, message, signature) {
+  if (rawPublicKey.length !== RAW_PUBLIC_KEY_BYTES) return false;
+  try {
+    const key = createPublicKey({ key: Buffer.concat([ED25519_SPKI_PREFIX, rawPublicKey]), format: "der", type: "spki" });
+    return verify(null, message, key, signature);
+  } catch {
+    return false;
+  }
+}
+function verifyToolIndex(index, keys = TRUSTED_TOOL_KEYS) {
+  const raw = keys[index.keyId];
+  if (raw === void 0) return false;
+  return verifyRawEd25519(Buffer.from(raw, "base64"), toolMessage(index), Buffer.from(index.signature, "base64"));
+}
+function validToolIndex(value) {
+  const v = value;
+  return typeof v === "object" && v !== null && typeof v.tool === "string" && typeof v.version === "string" && typeof v.keyId === "string" && typeof v.signature === "string" && Array.isArray(v.entries) && v.entries.every((e) => TOOL_PLATFORMS.includes(e.platform) && e.path === toolPath(e.platform) && isDigest(e.sha256) && Number.isInteger(e.bytes) && e.bytes > 0);
+}
+
+// src/interactives/kernels/tuner.ts
+var EXECUTABLE_MODE = 493;
+var MAX_INDEX_BYTES = 64 * 1024;
+var DOWNLOAD_TIMEOUT_MS = 5 * 60 * 1e3;
+var TEMP_SUFFIX_BYTES = 6;
+var POINTER_SUFFIX = ".json";
+function binaryPath(root, platform, digest) {
+  return path5.join(root, TOOLS_DIR, digest, path5.basename(toolPath(platform)));
+}
+function pointerPath(root, platform) {
+  return path5.join(root, TOOLS_DIR, `${KERNEL_TUNE}-${platform}${POINTER_SUFFIX}`);
+}
+function intact(file, digest) {
+  return existsSync(file) && sha256(new Uint8Array(readFileSync(file))) === digest;
+}
+async function writeAtomically(file, bytes, mode) {
+  await promises.mkdir(path5.dirname(file), { recursive: true });
+  const staged = path5.join(path5.dirname(file), `.tmp-${process.pid}-${randomBytes(TEMP_SUFFIX_BYTES).toString("hex")}`);
+  await promises.writeFile(staged, bytes, mode === void 0 ? void 0 : { mode });
+  await promises.rename(staged, file);
+}
+function cachedTuner(root, platform) {
+  const pointer = pointerPath(root, platform);
+  if (!existsSync(pointer)) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(pointer, "utf8"));
+  } catch {
+    return null;
+  }
+  if (typeof parsed.sha256 !== "string" || !isDigest(parsed.sha256)) return null;
+  const file = binaryPath(root, platform, parsed.sha256);
+  return intact(file, parsed.sha256) ? { command: [file], source: "cached", version: parsed.version } : null;
+}
+function entryAt(manifest, wanted) {
+  return manifest.files.find((f) => f.path === wanted) ?? null;
+}
+async function fetchTuner(client, root, platform, keys) {
+  let manifest;
+  try {
+    manifest = await client.get(ENGINE_RUNTIME_ROUTE);
+  } catch (error) {
+    if (isCliError(error) && error.code === CLI_ERROR_CODE.NOT_FOUND) return null;
+    throw error;
+  }
+  if (!validManifest(manifest)) throw new Error("the registry returned an engine runtime manifest this CLI cannot use");
+  const indexFile = entryAt(manifest, TOOL_INDEX_PATH);
+  const binary = entryAt(manifest, toolPath(platform));
+  if (indexFile === null || binary === null) return null;
+  if (indexFile.bytes > MAX_INDEX_BYTES) throw new Error("the published tool index is too large");
+  const indexBytes = canonicalBytes(indexFile, await client.getBytes(`${ENGINE_RUNTIME_FILES_ROUTE}/${indexFile.sha256}`, { timeoutMs: DOWNLOAD_TIMEOUT_MS }));
+  const index = JSON.parse(Buffer.from(indexBytes).toString("utf8"));
+  if (!validToolIndex(index)) throw new Error("the published tool index is malformed");
+  if (!verifyToolIndex(index, keys)) throw new Error(`the published ${KERNEL_TUNE} index is not signed by a key this CLI trusts`);
+  const signed = index.entries.find((e) => e.platform === platform);
+  if (index.tool !== KERNEL_TUNE || signed === void 0 || signed.sha256 !== binary.sha256 || signed.bytes !== binary.bytes) {
+    throw new Error(`the published ${KERNEL_TUNE} for ${platform} does not match its signed index`);
+  }
+  const file = binaryPath(root, platform, binary.sha256);
+  let fetched = false;
+  if (!intact(file, binary.sha256)) {
+    const bytes = canonicalBytes(binary, await client.getBytes(`${ENGINE_RUNTIME_FILES_ROUTE}/${binary.sha256}`, { timeoutMs: DOWNLOAD_TIMEOUT_MS }));
+    await writeAtomically(file, bytes, EXECUTABLE_MODE);
+    fetched = true;
+  }
+  await writeAtomically(pointerPath(root, platform), `${JSON.stringify({ sha256: binary.sha256, version: index.version })}
+`);
+  return { command: [file], source: fetched ? "fetched" : "cached", version: index.version };
+}
+async function signedInClient() {
+  const auth = await readAuthOrNull();
+  return auth === null ? null : ApiClient.fromAuth(auth);
+}
+async function resolveTuner(options) {
+  if (options.explicit !== null && options.explicit !== "") return { command: [options.explicit], source: "flag", version: null };
+  const fromEnv = process.env[TUNER_ENV];
+  if (fromEnv !== void 0 && fromEnv !== "") return { command: [fromEnv], source: "env", version: null };
+  const monorepo = tunerCommand(null, options.cwd);
+  if (monorepo !== null) return { command: monorepo, source: "monorepo", version: null };
+  const platform = options.platform === void 0 ? toolPlatform() : options.platform;
+  if (platform === null) return null;
+  const root = options.root ?? engineCacheRoot();
+  const client = options.client === void 0 ? await signedInClient() : options.client;
+  if (client !== null) {
+    try {
+      const fetched = await fetchTuner(client, root, platform, options.keys ?? TRUSTED_TOOL_KEYS);
+      if (fetched !== null) return fetched;
+    } catch (error) {
+      const cached = cachedTuner(root, platform);
+      if (cached !== null) return cached;
+      throw error;
+    }
+  }
+  return cachedTuner(root, platform);
+}
+var IMPORT_USAGE = "cimplify kernel import <model.onnx|model.json> [expert.onnx ...] [--router <router.onnx|router.json>] [--samples <samples.json>] [--max-drift <d>] [--memory <n>] [--out <net.mlp>] (ONNX graphs of Gemm, MatMul, Add, Relu, Tanh and Clip, or plain JSON { layers: [{ weights, bias, activation }] } or { router, experts }; with --router every model is an expert)";
+var OUT_SUFFIX = ".mlp";
+var WORD_BYTES = 4;
+var ONNX_SUFFIX = ".onnx";
+function invalid(message) {
+  throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, message, { remediation: `usage: ${IMPORT_USAGE}` });
+}
+async function bytesOf(file) {
+  try {
+    return await promises.readFile(path5.resolve(file));
+  } catch {
+    invalid(`cannot read ${file}`);
+  }
+}
+function layersOf(json, what) {
+  const layers = json?.layers;
+  if (!Array.isArray(layers)) invalid(`${what} needs a "layers" list of { weights, bias, activation }`);
+  return plainNet(layers);
+}
+async function netOf(file) {
+  const bytes = await bytesOf(file);
+  if (file.endsWith(ONNX_SUFFIX)) return readOnnx(new Uint8Array(bytes));
+  let json;
+  try {
+    json = JSON.parse(bytes.toString("utf8"));
+  } catch {
+    invalid(`${file} is neither an .onnx model nor readable JSON`);
+  }
+  const mixture = json;
+  if (mixture.router !== void 0) {
+    if (!Array.isArray(mixture.experts)) invalid(`${file} names a router but no "experts" list`);
+    return { router: layersOf(mixture.router, `${file} router`), experts: mixture.experts.map((e, k) => layersOf(e, `${file} expert ${k}`)) };
+  }
+  return layersOf(json, file);
+}
+function single(net, file) {
+  if ("router" in net) invalid(`${file} is a whole mixture; pass it alone, without --router`);
+  return net;
+}
+async function samplesOf(file) {
+  if (file === void 0) return void 0;
+  let json;
+  try {
+    json = JSON.parse((await bytesOf(file)).toString("utf8"));
+  } catch {
+    invalid(`${file} is not readable JSON`);
+  }
+  const rows = json?.inputs;
+  if (!Array.isArray(rows) || rows.length === 0 || rows.some((r) => !Array.isArray(r) || r.some((v) => typeof v !== "number"))) invalid(`${file} needs an "inputs" list of rows of numbers`);
+  return Float32Array.from(rows.flat());
+}
+function number(raw, name) {
+  if (raw === void 0) return void 0;
+  const value = Number(raw);
+  if (!Number.isFinite(value) || value < 0) invalid(`--${name} must be a non-negative number`);
+  return value;
+}
+async function importNet(file, argv) {
+  if (file === void 0 || file.startsWith("--")) invalid(`usage: ${IMPORT_USAGE}`);
+  const args = parseArgs(argv);
+  const files = [file, ...args.positional];
+  const router = flagString(args, "router");
+  const maxDrift = number(flagString(args, "max-drift"), "max-drift");
+  const memory = number(flagString(args, "memory"), "memory");
+  const samples = await samplesOf(flagString(args, "samples"));
+  const options = { ...samples === void 0 ? {} : { samples }, ...maxDrift === void 0 ? {} : { maxDrift }, ...memory === void 0 ? {} : { memory: Math.round(memory) } };
+  let imported;
+  try {
+    const first = await netOf(file);
+    if (router !== void 0) {
+      const experts = await Promise.all(files.map(async (f) => single(await netOf(f), f)));
+      imported = importMoe(single(await netOf(router), router), experts, options);
+    } else if ("router" in first) {
+      if (files.length > 1) invalid("a mixture file stands alone");
+      imported = importMoe(first.router, first.experts, options);
+    } else {
+      if (files.length > 1) invalid("several models make a mixture only with --router");
+      imported = importMlp(first, options);
+    }
+  } catch (error) {
+    if (error instanceof CliError) throw error;
+    invalid(error.message);
+  }
+  const out = path5.resolve(flagString(args, "out") ?? `${file.replace(/\.(onnx|json)$/, "")}${OUT_SUFFIX}`);
+  const bytes = new Uint8Array(imported.blob.length * WORD_BYTES);
+  const view = new DataView(bytes.buffer);
+  imported.blob.forEach((w, k) => view.setUint32(k * WORD_BYTES, w, true));
+  await promises.writeFile(out, bytes);
+  for (const l of imported.layers) info(dim(`net ${l.net} layer ${l.layer} ${l.inputs}->${l.outputs} ${l.activation === 1 ? "relu" : "linear"}: weight scale ${l.weightScale.toPrecision(4)}, activation scale ${l.activationScale.toPrecision(4)}, requantize ${l.multiplier} >> ${l.shift}`));
+  const d = imported.drift;
+  info(`drift over ${d.samples} samples: largest error ${d.maxError.toPrecision(4)} on outputs up to ${d.peak.toPrecision(4)} (${(d.relative * 100).toFixed(2)}%, bound ${(d.bound * 100).toFixed(2)}%)`);
+  success(`wrote ${path5.relative(process.cwd(), out)}; load it with loadMlp(net, url) or setMlp(net, words)`);
+  result({ out, words: imported.blob.length, inputScale: imported.inputScale, layers: imported.layers, drift: imported.drift, memory: imported.memory });
+}
+var TRAIN_USAGE = "cimplify kernel train <samples.json> --widths <in,hidden,...,out> [--epochs <n>] [--batch <n>] [--rate <r>] [--momentum <m>] [--seed <n>] [--experts <n> [--router <hidden,...>] [--balance <b>]] [--out <net.mlp>] (with --experts the widths are each expert's and the file is a mixture of experts; samples: inputs, targets and optional memory.previous and memory.next rows; the widths count the memory in and out)";
+var OUT_SUFFIX2 = ".mlp";
+var WORD_BYTES2 = 4;
+function memoryWidth(json) {
+  const memory = json?.memory;
+  if (memory === void 0) return 0;
+  const previous = memory.previous;
+  if (!Array.isArray(previous) || !Array.isArray(previous[0])) invalid2('"memory" needs "previous" and "next" arrays with one row of numbers per sample');
+  return previous[0].length;
+}
+function invalid2(message) {
+  throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, message, { remediation: `usage: ${TRAIN_USAGE}` });
+}
+function count(raw, name) {
+  if (raw === void 0) return void 0;
+  const value = Number(raw);
+  if (!Number.isFinite(value) || value < 0) invalid2(`--${name} must be a non-negative number`);
+  return value;
+}
+function samplesOf2(json, inputs, outputs) {
+  const rows = (key) => {
+    const value = json?.[key];
+    if (!Array.isArray(value)) invalid2(`the samples file needs an "${key}" array with one row of numbers per sample`);
+    return value;
+  };
+  const xs = rows("inputs");
+  const ys = rows("targets");
+  if (xs.length !== ys.length || xs.length === 0) invalid2("inputs and targets need the same number of rows, at least one");
+  const flat = (list2, width2, key) => {
+    const out = new Float32Array(list2.length * width2);
+    list2.forEach((row, n) => {
+      if (!Array.isArray(row) || row.length !== width2 || row.some((v) => typeof v !== "number")) invalid2(`${key} row ${n} needs ${width2} numbers`);
+      out.set(row, n * width2);
+    });
+    return out;
+  };
+  const width = memoryWidth(json);
+  const base = { inputs: flat(xs, inputs - width, "inputs"), targets: flat(ys, outputs - width, "targets"), samples: xs.length };
+  if (width === 0) return base;
+  const memory = json.memory;
+  const list = (key) => {
+    const value = memory[key];
+    if (!Array.isArray(value) || value.length !== xs.length) invalid2(`memory.${key} needs one row per sample`);
+    return value;
+  };
+  return { ...base, memory: { width, previous: flat(list("previous"), width, "memory.previous"), next: flat(list("next"), width, "memory.next") } };
+}
+async function trainNet(file, argv) {
+  if (file === void 0 || file.startsWith("--")) invalid2(`usage: ${TRAIN_USAGE}`);
+  const args = parseArgs(argv);
+  const widthsFlag = flagString(args, "widths");
+  if (widthsFlag === void 0) invalid2("--widths is required, for example --widths 32,64,64,8");
+  const widths = widthsFlag.split(",").map((w) => Number(w.trim()));
+  if (widths.length < 2 || widths.some((w) => !Number.isInteger(w) || w < 1)) invalid2("--widths lists whole numbers: inputs, hidden layers, outputs");
+  let json;
+  try {
+    json = JSON.parse(await promises.readFile(path5.resolve(file), "utf8"));
+  } catch {
+    invalid2(`${file} is not a readable JSON file`);
+  }
+  const data = samplesOf2(json, widths[0], widths[widths.length - 1]);
+  const epochs = count(flagString(args, "epochs"), "epochs");
+  const batch = count(flagString(args, "batch"), "batch");
+  const learningRate = count(flagString(args, "rate"), "rate");
+  const momentum = count(flagString(args, "momentum"), "momentum");
+  const seed = count(flagString(args, "seed"), "seed");
+  const experts = count(flagString(args, "experts"), "experts");
+  const balance = count(flagString(args, "balance"), "balance");
+  const routerFlag = flagString(args, "router");
+  const router = routerFlag === void 0 || routerFlag === "" ? [] : routerFlag.split(",").map((w) => Number(w.trim()));
+  if (router.some((w) => !Number.isInteger(w) || w < 1)) invalid2("--router lists whole hidden widths, for example --router 16");
+  const started = performance.now();
+  const common = {
+    ...epochs === void 0 ? {} : { epochs: Math.round(epochs) },
+    ...batch === void 0 ? {} : { batch: Math.round(batch) },
+    ...learningRate === void 0 ? {} : { learningRate },
+    ...momentum === void 0 ? {} : { momentum },
+    ...seed === void 0 ? {} : { seed: Math.round(seed) }
+  };
+  let trained;
+  try {
+    trained = experts === void 0 ? trainMlp(data, { widths, ...common }) : trainMoe(data, { experts: Math.round(experts), router, expert: widths.slice(1, -1), ...balance === void 0 ? {} : { balance }, ...common });
+  } catch (error) {
+    invalid2(error.message);
+  }
+  const seconds = (performance.now() - started) / 1e3;
+  const out = path5.resolve(flagString(args, "out") ?? `${file.replace(/\.json$/, "")}${OUT_SUFFIX2}`);
+  const bytes = new Uint8Array(trained.blob.length * WORD_BYTES2);
+  const view = new DataView(bytes.buffer);
+  trained.blob.forEach((w, k) => view.setUint32(k * WORD_BYTES2, w, true));
+  await promises.writeFile(out, bytes);
+  const loss = Array.from(trained.loss);
+  info(dim(`loss by epoch ${loss.map((l) => l.toPrecision(4)).join(" ")}`));
+  info(`trained ${widths.join("-")} on ${data.samples} samples in ${seconds.toFixed(2)} s; error of the shipped network ${trained.blobLoss.toPrecision(4)}`);
+  success(`wrote ${path5.relative(process.cwd(), out)}; load it with loadMlp(net, url) or setMlp(net, words)`);
+  const usage = trained.usage === void 0 ? null : Array.from(trained.usage);
+  if (usage !== null) info(dim(`rows per expert ${usage.join(" ")}`));
+  result({ out, widths, samples: data.samples, seconds, loss, shippedLoss: trained.blobLoss, words: trained.blob.length, ...usage === null ? {} : { experts: usage.length, usage } });
+}
+
+// src/interactives/commands/kernel.ts
+var USAGE = `cimplify kernel tune <file>[#kernel] --objective <file>[#kernel] --params <A,B> --inputs <recording.json> [--iterations <n>] [--rate <r>] [--band <b>] [--logistic] [--range <A=lo:hi>] [--diff <path>] [--apply] [--tuner <path>]
+       ${TRAIN_USAGE}
+       ${IMPORT_USAGE}`;
+var TUNE = "tune";
+var TRAIN = "train";
+var IMPORT = "import";
+var DIFF_SUFFIX = ".tune.diff";
+function split(spec) {
+  const hash = spec.lastIndexOf("#");
+  return hash < 0 ? { file: spec, name: null } : { file: spec.slice(0, hash), name: spec.slice(hash + 1) };
+}
+function numberFlag(args, name) {
+  const raw = flagString(args, name);
+  if (raw === void 0) return void 0;
+  const value = Number(raw);
+  if (!Number.isFinite(value) || value < 0) throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `--${name} must be a non-negative number`);
+  return value;
+}
+function bounds(raw) {
+  const out = /* @__PURE__ */ new Map();
+  if (raw === void 0) return out;
+  for (const part of raw.split(",")) {
+    const match = /^([A-Za-z_$][\w$]*)=(-?[\d.eE+-]*):(-?[\d.eE+-]*)$/.exec(part.trim());
+    if (match === null) throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `--range ${part} is not NAME=lo:hi`);
+    out.set(match[1], { ...match[2] === "" ? {} : { min: Number(match[2]) }, ...match[3] === "" ? {} : { max: Number(match[3]) } });
+  }
+  return out;
+}
+async function read(file) {
+  try {
+    return await promises.readFile(file, "utf8");
+  } catch {
+    throw new CliError(CLI_ERROR_CODE.NOT_FOUND, `cannot read ${file}`);
+  }
+}
+function relative(root, file) {
+  return path5.relative(root, file).split(path5.sep).join("/");
+}
+async function run(argv) {
+  const [action, target, ...rest] = argv;
+  if (action === TRAIN) return trainNet(target, rest);
+  if (action === IMPORT) return importNet(target, rest);
+  if (action !== TUNE || target === void 0 || target.startsWith("--")) throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `usage: ${USAGE}`);
+  const args = parseArgs(rest);
+  const objectiveFlag = flagString(args, "objective");
+  const paramsFlag = flagString(args, "params");
+  const inputsFlag = flagString(args, "inputs");
+  if (objectiveFlag === void 0 || paramsFlag === void 0 || inputsFlag === void 0) throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `usage: ${USAGE}`);
+  const cwd = process.cwd();
+  const kernelSpec = split(target);
+  const objectiveSpec = split(objectiveFlag);
+  const kernelFile = path5.resolve(kernelSpec.file);
+  const objectiveFile = path5.resolve(objectiveSpec.file);
+  const params = paramsFlag.split(",").map((p) => p.trim()).filter((p) => p !== "");
+  const iterations = numberFlag(args, "iterations");
+  const rate = numberFlag(args, "rate");
+  const band = numberFlag(args, "band");
+  const options = {
+    ...iterations === void 0 ? {} : { iterations: Math.round(iterations) },
+    ...rate === void 0 ? {} : { rate },
+    ...band === void 0 ? {} : { band },
+    ...flagBool(args, "logistic") ? { logistic: true } : {}
+  };
+  const kernelText = await read(kernelFile);
+  const objectiveText = await read(objectiveFile);
+  let inputs;
+  try {
+    inputs = JSON.parse(await read(path5.resolve(inputsFlag)));
+  } catch (error) {
+    if (error instanceof CliError) throw error;
+    throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `${inputsFlag} is not JSON`);
+  }
+  const toolchain = locateToolchain(cwd);
+  if (toolchain === null) throw new CliError(CLI_ERROR_CODE.NOT_FOUND, "the kernel compiler toolchain is not installed", { remediation: "run cimplify build once in this project" });
+  const root = path5.dirname(kernelFile) === path5.dirname(objectiveFile) ? path5.dirname(kernelFile) : cwd;
+  const kernelSource = { path: relative(root, kernelFile), text: kernelText };
+  const objectiveSource = { path: relative(root, objectiveFile), text: objectiveText };
+  let compiled;
+  try {
+    compiled = compileForTuning(kernelSource, kernelSpec.name, objectiveSource, objectiveSpec.name, params, toolchain);
+  } catch (error) {
+    throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, error.message);
+  }
+  let resolved;
+  try {
+    resolved = await resolveTuner({ explicit: flagString(args, "tuner") ?? null, cwd });
+  } catch (error) {
+    throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `the kernel tuner could not be fetched: ${error.message}`, { remediation: "pass --tuner <path to kernel-tune> or set CIMPLIFY_KERNEL_TUNER" });
+  }
+  if (resolved === null) throw new CliError(CLI_ERROR_CODE.NOT_FOUND, "the kernel tuner was not found", { remediation: "sign in with cimplify login so the CLI can fetch it, or pass --tuner <path to kernel-tune>, or set CIMPLIFY_KERNEL_TUNER" });
+  if (resolved.source === "fetched") info(dim(`Downloaded ${KERNEL_TUNE} ${resolved.version ?? ""}`));
+  const command = resolved.command;
+  info(dim(`tuning ${params.join(", ")} of ${compiled.tunable.site.name} against ${compiled.objective.site.name}`));
+  let report;
+  try {
+    report = runTuner(command, tuneJob(compiled, inputs, options, bounds(flagString(args, "range"))));
+  } catch (error) {
+    throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, error.message);
+  }
+  for (const p of report.params) info(`${bold(p.name.padEnd(20))} ${String(p.before).padStart(12)} -> ${String(p.after).padEnd(12)} ${dim(`d loss / d ${p.name} at start ${p.gradient.toExponential(3)}`)}`);
+  info(`loss (shipping kernel) ${report.exact.before.toExponential(4)} -> ${report.exact.after.toExponential(4)}`);
+  info(dim(`loss (surrogate) ${report.surrogate.before.toExponential(4)} -> ${report.surrogate.after.toExponential(4)}, best of ${report.history.length - 1} iterations at ${report.best}`));
+  info(dim(`surrogate ops: ${report.kernel.exact} exact, ${report.kernel.smooth} smooth, ${report.kernel.straight_through} straight-through, ${report.kernel.frozen} without gradient`));
+  const values = new Map(report.params.map((p) => [p.name, p.after]));
+  const { text, edits } = writeBack(kernelSource, values);
+  const diff = unifiedDiff(relative(cwd, kernelFile), kernelText, text);
+  const retuned = compileForTuning({ ...kernelSource, text }, kernelSpec.name, objectiveSource, objectiveSpec.name, params, toolchain);
+  const same = sameButConstants(compiled.shipped.bytes, retuned.shipped.bytes);
+  if (!same) warn("the retuned kernel's bytecode differs beyond its constants (constant pooling or folding changed); review it before shipping");
+  const diffPath = path5.resolve(flagString(args, "diff") ?? `${kernelFile}${DIFF_SUFFIX}`);
+  if (diff === "") {
+    info("no constant changed");
+  } else {
+    await promises.writeFile(diffPath, diff);
+    info(diff.trimEnd());
+    if (flagBool(args, "apply")) {
+      await promises.writeFile(kernelFile, text);
+      success(`applied to ${kernelSource.path}`);
+    } else {
+      success(`review ${path5.relative(cwd, diffPath)}; rerun with --apply to write it`);
+    }
+  }
+  result({ params: report.params, exact: report.exact, surrogate: report.surrogate, edits, diff: diff === "" ? null : diffPath, applied: diff !== "" && flagBool(args, "apply"), sameButConstants: same, kernel: report.kernel });
+}
+
+export { USAGE, run as default };