agentic-numerical-control 0.1.6 → 0.2.0

package/dist/engines/kiri/bin/runner.mjs

@@ -0,0 +1,241 @@
+// ANC's CAM process: runs Kiri:Moto's engine (unchanged upstream code, bundled
+// beside this file) on one job and returns the G-code. server/cam.ts starts
+// it as a separate child process for each job, so CAM work can never block or
+// reach machine control; ANC cancels a job by ending the process.
+//
+// IPC in:  { type: "generate", job }  (see Job below)
+//          { type: "inspect", model, units }  (size of a model, no toolpaths)
+// IPC out: { type: "progress", fraction, status }
+//          { type: "result", ... }  |  { type: "error", message }
+// Or from a shell: node runner.mjs job.json out.nc
+//
+// Job: {
+//   model: absolute path of an STL file, units: "mm" | "in",
+//   stock: { x, y, z } in mm (absolute size),
+//   origin: "front-left" | "center"  (X/Y zero; Z zero is the top of the stock),
+//   device: Kiri CAM device fields (bed size, spindleMax, gcodePre, ...),
+//   tools: Kiri tool records, process: Kiri CAM process fields including ops
+// }
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { Worker } from 'node:worker_threads';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const CWD = process.cwd();
+// Kiri loads its WebAssembly from "../wasm/" relative to the working folder.
+process.chdir(HERE);
+
+globalThis.self = globalThis;
+await import('./dom-stub.mjs');
+
+const buffers = (transfer) => (Array.isArray(transfer) ? transfer.filter((t) => t instanceof ArrayBuffer) : undefined);
+
+// Kiri's client asks self.createWorker() for its worker when it is defined.
+self.createWorker = () => {
+  const shim = new URL('./worker-shim.mjs', import.meta.url);
+  const worker = new Worker(shim, {
+    workerData: {
+      script: pathToFileURL(path.join(HERE, 'kiri-work.js')).href,
+      pool: pathToFileURL(path.join(HERE, 'kiri-pool.js')).href,
+    },
+  });
+  const facade = {
+    postMessage: (msg, transfer) => worker.postMessage(msg, buffers(transfer)),
+    terminate: () => worker.terminate(),
+    onmessage: null,
+  };
+  worker.on('message', (data) => facade.onmessage?.({ data }));
+  worker.on('error', (error) => fail(`CAM worker failed: ${error?.message ?? error}`));
+  return facade;
+};
+
+const { newEngine, conf, version } = await import('./kiri-main.js');
+
+// For each operation ANC offers: the operation's fields and the CAM process
+// setting each one defaults from (a literal where upstream uses one). Copied
+// from the createPopOp() tables in upstream src/kiri/mode/cam/app/cl-ops.js,
+// which is UI code and can't be imported here. Update with the pin.
+const OP_FIELDS = {
+  rough: {
+    tool: 'camRoughTool', direction: 'camMillDirection', spindle: 'camRoughSpindle', down: 'camRoughDown', step: 'camRoughOver',
+    rate: 'camRoughSpeed', plunge: 'camRoughPlunge', leave: 'camRoughStock', leavez: 'camRoughStockZ', all: 'camRoughAll',
+    flats: 'camRoughFlat', inside: 'camRoughIn', omitthru: 'camRoughOmitThru', ov_topz: 0, ov_botz: 0,
+  },
+  outline: {
+    tool: 'camOutlineTool', direction: 'camMillDirection', spindle: 'camOutlineSpindle', step: 'camOutlineOver', steps: 'camOutlineOverCount',
+    down: 'camOutlineDown', rate: 'camOutlineSpeed', plunge: 'camOutlinePlunge', dogbones: 'camOutlineDogbone', revbones: 'camOutlineRevbone',
+    omitthru: 'camOutlineOmitThru', omitvoid: 'camOutlineOmitVoid', outside: 'camOutlineOut', inside: 'camOutlineIn', wide: 'camOutlineWide',
+    ov_topz: 0, ov_botz: 0,
+  },
+  contour: {
+    tool: 'camContourTool', spindle: 'camContourSpindle', step: 'camContourOver', rate: 'camContourSpeed', angle: 'camContourAngle',
+    leave: 'camContourLeave', tolerance: 'camTolerance', flatness: 'camFlatness', reduction: 'camContourReduce', bridging: 'camContourBridge',
+    bottom: 'camContourBottom', curves: 'camContourCurves', inside: 'camContourIn', clipto: 'camStockClipTo', filter: 'camContourFilter', axis: 'X',
+  },
+};
+
+/** An operation with every field upstream's app would give it, then ANC's values on top. */
+function fillOp(op) {
+  const fields = OP_FIELDS[op.type];
+  if (!fields) throw new Error(`Unsupported operation "${op.type}"`);
+  const defaults = conf.defaults.cam.p;
+  const out = { type: op.type };
+  for (const [field, from] of Object.entries(fields)) {
+    out[field] = typeof from === 'string' && from.startsWith('cam') ? defaults[from] : from;
+  }
+  return { ...out, ...op };
+}
+
+function send(msg) {
+  if (process.send) process.send(msg);
+}
+
+function fail(message) {
+  if (!process.send) {
+    console.error(message);
+    process.exit(1);
+  }
+  process.send({ type: 'error', message: String(message) }, () => process.exit(1));
+}
+
+const fmtFeed = (f) => String(Number(f.toFixed(4)));
+
+/**
+ * Kiri links the passes of a pocket with rapids at cutting depth: its prepare
+ * step leaves a move inside a pocket's travel boundary as a move. On a real
+ * machine a G0 there runs at full speed into uncut stock, so ANC rewrites
+ * every rapid that travels or descends below the top of the stock (Z 0) as a
+ * G1, at no more than the last cutting feed, and keeps Kiri's own feeds for
+ * the lines after it. Returns the G-code and how many moves it changed.
+ */
+export function feedLinksInStock(gcode) {
+  const pos = { X: null, Y: null, Z: null };
+  let kiriMotion = null; // modal G0-G3 as Kiri wrote it
+  let motion = null; // and as ANC sends it
+  let kiriF = null;
+  let machineF = null;
+  let cutF = null;
+  let changed = 0;
+  const lines = gcode.split('\n').map((line) => {
+    const code = line.replace(/[;(].*$/, '');
+    const words = [...code.toUpperCase().matchAll(/([A-Z])\s*([-+]?\d*\.?\d+)/g)].map((m) => [m[1], Number(m[2])]);
+    const g = words.find(([k, v]) => k === 'G' && v >= 0 && v <= 3);
+    const f = words.find(([k]) => k === 'F');
+    if (g) kiriMotion = g[1];
+    if (f) kiriF = f[1];
+    const target = { ...pos };
+    for (const [k, v] of words) if (k in target) target[k] = v;
+    if (kiriMotion === null || !words.some(([k]) => k in pos)) {
+      if (f) machineF = f[1];
+      return line;
+    }
+
+    const inStock = pos.Z !== null && target.Z < 0 && (target.X !== pos.X || target.Y !== pos.Y || target.Z < pos.Z);
+    Object.assign(pos, target);
+    let want = kiriMotion;
+    let wantF = want === 0 ? null : kiriF;
+    if (want === 0 && inStock && (cutF ?? kiriF) !== null) {
+      want = 1;
+      wantF = Math.min(kiriF ?? Infinity, cutF ?? Infinity);
+      changed++;
+    }
+
+    let out = code.trimEnd();
+    const rest = line.slice(code.trimEnd().length);
+    if (g && want !== kiriMotion) out = out.replace(/G0*[0-3](?![\d.])/i, `G${want}`);
+    else if (!g && want !== motion) out = `G${want} ${out}`;
+    if (wantF !== null && (wantF !== machineF || (f && f[1] !== wantF))) {
+      out = out.replace(/\s*F\s*[-+]?\d*\.?\d+/i, '') + (wantF !== machineF ? ` F${fmtFeed(wantF)}` : '');
+    }
+    machineF = wantF ?? (f ? f[1] : machineF);
+    motion = want;
+    if (want !== 0) cutF = machineF;
+    return out + rest;
+  });
+  return { gcode: lines.join('\n'), changed };
+}
+
+/** Reads a model the way Kiri does and reports its size, in the model's own units. */
+export async function inspect(model) {
+  const engine = newEngine();
+  let triangles = 0;
+  engine.setListener((msg) => {
+    if (msg?.vertices) triangles = msg.vertices.length / 9;
+  });
+  engine.setMode('CAM');
+  await engine.parse(new Uint8Array(fs.readFileSync(model)).buffer);
+  const box = engine.widget.getBoundingBox();
+  return {
+    engine: 'Kiri:Moto',
+    version,
+    triangles,
+    size: { x: box.max.x - box.min.x, y: box.max.y - box.min.y, z: box.max.z - box.min.z },
+  };
+}
+
+export async function generate(job) {
+  const engine = newEngine();
+  let lastAlert = null;
+  engine.setListener((msg) => {
+    const s = msg?.slice ?? msg?.prepare;
+    if (s?.update !== undefined) send({ type: 'progress', fraction: s.update, status: s.updateStatus ?? (msg.slice ? 'slicing' : 'preparing') });
+    if (msg?.slice?.alert) lastAlert = msg.slice.alert;
+  });
+  engine.setMode('CAM');
+  engine.setDevice(job.device);
+  engine.setTools(job.tools);
+
+  const data = fs.readFileSync(job.model);
+  await engine.parse(new Uint8Array(data).buffer);
+  if (job.units === 'in') engine.scale(25.4, 25.4, 25.4);
+  const box = engine.widget.getBoundingBox();
+  const part = { x: box.max.x - box.min.x, y: box.max.y - box.min.y, z: box.max.z - box.min.z };
+  const stock = { ...job.stock };
+
+  // Absolute stock, part's top at the top of the stock ("top" anchor), Z zero
+  // at the top of the stock: the same placement Kiri's own app makes in
+  // platform.update_stock / update_top_z / update_origin.
+  engine.setProcess({ ...job.process, ops: (job.process.ops ?? []).map(fillOp), camStockOffset: false, camZAnchor: 'top', camOriginTop: true, camOriginCenter: job.origin === 'center' });
+  engine.setStock(stock);
+  const center = { x: (box.max.x + box.min.x) / 2, y: (box.max.y + box.min.y) / 2, z: stock.z / 2 };
+  engine.settings.stock.center = center;
+  engine.widget.setTopZ(stock.z, true);
+  if (job.origin === 'center') engine.setOrigin(center.x, -center.y, stock.z + 0.01);
+  else engine.setOrigin(-stock.x / 2 + center.x, stock.y / 2 - center.y, stock.z + 0.01);
+
+  await engine.slice();
+  await engine.prepare();
+  const linked = feedLinksInStock(await engine.export());
+  return {
+    gcode: linked.gcode,
+    info: { engine: 'Kiri:Moto', version, part, stock, origin: job.origin, alert: lastAlert, linksAsCuts: linked.changed },
+  };
+}
+
+process.on('uncaughtException', (e) => fail(e?.stack ?? e));
+process.on('unhandledRejection', (e) => fail(e?.stack ?? e));
+
+if (process.send) {
+  process.on('message', async (msg) => {
+    if (msg?.type !== 'generate' && msg?.type !== 'inspect') return;
+    try {
+      const result = msg.type === 'inspect' ? await inspect(msg.model) : await generate(msg.job);
+      // Exit only once the result has been written: a large program takes
+      // more than one write to send.
+      process.send({ type: 'result', ...result }, () => process.exit(0));
+    } catch (e) {
+      fail(e?.message ?? e);
+    }
+  });
+  process.on('disconnect', () => process.exit(0));
+  send({ type: 'ready' });
+} else if (process.argv[2]) {
+  const job = JSON.parse(fs.readFileSync(path.resolve(CWD, process.argv[2]), 'utf-8'));
+  const result = await generate(job);
+  if (process.argv[3]) fs.writeFileSync(path.resolve(CWD, process.argv[3]), result.gcode);
+  else process.stdout.write(result.gcode);
+  console.error(JSON.stringify(result.info));
+  process.exit(0);
+}

package/dist/engines/kiri/bin/worker-shim.mjs

@@ -0,0 +1,32 @@
+// Runs one of Kiri:Moto's worker bundles (kiri-work.js, kiri-pool.js) in a
+// Node worker_thread, with the Web Worker globals those bundles expect: self,
+// postMessage, onmessage, and Worker for the helper "minion" pool the main
+// worker starts. Upstream code is unchanged; this only adapts the host.
+
+import { Worker as NodeWorker, parentPort, workerData } from 'node:worker_threads';
+
+const buffers = (transfer) => (Array.isArray(transfer) ? transfer.filter((t) => t instanceof ArrayBuffer) : undefined);
+
+globalThis.self = globalThis;
+globalThis.postMessage = (msg, transfer) => parentPort.postMessage(msg, buffers(transfer));
+parentPort.on('message', (data) => {
+  const handler = globalThis.onmessage;
+  if (handler) handler({ data });
+});
+
+// Minions: Kiri asks for new Worker(poolURL); every one runs the pool bundle.
+globalThis.Worker = class {
+  constructor() {
+    this.worker = new NodeWorker(new URL(import.meta.url), { workerData: { script: workerData.pool, pool: workerData.pool } });
+    this.worker.on('message', (data) => this.onmessage?.({ data }));
+    this.worker.on('error', (error) => this.onerror?.(Object.assign(error, { preventDefault() {} })));
+  }
+  postMessage(msg, transfer) {
+    this.worker.postMessage(msg, buffers(transfer));
+  }
+  terminate() {
+    this.worker.terminate();
+  }
+};
+
+await import(workerData.script);