@genroc/eval-node 0.0.0-edge.627a84e1 → 0.0.0-edge.63f3718c

package/dist/eval.js

@@ -1,21 +1,28 @@
-// Imports a script module in its own realm (a Worker per execution, realm.ts), calls its default
-// export, and classifies every outcome (README.md). Only a killable thread bounds a synchronous
-// busy loop, which is what makes the budget real. Knows nothing of genroc; worker.ts does.
+// Evaluation core: import a script module in its OWN realm, call its default export, and
+// classify every outcome into one of the failure kinds in README.md. Nothing here knows about
+// genroc — worker.ts is the only thing that talks to the queue — so this stays testable and
+// the containment stays swappable.
+//
+// The containment is a Worker per execution (realm.ts). It is what makes the budget real:
+// a synchronous busy loop never yields, so no in-process timer can interrupt it, and only a
+// thread the host can kill bounds it.
 import { Worker } from "node:worker_threads";
 const DEFAULT_TIMEOUT_MS = 5_000;
 // Resolved from THIS file's own extension: run from a checkout it is `.ts`, and from the
 // published package `.js`, because Node will not strip types under node_modules.
 const REALM_URL = new URL(import.meta.url.endsWith(".ts") ? "./realm.ts" : "./realm.js", import.meta.url);
-/** Thrown, not returned: a realm that fails to start is the runner faulting, which worker.ts
- *  answers by releasing the claim. */
+/** Thrown, not returned: a realm that fails to start is the RUNNER faulting, which worker.ts
+ *  answers by releasing the claim rather than by reporting an outcome. A script fault is a
+ *  return value. */
 class RealmFault extends Error {
     constructor(message) {
         super(message);
         this.name = "RealmFault";
     }
 }
