@genroc/eval-node 0.0.0-edge.aff7b37 → 0.0.0-edge.ca3207b

package/dist/realm.js

@@ -0,0 +1,113 @@
+// 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) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+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.
+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
+// evaluates one script and is then discarded, so no second execution can observe it.
+let source = "";
+registerHooks({
+    resolve: (specifier, context, next) => specifier === SCRIPT_URL ? { url: SCRIPT_URL, shortCircuit: true } : next(specifier, context),
+    load: (url, context, next) => url === SCRIPT_URL ? { format: "module", source, shortCircuit: true } : next(url, context),
+});
+/** Keeps the frames that are the script's own. Everything below the last of them is runner
+ *  plumbing the author cannot act on, and V8 puts this file's path in it. */
+function scriptStack(err) {
+    if (!(err instanceof Error) || typeof err.stack !== "string")
+        return undefined;
+    const lines = err.stack.split("\n");
+    let last = 0;
+    for (let i = 0; i < lines.length; i++)
+        if (lines[i].includes(SCRIPT_URL))
+            last = i;
+    const stack = lines.slice(0, last + 1).join("\n");
+    return stack.length > STACK_BYTES ? stack.slice(0, STACK_BYTES) : stack;
+}
+function describe(err, kind) {
+    if (err instanceof Error) {
+        return { kind, name: err.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) };
+}
+function safeText(v) {
+    try {
+        return typeof v === "string" ? v : JSON.stringify(v) ?? String(v);
+    }
+    catch {
+        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. */
+function unloadable(err) {
+    const code = err?.code;
+    return err instanceof SyntaxError || (typeof code === "string" && code.startsWith("ERR_MODULE"));
+}
+async function run(req) {
+    source = req.code;
+    let main;
+    try {
+        main = (await import(__rewriteRelativeImportExtension(SCRIPT_URL))).default;
+    }
+    catch (err) {
+        return { ok: false, failure: describe(err, unloadable(err) ? "compile_error" : "threw") };
+    }
+    if (typeof main !== "function") {
+        const got = main === undefined ? "no default export" : `a ${typeof main}`;
+        return {
+            ok: false,
+            failure: {
+                kind: "compile_error",
+                name: "NoDefaultExport",
+                message: `a script must export default a function; this one has ${got}`,
+            },
+        };
+    }
+    let value;
+    try {
+        value = await main(req.input);
+    }
+    catch (err) {
+        return { ok: false, failure: describe(err, "threw") };
+    }
+    try {
+        // undefined stringifies to undefined, not "undefined"; an empty body is how genroc
+        // spells null, which is the right reading of a script that returned nothing.
+        return { ok: true, body: value === undefined ? "" : JSON.stringify(value) ?? "" };
+    }
+    catch (err) {
+        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.
+function flush(stream) {
+    return new Promise((resolve) => stream.write("", () => resolve()));
+}
+// Non-null because this module only ever runs as a worker entry point; a null port here
+// would mean eval.ts loaded it as a plain module, which nothing does.
+parentPort.on("message", async (req) => {
+    const reply = await run(req);
+    await Promise.all([flush(process.stdout), flush(process.stderr)]);
+    parentPort.postMessage(reply);
+});

package/dist/worker.js

@@ -0,0 +1,285 @@
+#!/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.
+import { readFileSync } from "node:fs";
+import { 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.
+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.
+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
+// should return its task quickly rather than holding it for the whole budget.
+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.
+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.
+    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());
+    let value;
+    try {
+        value = JSON.parse(data);
+    }
+    catch {
+        value = data;
+    }
+    objectCache.set(ref, value);
+    return value;
+}
+/** 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;
+    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;
+        if (rest.length === 0) {
+            input = value;
+            continue;
+        }
+        let cur = input;
+        for (let i = 0; i < rest.length - 1; i++)
+            cur = cur?.[rest[i]];
+        if (cur)
+            cur[rest[rest.length - 1]] = value;
+    }
+    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.
+    let res;
+    try {
+        res = await fetch(SERVER + path, {
+            method: "POST",
+            headers: { "content-type": "application/json", ...authHeaders },
+            body: JSON.stringify(body),
+        });
+    }
+    catch (err) {
+        return { ok: false, status: 0, data: { error: `${SERVER} unreachable: ${err.message}` } };
+    }
+    const text = await res.text();
+    let data = null;
+    try {
+        data = text ? JSON.parse(text) : null;
+    }
+    catch {
+        data = { error: text };
+    }
+    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. */
+function asEvalRequest(input) {
+    if (typeof input !== "object" || input === null)
+        return "the task input is not an object";
+    const r = input;
+    if (typeof r.code !== "string")
+        return "the task input has no `code` string";
+    return {
+        code: r.code,
+        input: r.input,
+        timeout_ms: typeof r.timeout_ms === "number" ? r.timeout_ms : undefined,
+    };
+}
+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.
+let serverReachable = true;
+async function claim(n) {
+    const { ok, status, data } = await call("/api/external-tasks/claim", {
+        worker_id: WORKER_ID,
+        limit: n,
+        lease_ms: LEASE_MS,
+        ...(PROCESS_FILTER ? { process: PROCESS_FILTER } : {}),
+        ...(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.
+        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.
+        if (status === 0) {
+            if (serverReachable) {
+                serverReachable = false;
+                console.error(`genroc at ${SERVER} is unreachable — ${data?.error ?? ""}. ` +
+                    `Still polling every ${POLL_MS}ms; work resumes when it comes back.`);
+            }
+            return [];
+        }
+        console.error(`claim failed: ${JSON.stringify(data)}`);
+        return [];
+    }
+    if (!serverReachable) {
+        serverReachable = true;
+        console.error(`genroc at ${SERVER} is reachable again — resuming.`);
+    }
+    return (data?.items ?? []);
+}
+async function release(token) {
+    const { ok, data } = await call("/api/external-tasks/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. */
+async function answer(token, outcome) {
+    const { ok, data } = await call("/api/external-tasks/resolve", { token, ...outcome });
+    if (ok)
+        return;
+    console.error(`genroc refused the outcome for ${token}: ${JSON.stringify(data)}`);
+    await release(token);
+}
+async function run(job) {
+    let resolved;
+    try {
+        resolved = await resolveObjects(job);
+    }
+    catch (err) {
+        // The values are there or they are not; this is the runner failing to read them, not the
+        // script failing, so hand the task back for someone else rather than reporting an outcome.
+        console.error(`resolving objects for ${job.token}: ${err instanceof Error ? err.message : String(err)}`);
+        await release(job.token);
+        return;
+    }
+    const req = asEvalRequest(resolved);
+    if (typeof req === "string") {
+        await answer(job.token, {
+            error: { code: "compile_error", message: req, data: { name: "BadTaskInput" } },
+        });
+        return;
+    }
+    let result;
+    try {
+        result = await evaluate(req);
+    }
+    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.
+        console.error(`evaluator fault on ${job.token}: ${err instanceof Error ? err.message : String(err)}`);
+        await release(job.token);
+        return;
+    }
+    if (result.ok) {
+        // `body` is JSON text produced inside the realm; an empty body is a script that returned
+        // nothing, which genroc reads as null.
+        await answer(job.token, { result: result.body === "" ? null : JSON.parse(result.body) });
+        return;
+    }
+    const f = result.failure;
+    await answer(job.token, {
+        error: {
+            // The failure KIND is the code, so an on_error rule branches on what went wrong without
+            // reading a payload. Every kind is permanent; see eval.ts.
+            code: f.kind,
+            message: f.message,
+            data: { name: f.name, ...(f.stack ? { stack: f.stack } : {}) },
+        },
+    });
+}
+async function renewLoop() {
+    while (running) {
+        await new Promise((r) => setTimeout(r, RENEW_MS));
+        const tokens = [...inFlight.keys()];
+        if (!tokens.length)
+            continue;
+        const { ok, data } = await call("/api/external-tasks/renew", {
+            worker_id: WORKER_ID,
+            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`);
+        }
+    }
+}
+async function pollLoop() {
+    while (running) {
+        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));
+        }
+        // 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.
+        if (jobs.length === 0)
+            await new Promise((r) => setTimeout(r, POLL_MS));
+    }
+}
+async function shutdown(signal) {
+    if (!running)
+        return;
+    running = false;
+    const tokens = [...inFlight.keys()];
+    console.log(`${signal}: releasing ${tokens.length} claim(s)`);
+    // Hand work back rather than letting it sit out its lease. The evaluations still running are
+    // abandoned, which is exactly what the release says: nobody answered.
+    await Promise.all(tokens.map(release));
+    process.exit(0);
+}
+process.on("SIGINT", () => void shutdown("SIGINT"));
+process.on("SIGTERM", () => void shutdown("SIGTERM"));
+console.log(`evaluator worker ${WORKER_ID} polling ${SERVER} (concurrency=${CONCURRENCY}, lease=${LEASE_MS}ms)`);
+void renewLoop();
+void pollLoop();

package/eval.ts

@@ -1,6 +1,7 @@
-// Evaluation core: run a code string in its OWN realm 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.
+// 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
@@ -9,6 +10,7 @@
 import { Worker } from "node:worker_threads";
 
 export type EvalRequest = {
+  /** An ES module whose default export is the function to run; `input` is its argument. */
   code: string;
   input?: unknown;
   timeout_ms?: number;
@@ -38,7 +40,12 @@ export type WorkerRequest = { code: string; input?: unknown };
 export type WorkerReply = EvalResult;
 
 const DEFAULT_TIMEOUT_MS = 5_000;
-const REALM_URL = new URL("./realm.ts", import.meta.url);
+// 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 rather than by reporting an outcome. A script fault is a

package/import.ts

@@ -1,3 +1,4 @@
+#!/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.
@@ -71,13 +72,16 @@ function tsType(s: Schema | undefined, used: Set<string>): string {
   if (Array.isArray(s.enum)) {
     return s.enum.map((v: unknown) => JSON.stringify(v)).join(" | ") || "never";
   }
-  if (Array.isArray(s.anyOf)) return union(s.anyOf.map((a: Schema) => tsType(a, used)));
-  if (Array.isArray(s.oneOf)) return union(s.oneOf.map((a: Schema) => tsType(a, used)));
+  if (Array.isArray(s.anyOf))
+    return union(s.anyOf.map((a: Schema) => tsType(a, used)));
+  if (Array.isArray(s.oneOf))
+    return union(s.oneOf.map((a: Schema) => tsType(a, used)));
   if (Array.isArray(s.allOf)) {
     return s.allOf.map((a: Schema) => tsType(a, used)).join(" & ") || "unknown";
   }
 
-  const types: string[] = s.type === undefined ? [] : Array.isArray(s.type) ? s.type : [s.type];
+  const types: string[] =
+    s.type === undefined ? [] : Array.isArray(s.type) ? s.type : [s.type];
   if (types.length === 0) {
     // The top type: `{}` means unknown, not "an empty object". specs/unknown-type.md.
     return s.properties ? objectType(s, used) : "unknown";
@@ -110,8 +114,13 @@ function objectType(s: Schema, used: Set<string>): string {
   const required = new Set<string>(s.required ?? []);
   const lines: string[] = [];
   for (const [key, sub] of Object.entries(props)) {
-    const doc = typeof sub.description === "string" ? `  /** ${sub.description} */\n` : "";
-    lines.push(`${doc}  ${propKey(key)}${required.has(key) ? "" : "?"}: ${tsType(sub, used)};`);
+    const doc =
+      typeof sub.description === "string"
+        ? `  /** ${sub.description} */\n`
+        : "";
+    lines.push(
+      `${doc}  ${propKey(key)}${required.has(key) ? "" : "?"}: ${tsType(sub, used)};`,
+    );
   }
   if (s.additionalProperties && typeof s.additionalProperties === "object") {
     lines.push(`  [key: string]: ${tsType(s.additionalProperties, used)};`);
@@ -127,9 +136,13 @@ function union(parts: string[]): string {
 
 const IDENT = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 const propKey = (k: string) => (IDENT.test(k) ? k : JSON.stringify(k));
-const identifier = (n: string) => (IDENT.test(n) ? n : `Def_${n.replace(/[^A-Za-z0-9_$]/g, "_")}`);
+const identifier = (n: string) =>
+  IDENT.test(n) ? n : `Def_${n.replace(/[^A-Za-z0-9_$]/g, "_")}`;
 
-function deref(s: Schema | undefined, defs: Record<string, Schema>): Schema | undefined {
+function deref(
+  s: Schema | undefined,
+  defs: Record<string, Schema>,
+): Schema | undefined {
   let cur = s;
   for (let i = 0; cur && typeof cur.$ref === "string" && i < 16; i++) {
     cur = defs[cur.$ref.replace(/^#\/\$defs\//, "")];
@@ -141,7 +154,10 @@ function deref(s: Schema | undefined, defs: Record<string, Schema>): Schema | un
  *  `{code, input, timeout_ms, …}`, and only its `input` field is bound as the script's
  *  parameter. genroc cannot know that; this file owns the evaluator's wire contract, so
  *  the navigation belongs here rather than in genctl. */
-function scriptInput(site: Site, defs: Record<string, Schema>): Schema | undefined {
+function scriptInput(
+  site: Site,
+  defs: Record<string, Schema>,
+): Schema | undefined {
   const action = deref(site.input, defs);
   const bound = action?.properties?.input;
   return bound ?? site.input;
@@ -188,7 +204,10 @@ function typesPathFor(scriptPath: string): string {
 /** 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): Promise<string | null> {
+async function nearestTsconfig(
+  from: string,
+  root: string,
+): Promise<string | null> {
   for (let dir = from; ; dir = dirname(dir)) {
     const candidate = join(dir, "tsconfig.json");
     if (await exists(candidate)) return candidate;
@@ -231,12 +250,18 @@ async function typecheck(root: string, sites: Site[]): Promise<void> {
         // base config there is nothing to opt in with, so the default stays none.
         ...(base ? {} : { types: [] }),
       },
-      files: group.flatMap((s) => [relative(dir, s.path), relative(dir, typesPathFor(s.path))]),
+      files: group.flatMap((s) => [
+        relative(dir, s.path),
+        relative(dir, typesPathFor(s.path)),
+      ]),
       // `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`);
+    const configPath = join(
+      dir,
+      groups.size === 1 ? "tsconfig.json" : `tsconfig.${n++}.json`,
+    );
     await write(configPath, JSON.stringify(config, null, 2));
     await runTsc(root, configPath);
   }
@@ -284,7 +309,10 @@ const transpile: Plugin = {
   },
 };
 
-const BUILTIN = new Set([...builtinModules, ...builtinModules.map((m) => `node:${m}`)]);
+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
@@ -295,25 +323,37 @@ function tsResolve(configPath: string | null): Plugin {
   let options: ts.CompilerOptions = {};
   if (configPath) {
     const read = ts.readConfigFile(configPath, ts.sys.readFile);
-    options = ts.parseJsonConfigFileContent(read.config ?? {}, ts.sys, dirname(configPath)).options;
+    options = ts.parseJsonConfigFileContent(
+      read.config ?? {},
+      ts.sys,
+      dirname(configPath),
+    ).options;
   }
   return {
     name: "genroc-ts-resolve",
     resolveId(source, importer) {
       if (!importer || BUILTIN.has(source)) return null;
-      const { resolvedModule } = ts.resolveModuleName(source, importer, options, ts.sys);
-      if (!resolvedModule || resolvedModule.isExternalLibraryImport) return null;
-      return resolvedModule.resolvedFileName.endsWith(".d.ts") ? null : resolvedModule.resolvedFileName;
+      const { resolvedModule } = ts.resolveModuleName(
+        source,
+        importer,
+        options,
+        ts.sys,
+      );
+      if (!resolvedModule || resolvedModule.isExternalLibraryImport)
+        return null;
+      return resolvedModule.resolvedFileName.endsWith(".d.ts")
+        ? null
+        : resolvedModule.resolvedFileName;
     },
   };
 }
 
-/** Bundles to CJS and wraps it as an async function BODY, which is what /eval compiles.
- *  The runtime stays unchanged: bundling is entirely the importer's job, and the string it
- *  produces is self-contained, so 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(site: Site, root: string): Promise<string> {
-  // Builtins are EXTERNALISED as `require` calls that worker.ts satisfies. Anything else
-  // unresolved is a REFUSAL, not an external: rollup's default is to leave it as a require
+  // 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: site.path,
@@ -329,23 +369,26 @@ async function bundle(site: Site, root: string): Promise<string> {
     ],
     onwarn(warning) {
       if (warning.code === "UNRESOLVED_IMPORT") {
-        die(`${site.path}: cannot resolve ${warning.exporter ?? "an import"} — is it installed?`);
+        die(
+          `${site.path}: cannot resolve ${warning.exporter ?? "an import"} — is it installed?`,
+        );
       }
     },
-  }).catch((e: unknown) => die(`${site.path}: ${e instanceof Error ? e.message : String(e)}`));
+  }).catch((e: unknown) =>
+    die(`${site.path}: ${e instanceof Error ? e.message : String(e)}`),
+  );
 
-  const { output } = await built.generate({ format: "cjs", exports: "auto", inlineDynamicImports: true });
+  const { output } = await built.generate({
+    format: "es",
+    inlineDynamicImports: true,
+  });
   await built.close();
-  const cjs = output[0].code;
-  return [
-    "var module = { exports: {} }, exports = module.exports;",
-    cjs,
-    "var __genroc_main = module.exports.default ?? module.exports;",
-    'if (typeof __genroc_main !== "function") {',
-    `  throw new Error(${JSON.stringify(`${site.path} has no default export function`)});`,
-    "}",
-    "return await __genroc_main(input);",
-  ].join("\n");
+  // Refused here rather than in the realm: the evaluator can only report it against a running
+  // instance, and the file it names is on this machine.
+  if (!output[0].exports.includes("default")) {
+    die(`${site.path}: a script must \`export default\` the function to run`);
+  }
+  return output[0].code;
 }
 
 // ── main ───────────────────────────────────────────────────────────────────────
@@ -358,14 +401,16 @@ const stdin: string = await new Promise((resolve, reject) => {
   process.stdin.on("error", reject);
 });
 const manifest = JSON.parse(stdin) as Manifest;
-if (!manifest || !Array.isArray(manifest.sites)) die("stdin is not a genroc resolver manifest");
+if (!manifest || !Array.isArray(manifest.sites))
+  die("stdin is not a genroc resolver manifest");
 
 // One script at two sites with different input types is a refusal, not a union: the union
 // is sound and would typecheck a body that is wrong at one of the sites.
 const byPath = new Map<string, Site>();
 for (const site of manifest.sites) {
   const seen = byPath.get(site.path);
-  const defsOf = (x: Site) => (manifest.schemas[x.process]?.$defs ?? {}) as Record<string, Schema>;
+  const defsOf = (x: Site) =>
+    (manifest.schemas[x.process]?.$defs ?? {}) as Record<string, Schema>;
   if (
     seen &&
     JSON.stringify(scriptInput(seen, defsOf(seen))) !==
@@ -380,7 +425,10 @@ for (const site of manifest.sites) {
 }
 
 for (const site of byPath.values()) {
-  const defs = (manifest.schemas[site.process]?.$defs ?? {}) as Record<string, Schema>;
+  const defs = (manifest.schemas[site.process]?.$defs ?? {}) as Record<
+    string,
+    Schema
+  >;
   await write(typesPathFor(site.path), declarations(site, defs));
 }