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

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.
@@ -51,7 +52,7 @@ async function exists(path: string): Promise<boolean> {
   }
 }
 
-/** Creates the parent directory, which `.genroc/` relies on: nothing else makes it. */
+/** Creates the parent directory, which `.genroc-cache/` relies on: nothing else makes it. */
 async function write(path: string, content: string): Promise<void> {
   await mkdir(dirname(path), { recursive: true });
   await writeFile(path, content);
@@ -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;
@@ -197,7 +216,9 @@ async function nearestTsconfig(from: string, root: string): Promise<string | nul
 }
 
 async function typecheck(root: string, sites: Site[]): Promise<void> {
-  const dir = join(root, ".genroc");
+  // NOT `.genroc`: that is the project config FILE, and a directory of the same name cannot
+  // coexist with it. The suffix is what keeps the scratch area out of its way.
+  const dir = join(root, ".genroc-cache");
   await write(join(dir, ".gitignore"), "*\n");
 
   // One tsc per distinct base config: `extends` takes a single base, so merging two would
@@ -229,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);
   }
@@ -282,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
@@ -293,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,
@@ -327,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 ───────────────────────────────────────────────────────────────────────
@@ -356,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))) !==
@@ -378,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));
 }
 

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "@genroc/eval-node",
-  "version": "0.0.0-edge.d8176a7",
+  "version": "0.0.0-edge.dc4ff88",
   "type": "module",
   "engines": {
     "node": ">=24"
   },
   "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run build",
     "work": "node worker.ts",
     "typecheck": "tsc --noEmit"
   },
@@ -28,11 +30,11 @@
   },
   "homepage": "https://genroc.org",
   "bin": {
-    "genroc-import": "bin/import.mjs",
-    "genroc-eval-node": "bin/worker.mjs"
+    "genroc-import": "dist/import.js",
+    "genroc-eval-node": "dist/worker.js"
   },
   "files": [
-    "bin",
+    "dist",
     "*.ts",
     "tsconfig.json",
     "README.md"

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";