-/** Thrown when `signal` aborts: the answer is no longer wanted, so worker.ts releases rather
- *  than answers. Not a RealmFault: nothing is wrong. */
+/** Thrown when `signal` aborts: the work was cancelled server-side, so there is no outcome to
+ *  report and worker.ts must release rather than answer. Distinct from RealmFault because the
+ *  runner did not fault -- nothing is wrong, the answer is simply no longer wanted. */
 export class Cancelled extends Error {
     constructor() {
         super("cancelled");
@@ -39,8 +46,9 @@ export async function evaluate(req, signal) {
                 signal.addEventListener("abort", onAbort, { once: true });
             }
             worker.once("message", (reply) => resolve(reply));
-            // A script may `process.exit()`, which would otherwise look like a hang until the budget.
-            // Our own terminate() fires this too, after the promise has settled.
+            // A script may end its own realm (`process.exit()`), which is not a throw and would
+            // otherwise present as a hang until the budget expired. Our own terminate() raises
+            // this too, by which time the promise has settled and the first result stands.
             worker.once("exit", (code) => resolve(exited(code)));
             worker.once("error", (err) => reject(new RealmFault(errorText(err))));
             worker.postMessage({ code: req.code, input: req.input });

package/dist/import.js

@@ -1,7 +1,11 @@
 #!/usr/bin/env node
-// The code-phase resolver: manifest on stdin, `{"code": [...]}` on stdout, diagnostic on stderr
-// with a non-zero exit (specs/source-resolution.md). Two modes share one `tsc` pass: "types"
-// writes declarations only, "build" typechecks and bundles.
+// 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 { existsSync } from "node:fs";
 import { access, writeFile } from "node:fs/promises";
 import { builtinModules } from "node:module";
@@ -133,8 +137,9 @@ function typesPathFor(scriptPath) {
     return scriptPath.replace(/\.[^.\/]+$/, "") + ".genroc.d.ts";
 }
 // ── typecheck ──────────────────────────────────────────────────────────────────
-/** The tsconfig the author's editor reads, so editor and apply agree. Stops at the project
- *  root. */
+/** 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. */
 async function nearestTsconfig(from, root) {
     for (let dir = from;; dir = dirname(dir)) {
         const candidate = join(dir, "tsconfig.json");
@@ -170,8 +175,9 @@ 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 opt-in to node globals, which the realm has. With no base
-                // config there is nothing to opt in with, so it stays none.
+                // `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.
                 ...(base ? {} : { types: [] }),
             },
             files: group.flatMap((s) => [s.file, typesPathFor(s.file)]),
@@ -179,8 +185,9 @@ async function typecheck(sites) {
             // drag the author's whole tree in, to be checked under the worker lib.
             include: [],
         };
-        // Never written; anchors `@types` lookup at the root. Not `tsconfig.json`: that is often the
-        // base it extends, and tsc refuses a circular extends.
+        // Never written: the name only anchors `@types` lookup at the root. It must not be
+        // `tsconfig.json`: that is the base the config `extends` whenever the author keeps one at
+        // the root, and tsc refuses a config that extends its own path as circular.
         const parsed = ts.parseJsonConfigFileContent(config, ts.sys, root, undefined, join(root, "tsconfig.genroc.json"));
         const program = ts.createProgram({
             rootNames: parsed.fileNames,
@@ -226,9 +233,11 @@ const BUILTIN = new Set([
     ...builtinModules,
     ...builtinModules.map((m) => `node:${m}`),
 ]);
-/** 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. */
+/** 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. */
 function tsResolve(configPath) {
     let options = {};
     if (configPath) {
@@ -249,12 +258,14 @@ function tsResolve(configPath) {
         },
     };
 }
-/** A self-contained ES module whose default export is the author's own, unwrapped. Bundling here
- *  means a definition version pins its code forever. */
+/** 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. */
 async function bundle(at) {
     const site = at.site;
-    // Builtins are externalised; anything else unresolved is a REFUSAL, since rollup's default
-    // leaves an import that bundles clean and fails at runtime.
+    // 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.
     const built = await rollup({
         input: at.file,
         external: (id) => BUILTIN.has(id),
@@ -262,7 +273,8 @@ async function bundle(at) {
             tsResolve(await nearestTsconfig(dirname(at.file), root)),
             nodeResolve({ extensions: [".ts", ".tsx", ".mjs", ".js", ".json"] }),
             commonjs(),
-            // Inlines `.json` imports; without it rollup hands JSON to the JS parser.
+            // 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.
             json(),
             transpile,
         ],
@@ -312,10 +324,15 @@ const located = manifest.processes.flatMap((where) => where.sites.map((site) =>
     where,
     file: resolve(where.dir, site.argument),
 })));
-// 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.
+// 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.
 for (const at of located) {
-    // The action's kind is a field; where in it the directive sits is the pointer.
+    // 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.
     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") {
@@ -324,7 +341,8 @@ for (const at of located) {
             `${kind ? `a ${kind} task's ` : ""}\`${slot}\`.`);
     }
 }
-// genctl does not know the argument is a file, so this resolver reports a missing one.
+// 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.
 for (const at of located) {
     if (!existsSync(at.file)) {
         die(`${join(at.where.dir, at.where.file)}: ${address(at.site.pointer)}: ` +

package/dist/realm.js

@@ -1,5 +1,9 @@
-// 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.
+// 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.
 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) {
@@ -10,8 +14,9 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 };
 import { registerHooks } from "node:module";
 import { parentPort } from "node:worker_threads";
-// IMPORTED under our own URL rather than compiled from a string, so frames carry the author's
-// line numbers and builtin imports resolve normally.
+// 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.
 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
@@ -49,8 +54,9 @@ function safeText(v) {
         return String(v);
     }
 }
-/** 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. */
+/** 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. */
 function unloadable(err) {
     const code = err?.code;
     return err instanceof SyntaxError || (typeof code === "string" && code.startsWith("ERR_MODULE"));
@@ -91,8 +97,10 @@ async function run(req) {
         return { ok: false, failure: describe(err, "nonserializable") };
     }
 }
-// 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.
+// 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.
 function flush(stream) {
     return new Promise((resolve) => stream.write("", () => resolve()));
 }

package/dist/worker.js

@@ -1,18 +1,31 @@
 #!/usr/bin/env node
-// 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).
+// 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.
 import { readFileSync } from "node:fs";
 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}`;
-// 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.
+// 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.
 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}` } : {};
-// The worker claims only what it can run, so a backlog is a queue rather than threads fighting
-// over a core.
+// 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.
 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
@@ -21,15 +34,17 @@ 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 ?? "";
-// Large values arrive as refs; a bundle is one object per definition version, fetched once.
-// Refs are content hashes, so the cache never invalidates.
+// 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.
 const objectCache = new Map();
 async function fetchObject(ref) {
     const cached = objectCache.get(ref);
     if (cached !== undefined)
         return cached;
-    // Left to throw: a task whose input cannot be fetched must not run against a missing value.
-    // The caller releases the claim.
+    // 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.
     const res = await fetch(`${SERVER}/api/objects/${encodeURIComponent(ref)}`, { headers: authHeaders });
     if (!res.ok)
         throw new Error(`fetch object ${ref}: HTTP ${res.status}`);
@@ -69,8 +84,10 @@ async function resolveObjects(job) {
     return input;
 }
 async function call(path, body) {
-    // 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.
+    // 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.
     let res;
     try {
         res = await fetch(SERVER + path, {
@@ -92,8 +109,9 @@ async function call(path, body) {
     }
     return { ok: res.ok, status: res.status, data };
 }
-/** 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. */
+/** 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. */
 function asEvalRequest(input) {
     if (typeof input !== "object" || input === null)
         return "the task input is not an object";
@@ -108,8 +126,10 @@ function asEvalRequest(input) {
 }
 const inFlight = new Map();
 let running = true;
-// Announce reachability TRANSITIONS only: polling several times a second would otherwise emit
-// thousands of lines during a restart.
+// 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.
 let serverReachable = true;
 async function claim(n) {
     const { ok, status, data } = await call("/api/external-tasks/claim", {
@@ -120,15 +140,18 @@ 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 idle
-        // worker. Exit, so a supervisor restarts it visibly.
+        // 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.
         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 (see call): a restart or blip the next poll clears, so it is reported once.
+        // 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.
         if (status === 0) {
             if (serverReachable) {
                 serverReachable = false;
@@ -151,8 +174,10 @@ async function release(token) {
     if (!ok)
         console.error(`release failed: ${JSON.stringify(data)}`);
 }
-/** 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. */
+/** 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. */
 async function answer(token, outcome) {
     const { ok, data } = await call("/api/external-tasks/resolve", { token, ...outcome });
     if (ok)
@@ -184,15 +209,18 @@ async function run(job, signal) {
         result = await evaluate(req, signal);
     }
     catch (err) {
-        // 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.
+        // Cancelled is not a fault: the process was stopped while this ran. The claim still goes
+        // back — the row is terminal, so nothing re-claims it, and the release is what stops it
+        // waiting out a lease nobody is serving.
         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.
+        // 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.
         console.error(`evaluator fault on ${job.token}: ${err instanceof Error ? err.message : String(err)}`);
         await release(job.token);
         return;
@@ -227,13 +255,17 @@ async function renewLoop() {
         });
         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.
+        // Cancelled: the process was stopped, so the evaluation is abandoned and the claim handed
+        // back. Aborting first is the point of the list — waiting for the script to finish would
+        // keep burning a core on work an operator has already stopped. The release rides run()'s
+        // own 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.
+        // Lost: someone else holds this claim now. The work continues and its answer will be
+        // refused — that is not fixable here — but say so, because it is the signal that LEASE_MS
+        // is too short for what these scripts actually take. Deliberately NOT released: the claim
+        // is the new holder's, and releasing would bump the epoch out from under it.
         const lost = (data?.lost ?? []);
         if (lost.length) {
             console.error(`lost ${lost.length}/${tokens.length} claims; a lease lapsed under load`);

package/eval.ts

@@ -1,6 +1,11 @@
-// Imports a script module in its own realm (a Worker per execution, realm.ts), calls its default
-// export, and classifies every outcome (README.md). Only a killable thread bounds a synchronous
-// busy loop, which is what makes the budget real. Knows nothing of genroc; worker.ts does.
+// Evaluation core: import a script module in its OWN realm, call its default export, and
+// classify every outcome into one of the failure kinds in README.md. Nothing here knows about
+// genroc — worker.ts is the only thing that talks to the queue — so this stays testable and
+// the containment stays swappable.
+//
+// The containment is a Worker per execution (realm.ts). It is what makes the budget real:
+// a synchronous busy loop never yields, so no in-process timer can interrupt it, and only a
+// thread the host can kill bounds it.
 
 import { Worker } from "node:worker_threads";
 
@@ -11,8 +16,9 @@ export type EvalRequest = {
   timeout_ms?: number;
 };
 
-/** Every kind is PERMANENT: a retry fails identically. A faulting runner is not an outcome; it
- *  releases its claim. */
+/** Every kind here is PERMANENT: a retry re-runs the same code on the same input and fails
+ *  identically. The retryable class has no kind because it is not an outcome — a runner that
+ *  faults releases its claim and lets another worker take the task. */
 export type FailureKind = "compile_error" | "threw" | "timeout" | "nonserializable" | "exited";
 
 export type EvalFailure = {
@@ -22,8 +28,9 @@ export type EvalFailure = {
   stack?: string;
 };
 
-/** JSON TEXT serialised in the realm, so a nonserializable return is a script fault, not a 500,
- *  and structured clone (which refuses a different set of values) never sees the value. */
+/** `body` is JSON TEXT, not a value: serialising in the realm is what makes a nonserializable
+ *  return a script fault rather than a 500 thrown out of the response path. It is also what
+ *  crosses the worker boundary — structured clone would refuse a different set of values. */
 export type EvalResult =
   | { ok: true; body: string }
   | { ok: false; failure: EvalFailure };
@@ -40,8 +47,9 @@ const REALM_URL = new URL(
   import.meta.url,
 );
 
-/** Thrown, not returned: a realm that fails to start is the runner faulting, which worker.ts
- *  answers by releasing the claim. */
+/** Thrown, not returned: a realm that fails to start is the RUNNER faulting, which worker.ts
+ *  answers by releasing the claim rather than by reporting an outcome. A script fault is a
+ *  return value. */
 class RealmFault extends Error {
   constructor(message: string) {
     super(message);
@@ -49,8 +57,9 @@ class RealmFault extends Error {
   }
 }
 
-/** Thrown when `signal` aborts: the answer is no longer wanted, so worker.ts releases rather
- *  than answers. Not a RealmFault: nothing is wrong. */
+/** Thrown when `signal` aborts: the work was cancelled server-side, so there is no outcome to
+ *  report and worker.ts must release rather than answer. Distinct from RealmFault because the
+ *  runner did not fault -- nothing is wrong, the answer is simply no longer wanted. */
 export class Cancelled extends Error {
   constructor() {
     super("cancelled");
@@ -75,8 +84,9 @@ export async function evaluate(req: EvalRequest, signal?: AbortSignal): Promise<
         signal.addEventListener("abort", onAbort, { once: true });
       }
       worker.once("message", (reply: WorkerReply) => resolve(reply));
-      // A script may `process.exit()`, which would otherwise look like a hang until the budget.
-      // Our own terminate() fires this too, after the promise has settled.
+      // A script may end its own realm (`process.exit()`), which is not a throw and would
+      // otherwise present as a hang until the budget expired. Our own terminate() raises
+      // this too, by which time the promise has settled and the first result stands.
       worker.once("exit", (code: number) => resolve(exited(code)));
       worker.once("error", (err: Error) => reject(new RealmFault(errorText(err))));
       worker.postMessage({ code: req.code, input: req.input } satisfies WorkerRequest);

package/import.ts

@@ -1,7 +1,11 @@
 #!/usr/bin/env node
-// The code-phase resolver: manifest on stdin, `{"code": [...]}` on stdout, diagnostic on stderr
-// with a non-zero exit (specs/source-resolution.md). Two modes share one `tsc` pass: "types"
-// writes declarations only, "build" typechecks and bundles.
+// 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 { existsSync } from "node:fs";
 import { access, writeFile } from "node:fs/promises";
@@ -190,8 +194,9 @@ function typesPathFor(scriptPath: string): string {
 
 // ── typecheck ──────────────────────────────────────────────────────────────────
 
-/** The tsconfig the author's editor reads, so editor and apply agree. Stops at the project
- *  root. */
+/** 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. */
 async function nearestTsconfig(
   from: string,
   root: string,
@@ -228,8 +233,9 @@ async function typecheck(sites: Located[]): Promise<void> {
         // `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 opt-in to node globals, which the realm has. With no base
-        // config there is nothing to opt in with, so it stays none.
+        // `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.
         ...(base ? {} : { types: [] }),
       },
       files: group.flatMap((s) => [s.file, typesPathFor(s.file)]),
@@ -237,8 +243,9 @@ async function typecheck(sites: Located[]): Promise<void> {
       // drag the author's whole tree in, to be checked under the worker lib.
       include: [],
     };
-    // Never written; anchors `@types` lookup at the root. Not `tsconfig.json`: that is often the
-    // base it extends, and tsc refuses a circular extends.
+    // Never written: the name only anchors `@types` lookup at the root. It must not be
+    // `tsconfig.json`: that is the base the config `extends` whenever the author keeps one at
+    // the root, and tsc refuses a config that extends its own path as circular.
     const parsed = ts.parseJsonConfigFileContent(
       config,
       ts.sys,
@@ -296,9 +303,11 @@ const BUILTIN = new Set([
   ...builtinModules.map((m) => `node:${m}`),
 ]);
 
-/** 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. */
+/** 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. */
 function tsResolve(configPath: string | null): Plugin {
   let options: ts.CompilerOptions = {};
   if (configPath) {
@@ -328,12 +337,14 @@ function tsResolve(configPath: string | null): Plugin {
   };
 }
 
-/** A self-contained ES module whose default export is the author's own, unwrapped. Bundling here
- *  means a definition version pins its code forever. */
+/** 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. */
 async function bundle(at: Located): Promise<string> {
   const site = at.site;
-  // Builtins are externalised; anything else unresolved is a REFUSAL, since rollup's default
-  // leaves an import that bundles clean and fails at runtime.
+  // 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.
   const built = await rollup({
     input: at.file,
     external: (id) => BUILTIN.has(id),
@@ -341,7 +352,8 @@ async function bundle(at: Located): Promise<string> {
       tsResolve(await nearestTsconfig(dirname(at.file), root)),
       nodeResolve({ extensions: [".ts", ".tsx", ".mjs", ".js", ".json"] }),
       commonjs(),
-      // Inlines `.json` imports; without it rollup hands JSON to the JS parser.
+      // 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.
       json(),
       transpile,
     ],
@@ -384,8 +396,10 @@ const root = process.cwd();
 if (!manifest || !Array.isArray(manifest.processes))
   die("stdin is not a genroc resolver manifest");
 
-/** Sites in manifest order, the order `code` must answer in. The argument is joined to the
- *  definition's directory here: only this resolver knows it is a path. */
+/** Every site with the process it sits in and the file its argument names, in the manifest's own
+ *  order — which is the order `code` must answer in. genctl passes the argument verbatim, so
+ *  joining it to the definition's directory is this resolver's business: only it knows the
+ *  argument is a path at all. */
 type Located = { site: Site; where: ManifestProcess; file: string };
 
 /** A pointer as the address it is, so a generated comment or an error can be pasted into
@@ -408,10 +422,15 @@ const located: Located[] = manifest.processes.flatMap((where) =>
   })),
 );
 
-// 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.
+// 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.
 for (const at of located) {
-  // The action's kind is a field; where in it the directive sits is the pointer.
+  // 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.
   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") {
@@ -423,7 +442,8 @@ for (const at of located) {
   }
 }
 
-// genctl does not know the argument is a file, so this resolver reports a missing one.
+// 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.
 for (const at of located) {
   if (!existsSync(at.file)) {
     die(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genroc/eval-node",
-  "version": "0.0.0-edge.627a84e1",
+  "version": "0.0.0-edge.63f3718c",
   "type": "module",
   "engines": {
     "node": ">=24"

package/realm.ts

@@ -1,13 +1,18 @@
-// 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.
+// 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.
 
 import { registerHooks } from "node:module";
 import { parentPort } from "node:worker_threads";
 
 import type { EvalFailure, FailureKind, WorkerReply, WorkerRequest } from "./eval.ts";
 
-// IMPORTED under our own URL rather than compiled from a string, so frames carry the author's
-// line numbers and builtin imports resolve normally.
+// 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.
 const SCRIPT_URL = "script:main";
 const STACK_BYTES = 2_048;
 
@@ -49,8 +54,9 @@ function safeText(v: unknown): string {
   }
 }
 
-/** 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. */
+/** 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. */
 function unloadable(err: unknown): boolean {
   const code = (err as { code?: unknown } | null)?.code;
   return err instanceof SyntaxError || (typeof code === "string" && code.startsWith("ERR_MODULE"));
@@ -93,8 +99,10 @@ async function run(req: WorkerRequest): Promise<WorkerReply> {
   }
 }
 
-// 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.
+// 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.
 function flush(stream: NodeJS.WriteStream): Promise<void> {
   return new Promise((resolve) => stream.write("", () => resolve()));
 }

package/worker.ts

@@ -1,21 +1,34 @@
 #!/usr/bin/env node
-// 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).
+// 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.
 
 import { readFileSync } from "node:fs";
 import { Cancelled, evaluate, type EvalRequest, type FailureKind } from "./eval.ts";
 
 const SERVER = (process.env.GENROC_SERVER ?? "http://localhost:8448").replace(/\/$/, "");
 const WORKER_ID = process.env.WORKER_ID ?? `evaluator-${process.pid}`;
-// 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.
+// 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.
 const TOKEN =
   process.env.GENROC_TOKEN ??
   (process.env.GENROC_TOKEN_FILE ? readFileSync(process.env.GENROC_TOKEN_FILE, "utf8").trim() : "");
 const authHeaders: Record<string, string> = TOKEN ? { authorization: `Bearer ${TOKEN}` } : {};
-// The worker claims only what it can run, so a backlog is a queue rather than threads fighting
-// over a core.
+// 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.
 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
@@ -36,15 +49,17 @@ type QueueTask = {
   raises?: Record<string, unknown>;
 };
 
-// Large values arrive as refs; a bundle is one object per definition version, fetched once.
-// Refs are content hashes, so the cache never invalidates.
+// 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.
 const objectCache = new Map<string, unknown>();
 
 async function fetchObject(ref: string): Promise<unknown> {
   const cached = objectCache.get(ref);
   if (cached !== undefined) return cached;
-  // Left to throw: a task whose input cannot be fetched must not run against a missing value.
-  // The caller releases the claim.
+  // 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.
   const res = await fetch(`${SERVER}/api/objects/${encodeURIComponent(ref)}`, { headers: authHeaders });
   if (!res.ok) throw new Error(`fetch object ${ref}: HTTP ${res.status}`);
   const { data } = (await res.json()) as { data: string };
@@ -82,8 +97,10 @@ async function resolveObjects(job: QueueTask): Promise<unknown> {
 }
 
 async function call(path: string, body: unknown): Promise<{ ok: boolean; status: number; data: any }> {
-  // 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.
+  // 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.
   let res: Response;
   try {
     res = await fetch(SERVER + path, {
@@ -104,8 +121,9 @@ async function call(path: string, body: unknown): Promise<{ ok: boolean; status:
   return { ok: res.ok, status: res.status, data };
 }
 
-/** 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. */
+/** 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. */
 function asEvalRequest(input: unknown): EvalRequest | string {
   if (typeof input !== "object" || input === null) return "the task input is not an object";
   const r = input as Record<string, unknown>;
@@ -117,15 +135,18 @@ function asEvalRequest(input: unknown): EvalRequest | string {
   };
 }
 
-/** genroc cannot call us, so a cancellation arrives on our own heartbeat and reaches the
- *  evaluation through the controller. */
+/** A claim this worker is currently serving. The controller is how the renewal loop reaches
+ *  the evaluation: genroc cannot call us, so a cancellation arrives as an answer to our own
+ *  heartbeat and has to be delivered inward from there. */
 type Running = { job: QueueTask; abort: AbortController };
 
 const inFlight = new Map<string, Running>();
 let running = true;
 
-// Announce reachability TRANSITIONS only: polling several times a second would otherwise emit
-// thousands of lines during a restart.
+// 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.
 let serverReachable = true;
 
 async function claim(n: number): Promise<QueueTask[]> {
@@ -137,8 +158,9 @@ async function claim(n: number): Promise<QueueTask[]> {
     ...(TASK_FILTER ? { task: TASK_FILTER } : {}),
   });
   if (!ok) {
-    // A credential problem is not transient, and polling through it looks like a healthy idle
-    // worker. Exit, so a supervisor restarts it visibly.
+    // 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.
     if (status === 401 || status === 403) {
       console.error(
         `claim rejected (${status}): ${JSON.stringify(data)}\n` +
@@ -147,7 +169,9 @@ async function claim(n: number): Promise<QueueTask[]> {
       );
       process.exit(1);
     }
-    // status 0 (see call): a restart or blip the next poll clears, so it is reported once.
+    // 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.
     if (status === 0) {
       if (serverReachable) {
         serverReachable = false;
@@ -173,8 +197,10 @@ async function release(token: string): Promise<void> {
   if (!ok) console.error(`release failed: ${JSON.stringify(data)}`);
 }
 
-/** 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. */
+/** 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. */
 async function answer(token: string, outcome: Record<string, unknown>): Promise<void> {
   const { ok, data } = await call("/api/external-tasks/resolve", { token, ...outcome });
   if (ok) return;
@@ -205,15 +231,18 @@ async function run(job: QueueTask, signal: AbortSignal): Promise<void> {
   try {
     result = await evaluate(req, signal);
   } catch (err) {
-    // 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.
+    // Cancelled is not a fault: the process was stopped while this ran. The claim still goes
+    // back — the row is terminal, so nothing re-claims it, and the release is what stops it
+    // waiting out a lease nobody is serving.
     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.
+    // 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.
     console.error(`evaluator fault on ${job.token}: ${err instanceof Error ? err.message : String(err)}`);
     await release(job.token);
     return;
@@ -249,13 +278,17 @@ async function renewLoop(): Promise<void> {
     });
     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.
+    // Cancelled: the process was stopped, so the evaluation is abandoned and the claim handed
+    // back. Aborting first is the point of the list — waiting for the script to finish would
+    // keep burning a core on work an operator has already stopped. The release rides run()'s
+    // own catch, so nothing is released twice.
     for (const token of (data?.cancelled ?? []) as string[]) {
       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.
+    // Lost: someone else holds this claim now. The work continues and its answer will be
+    // refused — that is not fixable here — but say so, because it is the signal that LEASE_MS
+    // is too short for what these scripts actually take. Deliberately NOT released: the claim
+    // is the new holder's, and releasing would bump the epoch out from under it.
     const lost = (data?.lost ?? []) as string[];
     if (lost.length) {
       console.error(`lost ${lost.length}/${tokens.length} claims; a lease lapsed under load`);