@genroc/eval-node 0.0.0-edge.86dae06 → 0.0.0-edge.939198f

package/README.md

@@ -96,15 +96,18 @@ The `input` of the external task IS the evaluation request:
 
 ```jsonc
 {
-  "code": "return { fee: input.amount * 0.1 };",  // required — an async function body
-  "input": { "amount": 250 },                     // optional — bound as `input`
-  "timeout_ms": 5000                              // optional — default 5000
+  "code": "export default (input) => ({ fee: input.amount * 0.1 });",  // required — a module
+  "input": { "amount": 250 },                                         // optional — its argument
+  "timeout_ms": 5000                                                  // optional — default 5000
 }
 ```
 
-`code` is the **body of an async function**, so `await` works and the value reaches genroc
-through `return`. It is compiled with `input` and `require` as parameters, under
-`"use strict"` — `require` is what a bundled `import` of a node builtin lands on.
+`code` is an **ES module**, and the evaluator imports it and calls its **default export** with
+`input`. The value it returns reaches genroc; the function may be async, and so may the module's
+top level. A module exporting anything else — or nothing — is a `compile_error`: there is
+nothing to call, and so is one that will not parse; a throw from its top level is a `threw`
+like any other. `import` of a node builtin resolves as it does anywhere else, and that is what
+a bundled builtin lands on.
 
 ## The answer — the failure kind IS the error code
 
@@ -140,12 +143,14 @@ no retry policy to write.
     type: external
     input:
       code: |
