@genroc/eval-node 0.0.0-edge.d8176a7 → 0.0.0-edge.ee19083

package/realm.ts

@@ -2,88 +2,45 @@
 // 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";
+import { registerHooks } from "node:module";
 import { parentPort } from "node:worker_threads";
 
 import type { EvalFailure, FailureKind, WorkerReply, WorkerRequest } from "./eval.ts";
 
-const AsyncFunction = async function () {}.constructor as new (
-  ...args: string[]
-) => (...args: unknown[]) => Promise<unknown>;
-
-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: Promise<number> = (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*\(/;
+// 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 = "";
 
-/** Line number of the throw as the engine reported it, or 1 if the stack is unreadable. */
-function reportedLine(err: unknown): number {
-  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;
-}
+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),
+});
 
-/** 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: unknown, offset: number): string | undefined {
+/** 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: unknown): string | undefined {
   if (!(err instanceof Error) || typeof err.stack !== "string") return undefined;
   const lines = err.stack.split("\n");
-  let boundary = -1;
-  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;
+  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: unknown, kind: FailureKind, offset: number): EvalFailure {
+function describe(err: unknown, kind: FailureKind): EvalFailure {
   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) };
@@ -97,23 +54,40 @@ function safeText(v: unknown): string {
   }
 }
 
+/** 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"));
+}
+
 async function run(req: WorkerRequest): Promise<WorkerReply> {
-  const offset = await lineOffset;
+  source = req.code;
 
-  let fn: (...args: unknown[]) => Promise<unknown>;
+  let main: unknown;
   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(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: unknown;
   try {
-    value = await fn(req.input, scriptRequire);
+    value = await (main as (input: unknown) => unknown)(req.input);
   } catch (err) {
-    return { ok: false, failure: describe(err, "threw", offset) };
+    return { ok: false, failure: describe(err, "threw") };
   }
 
   try {
@@ -121,12 +95,22 @@ async function run(req: WorkerRequest): Promise<WorkerReply> {
     // 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", 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: NodeJS.WriteStream): Promise<void> {
+  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: WorkerRequest) => {
-  parentPort!.postMessage(await run(req));
+  const reply = await run(req);
+  await Promise.all([flush(process.stdout), flush(process.stderr)]);
+  parentPort!.postMessage(reply);
 });

package/worker.ts

@@ -1,9 +1,11 @@
+#!/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, type EvalRequest, type FailureKind } from "./eval.ts";
 
 const SERVER = (process.env.GENROC_SERVER ?? "http://localhost:8448").replace(/\/$/, "");
@@ -16,7 +18,12 @@ 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: Record<string, string> = 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

package/bin/import.mjs

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-// npm `bin` entries need a shebang and a stable extension; Node's type stripping handles the
-// .ts behind it. genroc.yaml points here: command: [npx, genroc-import]
-import "../import.ts";

package/bin/worker.mjs

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-import "../worker.ts";