@genroc/eval-node 0.0.0-edge.f33a7b2 → 0.0.0-edge.f4092c85

package/dist/import.js

@@ -1,17 +1,11 @@
 #!/usr/bin/env node
-// The code-phase resolver: manifest on stdin, `{"code": [...]}` on stdout, non-zero exit
-// with the diagnostic on stderr. genctl never parses TypeScript and this never parses YAML
-// — the manifest is the whole contract. See specs/source-resolution.md.
-//
-// Two modes, one binary: "types" writes the declarations an editor needs and returns no
-// code; "build" typechecks and bundles. A separate types hook would mean a second `tsc`
-// over the same project.
-import { spawn } from "node:child_process";
+// The typed-phase resolver: manifest on stdin, `{"values": [...]}` on stdout, diagnostic on stderr
+// with a non-zero exit (specs/source-resolution.md). Two modes share one `tsc` pass: "generate"
+// writes declarations only, "resolve" typechecks and bundles.
 import { existsSync } from "node:fs";
-import { access, mkdir, writeFile } from "node:fs/promises";
+import { access, writeFile } from "node:fs/promises";
 import { builtinModules } from "node:module";
-import { dirname, join, relative, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
+import { dirname, join, resolve } from "node:path";
 import commonjs from "@rollup/plugin-commonjs";
 import json from "@rollup/plugin-json";
 import { nodeResolve } from "@rollup/plugin-node-resolve";
@@ -30,11 +24,6 @@ async function exists(path) {
         return false;
     }
 }
-/** Creates the parent directory, which `.genroc-cache/` relies on: nothing else makes it. */
-async function write(path, content) {
-    await mkdir(dirname(path), { recursive: true });
-    await writeFile(path, content);
-}
 // ── JSON Schema → TypeScript ───────────────────────────────────────────────────
 /** Only genroc's keyword set is handled; anything else its strict decoder would have
  *  refused before this ran (internal/schema, allowedKeywords). */
@@ -90,15 +79,17 @@ function objectType(s, used) {
         const doc = typeof sub.description === "string"
             ? `  /** ${sub.description} */\n`
             : "";
-        lines.push(`${doc}  ${propKey(key)}${required.has(key) ? "" : "?"}: ${tsType(sub, used)};`);
+        lines.push(`${doc}  ${propKey(key)}${required.has(key) ? "" : "?"}: ${nest(tsType(sub, used))};`);
     }
     if (s.additionalProperties && typeof s.additionalProperties === "object") {
-        lines.push(`  [key: string]: ${tsType(s.additionalProperties, used)};`);
+        lines.push(`  [key: string]: ${nest(tsType(s.additionalProperties, used))};`);
     }
     if (lines.length === 0)
         return "Record<string, unknown>";
     return `{\n${lines.join("\n")}\n}`;
 }