-        if (input.amount > 100) {
-          const e = new Error('amount over the limit');
-          e.name = 'LimitExceeded';
-          throw e;
+        export default function (input) {
+          if (input.amount > 100) {
+            const e = new Error('amount over the limit');
+            e.name = 'LimitExceeded';
+            throw e;
+          }
+          return { fee: input.amount * 0.1 };
         }
-        return { fee: input.amount * 0.1 };
       input: "$: input"
     result_schema: { type: object, properties: { fee: { type: number } }, required: [fee] }
     raises:
@@ -164,7 +169,7 @@ no retry policy to write.
 
 - id: script_failed
   switch:
-    - case: 'error.data.name == "LimitExceeded"'
+    - case: 'last_error.data.name == "LimitExceeded"'
       raise: { code: limit_exceeded, message: "the script rejected the amount" }
     - raise: { code: script_failed, message: "the script failed" }
 ```
@@ -227,12 +232,14 @@ the inferred type of what the definition passes; `Output` is what it declares
 `tsc --noEmit`, and bundles — so **a type error is a failed apply**, and a stored definition
 cannot hold code that failed to typecheck.
 
-The bundle is emitted as CJS and wrapped as a function body, so the evaluator needs to know
-nothing about modules. Imports resolve through TypeScript under the same config the check
-ran with, so a `paths` alias that typechecks also bundles. They are inlined at build time, so the string a
-definition version stores is self-contained forever — with one exception: **node builtins
-stay as `require` calls**, which the realm satisfies. A package is frozen into the
-definition; `node:fs` is resolved by whatever runner executes it.
+The bundle is one self-contained ES module whose default export is the author's own — nothing
+wraps or rewrites it, so what the editor checks and what the realm runs are the same module, and
+**a missing default export is a failed apply** rather than a fault at run time. Imports resolve
+through TypeScript under the same config the check ran with, so a `paths` alias that typechecks
+also bundles. They are inlined at build time, so the string a definition version stores is
+self-contained forever — with one exception: **node builtins stay as imports**, which the realm
+resolves. A package is frozen into the definition; `node:fs` is resolved by whatever runner
+executes it.
 
 ### Your tsconfig, your types
 
@@ -258,8 +265,9 @@ never read by genroc, because genctl doubles every `$` on splice.
 
 ## The realm — one Worker per execution
 
-`evaluate()` starts a Worker (`realm.ts`), posts the code into it, and races the reply against the budget;
-`terminate()` runs on every path. That thread is what the contract rests on, and it buys
+`evaluate()` starts a Worker (`realm.ts`), posts the code into it — where a module loader hook
+serves it to `import()`, so the engine numbers the script's frames from the author's own source —
+and races the reply against the budget; `terminate()` runs on every path. That thread is what the contract rests on, and it buys
 exactly three things the previous in-process evaluator could not:
 
 - **The budget is enforced, not merely reported.** A synchronous `while(true){}` never
@@ -271,16 +279,15 @@ exactly three things the previous in-process evaluator could not:
 - **The script's mistakes stay the script's.** An uncaught throw, and `process.exit()`, end
   the realm and come back as a `422` — neither reaches the runner.
 
-It costs about **50ms per execution** end to end for a trivial script (Node 24, M-series
-laptop), a 200 KiB body about 63ms. Roughly 19ms of that is Node re-stripping `worker.ts`'s
-types on every realm — precompiling it to JavaScript would buy that back, and is deliberately
-not done: a build artefact that goes stale against its source fails silently, and this file
-is the one where a wrong line number is invisible.
+It costs about **27ms per execution** end to end for a trivial script (Node 24, M-series
+laptop), a 200 KiB body about 30ms. Roughly 11ms of that is Node re-stripping `realm.ts`'s
+types on every realm — precompiling it to JavaScript measures 17ms and would buy that back, and
+is deliberately not done: a build artefact that goes stale against its source fails silently,
+and this file is the one where a wrong line number is invisible.
 
-That also changes an old trade-off. A subprocess per execution measures ~48ms here — within
-noise of the thread — where on the previous runtime it was ten times the thread's cost. The
-thread no longer wins on price, and a subprocess contains the two things a thread cannot
-(below), so it is the live upgrade path rather than a theoretical one.
+A subprocess per execution measures ~55ms here, twice the thread rather than the ten times it
+cost on the previous runtime. It contains the two things a thread cannot (below), so the upgrade
+path is a live one at a price worth naming rather than a theoretical one.
 
 ## What this is not
 
@@ -291,7 +298,7 @@ thread no longer wins on price, and a subprocess contains the two things a threa
   it needed was surface with nothing behind it. A value that must survive a retry belongs in
   the definition, passed through `input`.
 - **Not a sandbox.** The realm isolates *execution*, not *authority*: a script gets the
-  worker's filesystem, network and environment, and `require` of any node builtin. That is
+  worker's filesystem, network and environment, and any node builtin it imports. That is
   deliberate — a script task is meant to do real work — but the trust boundary stays the
   same-trust-domain one (your genroc, your worker host). It is not the multi-tenant story, and
   nothing here should be mistaken for one. Pulling does move the boundary in one useful way:
@@ -305,9 +312,9 @@ thread no longer wins on price, and a subprocess contains the two things a threa
 - **Concurrency is capped by this worker, not by genroc.** Each evaluation is a thread, and
   `CONCURRENCY` is how many it will claim at once. Raising it past what the host can run turns
   a queue back into threads fighting over a core.
-- **Not where imports and type checking happen.** The evaluator still takes one
-  self-contained function body and knows nothing about TypeScript; `import.ts` is what turns
-  a module into that body, at author time. See above.
+- **Not where imports and type checking happen.** The evaluator takes one self-contained
+  module and knows nothing about TypeScript; `import.ts` is what bundles an author's script and
+  its dependencies into that module, at author time. See above.
 - **`eval.ts` and `realm.ts` know nothing about genroc.** `worker.ts` is the entire
   queue-facing half, which is what keeps the containment strategy swappable — and what lets
   the realm's own properties be tested by calling `evaluate()` directly.

package/dist/eval.js

@@ -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

package/dist/import.js

@@ -7,9 +7,10 @@
 // code; "build" typechecks and bundles. A separate types hook would mean a second `tsc`
 // over the same project.
 import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
 import { access, mkdir, writeFile } from "node:fs/promises";
 import { builtinModules } from "node:module";
-import { dirname, join, relative } from "node:path";
+import { dirname, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import commonjs from "@rollup/plugin-commonjs";
 import json from "@rollup/plugin-json";
@@ -86,7 +87,9 @@ function objectType(s, used) {
     const required = new Set(s.required ?? []);
     const lines = [];
     for (const [key, sub] of Object.entries(props)) {
-        const doc = typeof sub.description === "string" ? `  /** ${sub.description} */\n` : "";
+        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") {
@@ -102,7 +105,7 @@ 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, "_")}`);
+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++) {
@@ -110,21 +113,14 @@ function deref(s, defs) {
     }
     return cur;
 }
