@genroc/eval-node 0.0.0-edge.f58b8b6 → 0.0.0-edge.f71f2603

package/eval.ts

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

package/import.ts

@@ -1,18 +1,12 @@
 #!/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.
-//
-// Two modes, one binary: "types" writes the declarations an editor needs and returns no
-// code; "build" typechecks and bundles. A separate types hook would mean a second `tsc`
-// over the same project.
-
-import { spawn } from "node:child_process";
+// The typed-phase resolver: manifest on stdin, `{"values": [...]}` on stdout, diagnostic on stderr
+// with a non-zero exit (specs/source-resolution.md). Two modes share one `tsc` pass: "generate"
+// writes declarations only, "resolve" typechecks and bundles.
+
 import { existsSync } from "node:fs";
-import { access, mkdir, writeFile } from "node:fs/promises";
+import { access, writeFile } from "node:fs/promises";
 import { builtinModules } from "node:module";
-import { dirname, join, relative, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
+import { dirname, join, resolve } from "node:path";
 
 import commonjs from "@rollup/plugin-commonjs";
 import json from "@rollup/plugin-json";
@@ -31,9 +25,9 @@ type Site = {
   child?: string;
   // The slot as a path of keys and indices, so nothing has to unescape a JSON Pointer.
   pointer: (string | number)[];
-  // Everything after `$<resolver>:`, verbatim. genctl does not read it as a path — that is
-  // this resolver's reading of it.
-  argument: string;
+  // The argument's words, split as sh splits single quotes. genctl does not read them as paths —
+  // that is this resolver's reading of them.
+  args: string[];
   // What .genroc asked genctl to type, keyed by the name it chose. This resolver reads Input
   // and Output; which ADDRESS each came from is the config's business, not ours.
   types?: Record<string, Schema>;
@@ -51,8 +45,7 @@ type ManifestProcess = {
 };
 
 type Manifest = {
-  mode: "types" | "build";
-  root: string;
+  mode: "generate" | "resolve";
   processes: ManifestProcess[];
 };
 
@@ -70,12 +63,6 @@ async function exists(path: string): Promise<boolean> {
   }
 }
 
-/** 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);
-}
-
 // ── JSON Schema → TypeScript ───────────────────────────────────────────────────
 
 /** Only genroc's keyword set is handled; anything else its strict decoder would have
@@ -137,16 +124,21 @@ function objectType(s: Schema, used: Set<string>): string {
         ? `  /** ${sub.description} */\n`
         : "";
     lines.push(
-      `${doc}  ${propKey(key)}${required.has(key) ? "" : "?"}: ${tsType(sub, used)};`,
+      `${doc}  ${propKey(key)}${required.has(key) ? "" : "?"}: ${nest(tsType(sub, used))};`,
     );
   }
   if (s.additionalProperties && typeof s.additionalProperties === "object") {
-    lines.push(`  [key: string]: ${tsType(s.additionalProperties, used)};`);
+    lines.push(
+      `  [key: string]: ${nest(tsType(s.additionalProperties, used))};`,
+    );
   }
   if (lines.length === 0) return "Record<string, unknown>";
   return `{\n${lines.join("\n")}\n}`;
 }
 
+/** Every line but the first, which is already placed by the property that opens it. */
+const nest = (t: string) => t.replace(/\n/g, "\n  ");
+
 function union(parts: string[]): string {
   const seen = [...new Set(parts)];
   return seen.length === 0 ? "unknown" : seen.join(" | ");
@@ -157,17 +149,6 @@ 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, "_")}`;
 
-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\//, "")];
-  }
-  return cur;
-}
-
 /** 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(at: Located): string {
@@ -188,7 +169,7 @@ function declarations(at: Located): string {
   }
 
   return [
-    "// Generated by genroc. Do not edit - regenerate with `genctl types`.",
+    "// Generated by genroc. Do not edit - regenerate with `genctl generate`.",
     `// ${where.name}  (${address(site.pointer)})`,
     "",
     ...emitted,
@@ -208,9 +189,8 @@ function typesPathFor(scriptPath: string): string {
 
 // ── typecheck ──────────────────────────────────────────────────────────────────
 
-/** 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. */
+/** The tsconfig the author's editor reads, so editor and apply agree. Stops at the project
+ *  root. */
 async function nearestTsconfig(
   from: string,
   root: string,
@@ -223,12 +203,7 @@ async function nearestTsconfig(
 }
 
 async function typecheck(sites: Located[]): Promise<void> {
-  // 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
+  // One program 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<string, Located[]>();
   for (const at of sites) {
@@ -238,10 +213,10 @@ async function typecheck(sites: Located[]): Promise<void> {
     else groups.set(base, [at]);
   }
 
-  let n = 0;
+  const diagnostics: ts.Diagnostic[] = [];
   for (const [base, group] of groups) {
     const config: Record<string, unknown> = {
-      ...(base ? { extends: relative(dir, base) } : {}),
+      ...(base ? { extends: base } : {}),
       compilerOptions: {
         noEmit: true,
         strict: true,
@@ -252,46 +227,45 @@ async function typecheck(sites: Located[]): Promise<void> {
         // `lib` DESCRIBES the realm and is written after `extends` so a base cannot widen it:
         // a worker thread has no document, whatever an author's config claims.
         lib: ["esnext", "webworker"],
-        // `types` is the author's, and it is how a script opts into the node globals —
-        // the worker realm has them, so refusing the declarations would only lie. With no
-        // base config there is nothing to opt in with, so the default stays none.
+        // `types` is the author's opt-in to node globals, which the realm has. With no base
+        // config there is nothing to opt in with, so it stays none.
         ...(base ? {} : { types: [] }),
       },
-      files: group.flatMap((s) => [
-        relative(dir, s.file),
-        relative(dir, typesPathFor(s.file)),
-      ]),
+      files: group.flatMap((s) => [s.file, 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: [],
     };
-    const configPath = join(
-      dir,
-      groups.size === 1 ? "tsconfig.json" : `tsconfig.${n++}.json`,
+    // Never written; anchors `@types` lookup at the root. Not `tsconfig.json`: that is often the
+    // base it extends, and tsc refuses a circular extends.
+    const parsed = ts.parseJsonConfigFileContent(
+      config,
+      ts.sys,
+      root,
+      undefined,
+      join(root, "tsconfig.genroc.json"),
     );
-    await write(configPath, JSON.stringify(config, null, 2));
-    await runTsc(root, configPath);
+    const program = ts.createProgram({
+      rootNames: parsed.fileNames,
+      options: parsed.options,
+      projectReferences: parsed.projectReferences,
+      configFileParsingDiagnostics: parsed.errors,
+    });
+    diagnostics.push(...parsed.errors, ...ts.getPreEmitDiagnostics(program));
   }
-}
 
-async function runTsc(root: string, configPath: string): Promise<void> {
-  const tsc = fileURLToPath(import.meta.resolve("typescript/bin/tsc"));
-  const proc = spawn(process.execPath, [tsc, "--noEmit", "-p", configPath], {
-    cwd: root,
-    stdio: ["ignore", "pipe", "pipe"],
-  });
-  let out = "";
-  let err = "";
-  proc.stdout.on("data", (c: Buffer) => (out += c));
-  proc.stderr.on("data", (c: Buffer) => (err += c));
-  const code = await new Promise<number>((resolve, reject) => {
-    proc.on("error", reject);
-    proc.on("close", (c) => resolve(c ?? 1));
-  });
-  if (code !== 0) {
-    // tsc reports on stdout; the exit code IS the type check, so this is the diagnostic
-    // genctl surfaces and the reason a failed import never produces a string.
-    die([out, err].filter(Boolean).join("\n").trimEnd());
+  if (diagnostics.length > 0) {
+    // The diagnostics are the whole type check: this is what genctl surfaces, and the reason a
+    // failed import never produces a string.
+    die(
+      ts
+        .formatDiagnostics(diagnostics, {
+          getCanonicalFileName: (f) => f,
+          getCurrentDirectory: () => root,
+          getNewLine: () => "\n",
+        })
+        .trimEnd(),
+    );
   }
 }
 
@@ -321,11 +295,9 @@ const BUILTIN = new Set([
   ...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.
- *  A package resolving to a `.d.ts` is declined — that is a type, not the implementation —
- *  which leaves node_modules to nodeResolve. */
+/** Resolves through TYPESCRIPT under the typecheck's config, so a `paths` alias that compiles
+ *  also bundles. A `.d.ts` resolution is declined (a type, not code), leaving node_modules to
+ *  nodeResolve. */
 function tsResolve(configPath: string | null): Plugin {
   let options: ts.CompilerOptions = {};
   if (configPath) {
@@ -355,14 +327,12 @@ function tsResolve(configPath: string | null): Plugin {
   };
 }
 
-/** 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. */
+/** A self-contained ES module whose default export is the author's own, unwrapped. Bundling here
+ *  means a definition version pins its code forever. */
 async function bundle(at: Located): Promise<string> {
   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.
+  // Builtins are externalised; anything else unresolved is a REFUSAL, since rollup's default
+  // leaves an import that bundles clean and fails at runtime.
   const built = await rollup({
     input: at.file,
     external: (id) => BUILTIN.has(id),
@@ -370,8 +340,7 @@ async function bundle(at: Located): Promise<string> {
       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
-      // did natively; without it rollup hands the JSON to the JS parser.
+      // Inlines `.json` imports; without it rollup hands JSON to the JS parser.
       json(),
       transpile,
     ],
@@ -414,10 +383,8 @@ const root = process.cwd();
 if (!manifest || !Array.isArray(manifest.processes))
   die("stdin is not a genroc resolver manifest");
 
-/** Every site with the process it sits in and the file its argument names, in the manifest's own
- *  order — which is the order `code` must answer in. genctl passes the argument verbatim, so
- *  joining it to the definition's directory is this resolver's business: only it knows the
- *  argument is a path at all. */
+/** Sites in manifest order, the order `code` must answer in. The argument is joined to the
+ *  definition's directory here: only this resolver knows it is a path. */
 type Located = { site: Site; where: ManifestProcess; file: string };
 
 /** A pointer as the address it is, so a generated comment or an error can be pasted into
@@ -433,22 +400,22 @@ function address(pointer: (string | number)[]): string {
     .replace(/^\./, "");
 }
 const located: Located[] = manifest.processes.flatMap((where) =>
-  where.sites.map((site) => ({
-    site,
-    where,
-    file: resolve(where.dir, site.argument),
-  })),
+  where.sites.map((site) => {
+    const [script, ...rest] = site.args;
+    if (script === undefined || rest.length > 0) {
+      die(
+        `${join(where.dir, where.file)}: ${address(site.pointer)}: $import takes one script, ` +
+          `and is given ${site.args.length} arguments`,
+      );
+    }
+    return { site, where, file: resolve(where.dir, script) };
+  }),
 );
 
-// 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.
+// The `code`-field contract is this resolver's, not genctl's, so it checks the directive landed
+// there: in a child call (the scaffold's shape) or an external task's input.
 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.
+  // The action's kind is a field; where in it the directive sits is the pointer.
   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") {
@@ -460,13 +427,12 @@ for (const at of located) {
   }
 }
 
-// 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.
+// genctl does not know the argument is a file, so this resolver reports a missing one.
 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})`,
+        `"$import: ${at.site.args[0]}" names no file (looked at ${at.file})`,
     );
   }
 }
@@ -490,18 +456,17 @@ for (const at of located) {
 }
 
 for (const at of byPath.values()) {
-  await write(typesPathFor(at.file), declarations(at));
+  await writeFile(typesPathFor(at.file), declarations(at));
 }
 
-if (manifest.mode === "types") {
-  console.log(JSON.stringify(manifest, null, 2));
+if (manifest.mode === "generate") {
   process.exit(0);
 }
 
 await typecheck([...byPath.values()]);
 
-const code: string[] = [];
+const values: string[] = [];
 for (const at of located) {
-  code.push(await bundle(at));
+  values.push(await bundle(at));
 }
-process.stdout.write(JSON.stringify({ code }));
+process.stdout.write(JSON.stringify({ values }));

package/package.json

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

package/realm.ts

@@ -1,18 +1,13 @@
-// 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.
+// The evaluation realm: one Worker per execution, killable mid-loop by eval.ts, which owns the
+// budget. Everything touching the script's VALUE lives here, the only realm it exists in.
 
 import { registerHooks } from "node:module";
 import { parentPort } from "node:worker_threads";
 
 import type { EvalFailure, FailureKind, WorkerReply, WorkerRequest } from "./eval.ts";
 
-// 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.
+// IMPORTED under our own URL rather than compiled from a string, so frames carry the author's
+// line numbers and builtin imports resolve normally.
 const SCRIPT_URL = "script:main";
 const STACK_BYTES = 2_048;
 
@@ -40,7 +35,10 @@ function scriptStack(err: unknown): string | undefined {
 
 function describe(err: unknown, kind: FailureKind): EvalFailure {
   if (err instanceof Error) {
-    return { kind, name: err.name, message: err.message, stack: scriptStack(err) };
+    // A subclass inherits `name` from Error.prototype, so `class LimitExceeded extends Error {}`
+    // would report "Error"; a name the script set still wins.
+    const name = err.name === "Error" && err.constructor.name ? err.constructor.name : err.name;
+    return { kind, 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) };
@@ -54,9 +52,8 @@ 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. */
+/** Unparseable code or an unresolvable import is broken code; anything else the import throws is
+ *  the module's top level running, i.e. the script throwing. */
 function unloadable(err: unknown): boolean {
   const code = (err as { code?: unknown } | null)?.code;
   return err instanceof SyntaxError || (typeof code === "string" && code.startsWith("ERR_MODULE"));
@@ -99,10 +96,8 @@ async function run(req: WorkerRequest): Promise<WorkerReply> {
   }
 }
 
-// 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.
+// eval.ts terminates this thread the moment the reply lands, while stdio may still be in the
+// pipe. An empty write's callback fires once the queue drains, making the reply a barrier.
 function flush(stream: NodeJS.WriteStream): Promise<void> {
   return new Promise((resolve) => stream.write("", () => resolve()));
 }