+/** Every line but the first, which is already placed by the property that opens it. */
+const nest = (t) => t.replace(/\n/g, "\n  ");
 function union(parts) {
     const seen = [...new Set(parts)];
     return seen.length === 0 ? "unknown" : seen.join(" | ");
@@ -106,13 +97,6 @@ function union(parts) {
 const IDENT = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 const propKey = (k) => (IDENT.test(k) ? k : JSON.stringify(k));
 const identifier = (n) => IDENT.test(n) ? n : `Def_${n.replace(/[^A-Za-z0-9_$]/g, "_")}`;
-function deref(s, defs) {
-    let cur = s;
-    for (let i = 0; cur && typeof cur.$ref === "string" && i < 16; i++) {
-        cur = defs[cur.$ref.replace(/^#\/\$defs\//, "")];
-    }
-    return cur;
-}
 /** Emits one named type per reachable $def rather than inlining: a task output may
  *  reference itself (specs/recursive-type-inference.md) and inlining would not terminate. */
 function declarations(at) {
@@ -132,7 +116,7 @@ function declarations(at) {
         emitted.push(`export type ${identifier(next)} = ${body};`);
     }
     return [
-        "// Generated by genroc. Do not edit - regenerate with `genctl types`.",
+        "// Generated by genroc. Do not edit - regenerate with `genctl generate`.",
         `// ${where.name}  (${address(site.pointer)})`,
         "",
         ...emitted,
@@ -149,9 +133,8 @@ function typesPathFor(scriptPath) {
     return scriptPath.replace(/\.[^.\/]+$/, "") + ".genroc.d.ts";
 }
 // ── typecheck ──────────────────────────────────────────────────────────────────
-/** The nearest tsconfig above the script — the one the author's editor already reads. Two
- *  different configs mean a red editor over a clean apply, or the reverse. The walk stops at
- *  the project root: above it is not this project. */
+/** The tsconfig the author's editor reads, so editor and apply agree. Stops at the project
+ *  root. */
 async function nearestTsconfig(from, root) {
     for (let dir = from;; dir = dirname(dir)) {
         const candidate = join(dir, "tsconfig.json");
@@ -162,11 +145,7 @@ async function nearestTsconfig(from, root) {
     }
 }
 async function typecheck(sites) {
-    // NOT `.genroc`: that is the project config FILE, and a directory of the same name cannot
-    // coexist with it. The suffix is what keeps the scratch area out of its way.
-    const dir = join(root, ".genroc-cache");
-    await write(join(dir, ".gitignore"), "*\n");
-    // One tsc per distinct base config: `extends` takes a single base, so merging two would
+    // One program per distinct base config: `extends` takes a single base, so merging two would
     // check each script under the other author's options.
     const groups = new Map();
     for (const at of sites) {
@@ -177,10 +156,10 @@ async function typecheck(sites) {
         else
             groups.set(base, [at]);
     }
-    let n = 0;
+    const diagnostics = [];
     for (const [base, group] of groups) {
         const config = {
-            ...(base ? { extends: relative(dir, base) } : {}),
+            ...(base ? { extends: base } : {}),
             compilerOptions: {
                 noEmit: true,
                 strict: true,
@@ -191,42 +170,36 @@ async function typecheck(sites) {
                 // `lib` DESCRIBES the realm and is written after `extends` so a base cannot widen it:
                 // a worker thread has no document, whatever an author's config claims.
                 lib: ["esnext", "webworker"],
-                // `types` is the author's, and it is how a script opts into the node globals —
-                // the worker realm has them, so refusing the declarations would only lie. With no
-                // base config there is nothing to opt in with, so the default stays none.
+                // `types` is the author's opt-in to node globals, which the realm has. With no base
+                // config there is nothing to opt in with, so it stays none.
                 ...(base ? {} : { types: [] }),
             },
-            files: group.flatMap((s) => [
-                relative(dir, s.file),
-                relative(dir, typesPathFor(s.file)),
-            ]),
+            files: group.flatMap((s) => [s.file, typesPathFor(s.file)]),
             // `files` overrides the base's, but a base `include` survives beside it and would
             // drag the author's whole tree in, to be checked under the worker lib.
             include: [],
         };
-        const configPath = join(dir, groups.size === 1 ? "tsconfig.json" : `tsconfig.${n++}.json`);
-        await write(configPath, JSON.stringify(config, null, 2));
-        await runTsc(root, configPath);
+        // Never written; anchors `@types` lookup at the root. Not `tsconfig.json`: that is often the
+        // base it extends, and tsc refuses a circular extends.
+        const parsed = ts.parseJsonConfigFileContent(config, ts.sys, root, undefined, join(root, "tsconfig.genroc.json"));
+        const program = ts.createProgram({
+            rootNames: parsed.fileNames,
+            options: parsed.options,
+            projectReferences: parsed.projectReferences,
+            configFileParsingDiagnostics: parsed.errors,
+        });
+        diagnostics.push(...parsed.errors, ...ts.getPreEmitDiagnostics(program));
     }
-}
-async function runTsc(root, configPath) {
-    const tsc = fileURLToPath(import.meta.resolve("typescript/bin/tsc"));
-    const proc = spawn(process.execPath, [tsc, "--noEmit", "-p", configPath], {
-        cwd: root,
-        stdio: ["ignore", "pipe", "pipe"],
-    });
-    let out = "";
-    let err = "";
-    proc.stdout.on("data", (c) => (out += c));
-    proc.stderr.on("data", (c) => (err += c));
-    const code = await new Promise((resolve, reject) => {
-        proc.on("error", reject);
-        proc.on("close", (c) => resolve(c ?? 1));
-    });
-    if (code !== 0) {
-        // tsc reports on stdout; the exit code IS the type check, so this is the diagnostic
-        // genctl surfaces and the reason a failed import never produces a string.
-        die([out, err].filter(Boolean).join("\n").trimEnd());
+    if (diagnostics.length > 0) {
+        // The diagnostics are the whole type check: this is what genctl surfaces, and the reason a
+        // failed import never produces a string.
+        die(ts
+            .formatDiagnostics(diagnostics, {
+            getCanonicalFileName: (f) => f,
+            getCurrentDirectory: () => root,
+            getNewLine: () => "\n",
+        })
+            .trimEnd());
     }
 }
 // ── bundle ─────────────────────────────────────────────────────────────────────
@@ -253,11 +226,9 @@ const BUILTIN = new Set([
     ...builtinModules,
     ...builtinModules.map((m) => `node:${m}`),
 ]);
-/** Resolves imports through TYPESCRIPT, using the same config the typecheck ran under, so a
- *  `paths` alias that compiles also bundles. Reimplementing `paths` here would be a second
- *  resolver to keep in agreement with tsc; this one cannot disagree.
- *  A package resolving to a `.d.ts` is declined — that is a type, not the implementation —
- *  which leaves node_modules to nodeResolve. */
+/** Resolves through TYPESCRIPT under the typecheck's config, so a `paths` alias that compiles
+ *  also bundles. A `.d.ts` resolution is declined (a type, not code), leaving node_modules to
+ *  nodeResolve. */
 function tsResolve(configPath) {
     let options = {};
     if (configPath) {
@@ -278,14 +249,12 @@ function tsResolve(configPath) {
         },
     };
 }
-/** Bundles to a self-contained ES module, which is what the evaluator imports: the default
- *  export it calls is the author's own, so nothing wraps or rewrites the code between the two.
- *  Bundling is entirely the importer's job, so a definition version pins its code forever. */
+/** A self-contained ES module whose default export is the author's own, unwrapped. Bundling here
+ *  means a definition version pins its code forever. */
 async function bundle(at) {
     const site = at.site;
-    // Builtins are EXTERNALISED as imports the realm resolves natively. Anything else
-    // unresolved is a REFUSAL, not an external: rollup's default is to leave it as an import
-    // of a module that will not be there, which bundles clean and fails at runtime.
+    // Builtins are externalised; anything else unresolved is a REFUSAL, since rollup's default
+    // leaves an import that bundles clean and fails at runtime.
     const built = await rollup({
         input: at.file,
         external: (id) => BUILTIN.has(id),
@@ -293,8 +262,7 @@ async function bundle(at) {
             tsResolve(await nearestTsconfig(dirname(at.file), root)),
             nodeResolve({ extensions: [".ts", ".tsx", ".mjs", ".js", ".json"] }),
             commonjs(),
-            // A `.json` import is a data file inlined at build time, which the previous bundler
-            // did natively; without it rollup hands the JSON to the JS parser.
+            // Inlines `.json` imports; without it rollup hands JSON to the JS parser.
             json(),
             transpile,
         ],
@@ -339,20 +307,18 @@ function address(pointer) {
         .join("")
         .replace(/^\./, "");
 }
-const located = manifest.processes.flatMap((where) => where.sites.map((site) => ({
-    site,
-    where,
-    file: resolve(where.dir, site.argument),
-})));
-// genctl is agnostic about what a script is for; the contract that an evaluation request carries
-// its module in `code` is THIS resolver's, so it is the one that checks a directive landed there.
-// `child` is the shape the scaffold uses — a call to a process that forwards to the evaluator —
-// and `external` is the same request made directly.
+const located = manifest.processes.flatMap((where) => where.sites.map((site) => {
+    const [script, ...rest] = site.args;
+    if (script === undefined || rest.length > 0) {
+        die(`${join(where.dir, where.file)}: ${address(site.pointer)}: $import takes one script, ` +
+            `and is given ${site.args.length} arguments`);
+    }
+    return { site, where, file: resolve(where.dir, script) };
+}));
+// The `code`-field contract is this resolver's, not genctl's, so it checks the directive landed
+// there: in a child call (the scaffold's shape) or an external task's input.
 for (const at of located) {
-    // Two halves, from the two places that carry them: the action's KIND is a field, and WHERE in
-    // it the directive sits is the pointer. A child call is the shape the scaffold generates — to a
-    // process that forwards to the evaluator — and an external task is the same request made
-    // directly.
+    // The action's kind is a field; where in it the directive sits is the pointer.
     const kind = at.site.level === "action" ? (at.site.action ?? "") : "";
     const slot = at.site.pointer.slice(-2).join(".");
     if ((kind !== "child" && kind !== "external") || slot !== "input.code") {
@@ -361,12 +327,11 @@ for (const at of located) {
             `${kind ? `a ${kind} task's ` : ""}\`${slot}\`.`);
     }
 }
-// genctl no longer stats the argument — it does not know it is a file — so the resolver that
-// does is the one that must say when it is not there.
+// genctl does not know the argument is a file, so this resolver reports a missing one.
 for (const at of located) {
     if (!existsSync(at.file)) {
         die(`${join(at.where.dir, at.where.file)}: ${address(at.site.pointer)}: ` +
-            `"$import: ${at.site.argument}" names no file (looked at ${at.file})`);
+            `"$import: ${at.site.args[0]}" names no file (looked at ${at.file})`);
     }
 }
 // One script at two sites with different input types is a refusal, not a union: the union
@@ -383,15 +348,14 @@ for (const at of located) {
     byPath.set(at.file, at);
 }
 for (const at of byPath.values()) {
-    await write(typesPathFor(at.file), declarations(at));
+    await writeFile(typesPathFor(at.file), declarations(at));
 }
-if (manifest.mode === "types") {
-    console.log(JSON.stringify(manifest, null, 2));
+if (manifest.mode === "generate") {
     process.exit(0);
 }
 await typecheck([...byPath.values()]);
-const code = [];
+const values = [];
 for (const at of located) {
-    code.push(await bundle(at));
+    values.push(await bundle(at));
 }
-process.stdout.write(JSON.stringify({ code }));
+process.stdout.write(JSON.stringify({ values }));

package/dist/realm.js

@@ -1,9 +1,5 @@
-// The evaluation realm. One Worker per execution: a fresh global object per script, and a
-// thread the host can kill mid-loop — the only thing that bounds a synchronous busy loop.
-// eval.ts owns the budget and does the killing; nothing here knows about time.
-//
-// Everything that touches the script's VALUE lives on this side of the boundary — loading,
-// classifying, serialising — because this is the only realm the value exists in.
+// The evaluation realm: one Worker per execution, killable mid-loop by eval.ts, which owns the
+// budget. Everything touching the script's VALUE lives here, the only realm it exists in.
 var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
     if (typeof path === "string" && /^\.\.?\//.test(path)) {
         return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
@@ -14,9 +10,8 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 };
 import { registerHooks } from "node:module";
 import { parentPort } from "node:worker_threads";
-// The script is IMPORTED as a module under a URL of our own, not compiled from a string: its
-// frames then carry the author's own line numbers, and an `import` of a node builtin resolves
-// the way it does everywhere else.
+// IMPORTED under our own URL rather than compiled from a string, so frames carry the author's
+// line numbers and builtin imports resolve normally.
 const SCRIPT_URL = "script:main";
 const STACK_BYTES = 2_048;
 // The only channel a load hook has to the source. Written per request and read once — a realm
@@ -41,7 +36,10 @@ function scriptStack(err) {
 }
 function describe(err, kind) {
     if (err instanceof Error) {
-        return { kind, name: err.name, message: err.message, stack: scriptStack(err) };
+        // A subclass inherits `name` from Error.prototype, so `class LimitExceeded extends Error {}`
+        // would report "Error"; a name the script set still wins.
+        const name = err.name === "Error" && err.constructor.name ? err.constructor.name : err.name;
+        return { kind, name, message: err.message, stack: scriptStack(err) };
     }
     // A script may throw a non-Error (`throw {code: "x"}`), so name/message must not assume one.
     return { kind, name: "Thrown", message: safeText(err) };
@@ -54,9 +52,8 @@ function safeText(v) {
         return String(v);
     }
 }
-/** A module that will not parse, or names an import nothing resolves, is broken code — only
- *  editing it helps. Anything else thrown by the import is the module's top level running,
- *  which is the script throwing. */
+/** Unparseable code or an unresolvable import is broken code; anything else the import throws is
+ *  the module's top level running, i.e. the script throwing. */
 function unloadable(err) {
     const code = err?.code;
     return err instanceof SyntaxError || (typeof code === "string" && code.startsWith("ERR_MODULE"));
@@ -97,10 +94,8 @@ async function run(req) {
         return { ok: false, failure: describe(err, "nonserializable") };
     }
 }
-// The realm's stdio is a pipe to the host thread, and eval.ts terminates this thread the moment
-// the reply lands — so whatever a script wrote last is still in the pipe when it dies. An empty
-// write's callback fires once the queue ahead of it has drained, which makes the reply a barrier
-// for `console` and a direct process.stdout.write alike: both are this stream.
+// eval.ts terminates this thread the moment the reply lands, while stdio may still be in the
+// pipe. An empty write's callback fires once the queue drains, making the reply a barrier.
 function flush(stream) {
     return new Promise((resolve) => stream.write("", () => resolve()));
 }

package/dist/worker.js

@@ -1,31 +1,18 @@
 #!/usr/bin/env node
-// The queue worker: claims parked `external` script tasks from genroc, evaluates each in its
-// own realm, and answers. This is the whole genroc-facing half — eval.ts and realm.ts know
-// nothing about the queue, which is what keeps the containment strategy swappable.
-//
-// See README.md for the contract, and specs/external-task-queue.md for the queue itself.
+// The queue worker: claims parked `external` script tasks, evaluates each in its own realm, and
+// answers. The only genroc-facing half (README.md; specs/external-task-queue.md).
 import { readFileSync } from "node:fs";
-import { evaluate } from "./eval.js";
+import { Cancelled, evaluate } from "./eval.js";
 const SERVER = (process.env.GENROC_SERVER ?? "http://localhost:8448").replace(/\/$/, "");
 const WORKER_ID = process.env.WORKER_ID ?? `evaluator-${process.pid}`;
-// The credential, when the server runs with --auth token. A worker needs exactly the `worker`
-// permission — the four queue verbs plus GET /api/objects — so mint it scoped rather than
-// handing a worker an admin token: this is the credential most likely to sit on a machine you
-// trust least. specs/api-auth.md §5.
-//
-// Sent as a header rather than in the URL because Node's fetch REFUSES a URL carrying
-// credentials ("Request cannot be constructed from a URL that includes credentials"), so the
-// basic-auth-in-the-URL trick that works for genctl is not available here.
-// GENROC_TOKEN_FILE is the mounted-secret shape: a credential in a file rather than an
-// environment variable, so it stays out of `docker inspect` and out of the process environment
-// any child inherits. The inline variable wins when both are set.
+// Needs only the `worker` permission (specs/api-auth.md §5): this credential sits on the machine
+// you trust least. A header, because Node's fetch refuses credentials in a URL. The file form
+// keeps it out of `docker inspect` and child environments; the inline variable wins.
 const TOKEN = process.env.GENROC_TOKEN ??
     (process.env.GENROC_TOKEN_FILE ? readFileSync(process.env.GENROC_TOKEN_FILE, "utf8").trim() : "");
 const authHeaders = TOKEN ? { authorization: `Bearer ${TOKEN}` } : {};
-// Concurrency is the worker's to set, and that is the point of pulling: under the old fetch
-// shape genroc decided how many scripts ran at once (--max-concurrent, default 200) and the
-// evaluator accepted every one of them. Here it claims what it can run and no more, so a
-// backlog is a queue rather than 200 threads fighting over a core.
+// The worker claims only what it can run, so a backlog is a queue rather than threads fighting
+// over a core.
 const CONCURRENCY = Number(process.env.CONCURRENCY ?? 4);
 const POLL_MS = Number(process.env.POLL_MS ?? 250);
 // The visibility timeout. Short, and renewed while work is in flight: a worker that dies
@@ -34,17 +21,15 @@ const LEASE_MS = Number(process.env.LEASE_MS ?? 30_000);
 const RENEW_MS = Math.max(1_000, Math.floor(LEASE_MS / 3));
 const PROCESS_FILTER = process.env.PROCESS ?? "";
 const TASK_FILTER = process.env.TASK ?? "";
-// Values too large to ship inline are listed rather than carried, and a bundle is exactly that:
-// one object shared by every instance of a definition version, fetched once instead of copied
-// into each task. A ref is a content hash, so it is immutable — the cache never invalidates.
+// Large values arrive as refs; a bundle is one object per definition version, fetched once.
+// Refs are content hashes, so the cache never invalidates.
 const objectCache = new Map();
 async function fetchObject(ref) {
     const cached = objectCache.get(ref);
     if (cached !== undefined)
         return cached;
-    // Left to throw on purpose: this runs while a task is IN FLIGHT, and a task whose input
-    // cannot be fetched must fail rather than silently run against a missing value. The caller
-    // releases the claim, so the task returns to the queue.
+    // Left to throw: a task whose input cannot be fetched must not run against a missing value.
+    // The caller releases the claim.
     const res = await fetch(`${SERVER}/api/objects/${encodeURIComponent(ref)}`, { headers: authHeaders });
     if (!res.ok)
         throw new Error(`fetch object ${ref}: HTTP ${res.status}`);
@@ -62,15 +47,15 @@ async function fetchObject(ref) {
 /** Put each listed value back where its path says it belongs. Paths are arrays of keys, so this
  *  needs no parser: the whole reason they are not JSON Pointer strings. */
 async function resolveObjects(job) {
-    let input = job.input;
+    let input = job.external_input;
     for (const e of job.objects ?? []) {
         const value = await fetchObject(e.ref);
         if (e.path.length === 0) {
             input = value;
             continue;
         }
-        // The path is rooted at the entry and starts with "input", which is the value being rebuilt.
-        const rest = e.path[0] === "input" ? e.path.slice(1) : e.path;
+        // The path is rooted at the entry and starts with "external_input", the value being rebuilt.
+        const rest = e.path[0] === "external_input" ? e.path.slice(1) : e.path;
         if (rest.length === 0) {
             input = value;
             continue;
@@ -84,10 +69,8 @@ async function resolveObjects(job) {
     return input;
 }
 async function call(path, body) {
-    // A network error is a REPLY, not a throw. A worker outlives the server it polls — a
-    // restart, a rolling deploy, a container coming up before genroc is listening — and an
-    // unhandled rejection here kills it for a condition the next poll would clear. Status 0
-    // says "never reached the server", which is distinct from anything genroc answers.
+    // A network error is a REPLY (status 0, "never reached the server"), not a throw: a worker
+    // outlives restarts and deploys, and an unhandled rejection would kill it.
     let res;
     try {
         res = await fetch(SERVER + path, {
@@ -109,9 +92,8 @@ async function call(path, body) {
     }
     return { ok: res.ok, status: res.status, data };
 }
-/** The task input IS an EvalRequest: `code` required, `input` and `timeout_ms` optional. A task
- *  whose input is not that shape is the definition's fault, not the script's, and is reported
- *  as a compile_error — the nearest permanent kind, since no retry can fix the definition. */
+/** A task input that is not an EvalRequest is the definition's fault, reported as compile_error:
+ *  the nearest permanent kind, since no retry fixes the definition. */
 function asEvalRequest(input) {
     if (typeof input !== "object" || input === null)
         return "the task input is not an object";
@@ -126,10 +108,8 @@ function asEvalRequest(input) {
 }
 const inFlight = new Map();
 let running = true;
-// Whether the last claim reached genroc. A worker polls several times a second, so an
-// unreachable server would otherwise emit a line per poll — thousands during a restart, which
-// buries the one line that mattered. Announce the TRANSITIONS instead: going away, and coming
-// back. Silence in between is the report that nothing changed.
+// Announce reachability TRANSITIONS only: polling several times a second would otherwise emit
+// thousands of lines during a restart.
 let serverReachable = true;
 async function claim(n) {
     const { ok, status, data } = await call("/api/external-tasks/claim", {
@@ -140,18 +120,15 @@ async function claim(n) {
         ...(TASK_FILTER ? { task: TASK_FILTER } : {}),
     });
     if (!ok) {
-        // A credential problem is not transient, and polling through it looks like a healthy
-        // worker that never picks anything up — the worst shape for an operator to debug. Exit
-        // instead, so a supervisor restarts it and the failure is visible where it happened.
+        // A credential problem is not transient, and polling through it looks like a healthy idle
+        // worker. Exit, so a supervisor restarts it visibly.
         if (status === 401 || status === 403) {
             console.error(`claim rejected (${status}): ${JSON.stringify(data)}\n` +
                 `The server requires authentication. Set GENROC_TOKEN to a token with the 'worker' ` +
                 `permission — mint one with: genctl token create --perms worker --label evaluator -q`);
             process.exit(1);
         }
-        // status 0 is "never reached the server" (see call): a restart, a rolling deploy, a
-        // network blip. Not an error to act on — the next poll clears it — so it is reported once
-        // and then waited out.
+        // status 0 (see call): a restart or blip the next poll clears, so it is reported once.
         if (status === 0) {
             if (serverReachable) {
                 serverReachable = false;
@@ -174,10 +151,8 @@ async function release(token) {
     if (!ok)
         console.error(`release failed: ${JSON.stringify(data)}`);
 }
-/** answer submits the outcome. A refusal is NOT retried with a different one: the definition
- *  declared a contract this worker does not satisfy (an undeclared code, a payload that does
- *  not fit `raises`), and guessing again would only pick a second wrong answer. Release it, so
- *  the task returns to the queue and an operator sees it waiting rather than silently gone. */
+/** A refused outcome is not retried with another: the worker does not satisfy the declared
+ *  contract. Released, so an operator sees the task waiting rather than gone. */
 async function answer(token, outcome) {
     const { ok, data } = await call("/api/external-tasks/resolve", { token, ...outcome });
     if (ok)
@@ -185,7 +160,7 @@ async function answer(token, outcome) {
     console.error(`genroc refused the outcome for ${token}: ${JSON.stringify(data)}`);
     await release(token);
 }
-async function run(job) {
+async function run(job, signal) {
     let resolved;
     try {
         resolved = await resolveObjects(job);
@@ -206,13 +181,18 @@ async function run(job) {
     }
     let result;
     try {
-        result = await evaluate(req);
+        result = await evaluate(req, signal);
     }
     catch (err) {
-        // The RUNNER faulted, not the script — the one class where a retry can help. There is no
-        // error code for it on purpose: releasing the claim is how a queue spells "retryable", and
-        // it puts the task in front of a different worker instead of burning the definition's
-        // on_error budget on this one's bad day.
+        // Cancelled is not a fault. Still released: the row is terminal so nothing re-claims it,
+        // but the release stops it waiting out a lease nobody serves.
+        if (err instanceof Cancelled) {
+            console.log(`cancelled: ${job.token}`);
+            await release(job.token);
+            return;
+        }
+        // The RUNNER faulted, the one retryable class. Releasing is how a queue spells "retryable",
+        // and it reaches another worker without spending the definition's on_error budget.
         console.error(`evaluator fault on ${job.token}: ${err instanceof Error ? err.message : String(err)}`);
         await release(job.token);
         return;
@@ -245,11 +225,18 @@ async function renewLoop() {
             tokens,
             lease_ms: LEASE_MS,
         });
-        // A short count means a claim lapsed and was taken over. Nothing to do about it — the work
-        // continues and its answer will be refused — but say so, because it is the signal that
-        // LEASE_MS is too short for what these scripts actually take.
-        if (ok && data?.renewed < tokens.length) {
-            console.error(`renewed ${data.renewed}/${tokens.length} claims; a lease lapsed under load`);
+        if (!ok)
+            continue;
+        // Abort first rather than let a stopped script burn a core; the release rides run()'s
+        // catch, so nothing is released twice.
+        for (const token of (data?.cancelled ?? [])) {
+            inFlight.get(token)?.abort.abort();
+        }
+        // Lost: another worker holds it now and our answer will be refused; logged as the sign that
+        // LEASE_MS is too short. NOT released: that would bump the epoch out from under the holder.
+        const lost = (data?.lost ?? []);
+        if (lost.length) {
+            console.error(`lost ${lost.length}/${tokens.length} claims; a lease lapsed under load`);
         }
     }
 }
@@ -258,8 +245,9 @@ async function pollLoop() {
         const free = CONCURRENCY - inFlight.size;
         const jobs = free > 0 ? await claim(free) : [];
         for (const job of jobs) {
-            inFlight.set(job.token, job);
-            void run(job).finally(() => inFlight.delete(job.token));
+            const abort = new AbortController();
+            inFlight.set(job.token, { job, abort });
+            void run(job, abort.signal).finally(() => inFlight.delete(job.token));
         }
         // Only idle when there was nothing to take: a full queue should be drained at the speed the
         // realms allow, not at the poll interval.