-/** The manifest's `input` is the type of the whole ACTION input — for /eval that is
- *  `{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, defs) {
-    const action = deref(site.input, defs);
-    const bound = action?.properties?.input;
-    return bound ?? site.input;
-}
 /** 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(site, defs) {
+function declarations(at) {
+    const { site, where } = at;
+    const defs = where.$defs ?? {};
     const used = new Set();
-    const input = tsType(scriptInput(site, defs), used);
-    const output = tsType(site.output, used);
+    const input = tsType(site.types?.Input, used);
+    const output = tsType(site.types?.Output, used);
     const emitted = [];
     const done = new Set();
     while (true) {
@@ -137,7 +133,7 @@ function declarations(site, defs) {
     }
     return [
         "// Generated by genroc. Do not edit - regenerate with `genctl types`.",
-        `// ${site.process}${site.task ? ` / ${site.task}` : ""}  (${site.pointer})`,
+        `// ${where.name}  (${address(site.pointer)})`,
         "",
         ...emitted,
         emitted.length ? "" : "",
@@ -165,7 +161,7 @@ async function nearestTsconfig(from, root) {
             return null;
     }
 }
-async function typecheck(root, sites) {
+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");
@@ -173,13 +169,13 @@ async function typecheck(root, sites) {
     // One tsc 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 site of sites) {
-        const base = (await nearestTsconfig(dirname(site.path), root)) ?? "";
+    for (const at of sites) {
+        const base = (await nearestTsconfig(dirname(at.file), root)) ?? "";
         const group = groups.get(base);
         if (group)
-            group.push(site);
+            group.push(at);
         else
-            groups.set(base, [site]);
+            groups.set(base, [at]);
     }
     let n = 0;
     for (const [base, group] of groups) {
@@ -200,7 +196,10 @@ async function typecheck(root, sites) {
                 // 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.file),
+                relative(dir, 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: [],
@@ -250,7 +249,10 @@ const transpile = {
         return { code: out.outputText, map: out.sourceMapText ?? null };
     },
 };
-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
  *  resolver to keep in agreement with tsc; this one cannot disagree.
@@ -270,22 +272,25 @@ function tsResolve(configPath) {
             const { resolvedModule } = ts.resolveModuleName(source, importer, options, ts.sys);
             if (!resolvedModule || resolvedModule.isExternalLibraryImport)
                 return null;
-            return resolvedModule.resolvedFileName.endsWith(".d.ts") ? null : resolvedModule.resolvedFileName;
+            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. */
-async function bundle(site, root) {
-    // 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
+/** 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 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,
+        input: at.file,
         external: (id) => BUILTIN.has(id),
         plugins: [
-            tsResolve(await nearestTsconfig(dirname(site.path), root)),
+            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
@@ -295,22 +300,21 @@ async function bundle(site, root) {
         ],
         onwarn(warning) {
             if (warning.code === "UNRESOLVED_IMPORT") {
-                die(`${site.path}: cannot resolve ${warning.exporter ?? "an import"} — is it installed?`);
+                die(`${at.file}: cannot resolve ${warning.exporter ?? "an import"} — is it installed?`);
             }
         },
-    }).catch((e) => die(`${site.path}: ${e instanceof Error ? e.message : String(e)}`));
-    const { output } = await built.generate({ format: "cjs", exports: "auto", inlineDynamicImports: true });
+    }).catch((e) => die(`${at.file}: ${e instanceof Error ? e.message : String(e)}`));
+    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(`${at.file}: a script must \`export default\` the function to run`);
+    }
+    return output[0].code;
 }
 // ── main ───────────────────────────────────────────────────────────────────────
 const stdin = await new Promise((resolve, reject) => {
@@ -321,32 +325,73 @@ const stdin = await new Promise((resolve, reject) => {
     process.stdin.on("error", reject);
 });
 const manifest = JSON.parse(stdin);
-if (!manifest || !Array.isArray(manifest.sites))
+// genctl runs a resolver with the project root as its cwd, so the manifest need not say so.
+const root = process.cwd();
+if (!manifest || !Array.isArray(manifest.processes))
     die("stdin is not a genroc resolver manifest");
+/** A pointer as the address it is, so a generated comment or an error can be pasted into
+ *  `genctl schema`. A key no identifier can spell is bracketed, as the grammar spells it. */
+function address(pointer) {
+    return pointer
+        .map((seg) => typeof seg === "string" && /^[A-Za-z_][A-Za-z0-9_]*$/.test(seg)
+        ? `.${seg}`
+        : `[${JSON.stringify(seg)}]`)
+        .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.
+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.
+    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") {
+        die(`${join(at.where.dir, at.where.file)}: ${address(at.site.pointer)}: an evaluated script ` +
+            "belongs in the `code` field of a child or external task's input, and this is " +
+            `${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.
+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})`);
+    }
+}
 // 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();
-for (const site of manifest.sites) {
-    const seen = byPath.get(site.path);
-    const defsOf = (x) => (manifest.schemas[x.process]?.$defs ?? {});
+for (const at of located) {
+    const seen = byPath.get(at.file);
     if (seen &&
-        JSON.stringify(scriptInput(seen, defsOf(seen))) !==
-            JSON.stringify(scriptInput(site, defsOf(site)))) {
-        die(`${site.path} is imported at ${seen.pointer} and ${site.pointer} with different input types.\n` +
+        JSON.stringify(seen.site.types) !== JSON.stringify(at.site.types)) {
+        die(`${at.file} is imported at ${address(seen.site.pointer)} and ` +
+            `${address(at.site.pointer)} with different input types.\n` +
             "Split it into two scripts, or make the two call sites pass the same shape.");
     }
-    byPath.set(site.path, site);
+    byPath.set(at.file, at);
 }
-for (const site of byPath.values()) {
-    const defs = (manifest.schemas[site.process]?.$defs ?? {});
-    await write(typesPathFor(site.path), declarations(site, defs));
+for (const at of byPath.values()) {
+    await write(typesPathFor(at.file), declarations(at));
 }
 if (manifest.mode === "types") {
+    console.log(JSON.stringify(manifest, null, 2));
     process.exit(0);
 }
-await typecheck(manifest.root, [...byPath.values()]);
+await typecheck([...byPath.values()]);
 const code = [];
-for (const site of manifest.sites) {
-    code.push(await bundle(site, manifest.root));
+for (const at of located) {
+    code.push(await bundle(at));
 }
 process.stdout.write(JSON.stringify({ code }));

package/dist/realm.js

@@ -2,80 +2,46 @@
 // 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 — compiling,
+// 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 { createRequire } from "node:module";
+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";
-const AsyncFunction = async function () { }.constructor;
-const STRICT = '"use strict";\n';
-// Bundled `node:*` imports survive as `require` calls — the importer externalises builtins and
-// inlines everything else — and a function built by the AsyncFunction constructor has no
-// `require` in scope. Passing one in is what makes an import of a builtin work at runtime rather than at
-// typecheck only. Resolution is anchored here, which is right: only builtins reach it.
-const scriptRequire = createRequire(import.meta.url);
+// 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;
-/**
- * Line offset the AsyncFunction preamble adds, measured rather than assumed: the generated
- * wrapper's shape is engine-specific, and a hardcoded number silently misreports every
- * script's error location the day it changes.
- */
-const lineOffset = (async () => {
-    // Same parameter list as a real compile: the preamble is what is being measured.
-    const probe = new AsyncFunction("input", "require", STRICT + "throw new Error('probe');");
-    try {
-        await probe();
-        return 0;
-    }
-    catch (err) {
-        return reportedLine(err) - 1;
-    }
-})();
-// V8 marks a frame compiled by the AsyncFunction constructor with the site that CALLED the
-// constructor, then the script's OWN position:
-//   at inner (eval at run (file:///…/worker.ts:107:10), <anonymous>:6:9)
-// `eval at` is therefore what separates script frames from runner plumbing — matched without
-// the function name, which is whatever encloses the `new AsyncFunction` below. The LAST such
-// frame is the body's top level: frames interleave, since a script can throw inside a native
-// callback.
-const SCRIPT_FRAME = /\(eval at /;
-// The trailing `<anonymous>:LINE:COL` — the script's position, after the host file's own.
-const POSITION = /<anonymous>:(\d+):(\d+)\)?\s*$/;
-// `    at name (` — absent on the top-level frame, which V8 names `eval`.
-const FRAME_NAME = /^\s*at\s+(?:async\s+)?([^\s(]+)\s*\(/;
-/** Line number of the throw as the engine reported it, or 1 if the stack is unreadable. */
-function reportedLine(err) {
-    const stack = err instanceof Error && typeof err.stack === "string" ? err.stack : "";
-    const frame = stack.split("\n").find((l) => SCRIPT_FRAME.test(l)) ?? "";
-    const m = frame.match(POSITION);
-    return m ? Number(m[1]) : 1;
-}
-/** Renumbers each script frame to the line the AUTHOR wrote and drops the runner's own.
- *  Rewriting the whole location is also what keeps the runner's path out of a script's
- *  stack — V8 puts it inside every compiled frame. */
-function scriptStack(err, offset) {
+// 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 boundary = -1;
+    let last = 0;
     for (let i = 0; i < lines.length; i++)
-        if (SCRIPT_FRAME.test(lines[i]))
-            boundary = i;
-    const frames = (boundary >= 0 ? lines.slice(0, boundary + 1) : lines.slice(0, 1))
-        .map((line) => {
-        const pos = line.match(POSITION);
-        if (!pos)
-            return line; // the `Error: message` header and native frames, kept as-is
-        const name = line.match(FRAME_NAME)?.[1];
-        const at = name && name !== "eval" && name !== "anonymous" ? `at ${name} ` : "at ";
-        const indent = line.match(/^\s*/)[0];
-        return `${indent}${at}(script:${Math.max(1, Number(pos[1]) - offset)}:${pos[2]})`;
-    })
-        .join("\n");
-    return frames.length > STACK_BYTES ? frames.slice(0, STACK_BYTES) : frames;
+        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, offset) {
+function describe(err, kind) {
     if (err instanceof Error) {
-        return { kind, name: err.name, message: err.message, stack: scriptStack(err, offset) };
+        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) };
@@ -88,23 +54,39 @@ 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. */
+function unloadable(err) {
+    const code = err?.code;
+    return err instanceof SyntaxError || (typeof code === "string" && code.startsWith("ERR_MODULE"));
+}
 async function run(req) {
-    const offset = await lineOffset;
-    let fn;
+    source = req.code;
+    let main;
     try {
-        // No compile cache: the realm is discarded after this execution, so a cache in it could
-        // never be hit. Repeated compilation is the price of the fresh global object.
-        fn = new AsyncFunction("input", "require", STRICT + req.code);
+        main = (await import(__rewriteRelativeImportExtension(SCRIPT_URL))).default;
     }
     catch (err) {
-        return { ok: false, failure: describe(err, "compile_error", offset) };
+        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 fn(req.input, scriptRequire);
+        value = await main(req.input);
     }
     catch (err) {
-        return { ok: false, failure: describe(err, "threw", offset) };
+        return { ok: false, failure: describe(err, "threw") };
     }
     try {
         // undefined stringifies to undefined, not "undefined"; an empty body is how genroc
@@ -112,11 +94,20 @@ async function run(req) {
         return { ok: true, body: value === undefined ? "" : JSON.stringify(value) ?? "" };
     }
     catch (err) {
-        return { ok: false, failure: describe(err, "nonserializable", offset) };
+        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) => {
-    parentPort.postMessage(await run(req));
+    const reply = await run(req);
+    await Promise.all([flush(process.stdout), flush(process.stderr)]);
+    parentPort.postMessage(reply);
 });

package/dist/worker.js

@@ -4,6 +4,7 @@
 // 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}`;
@@ -15,7 +16,11 @@ const WORKER_ID = process.env.WORKER_ID ?? `evaluator-${process.pid}`;
 // 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.
-const TOKEN = process.env.GENROC_TOKEN ?? "";
+// 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