@genroc/eval-node 0.0.0-edge.51cbf37 → 0.0.0-edge.51f2744b

package/dist/eval.js

@@ -1,35 +1,46 @@
-// 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.
-//
-// 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";
 const DEFAULT_TIMEOUT_MS = 5_000;
 // Resolved from THIS file's own extension: run from a checkout it is `.ts`, and from the
 // published package `.js`, because Node will not strip types under node_modules.
 const REALM_URL = new URL(import.meta.url.endsWith(".ts") ? "./realm.ts" : "./realm.js", import.meta.url);
-/** Thrown, not returned: a realm that fails to start is the RUNNER faulting, which worker.ts
- *  answers by releasing the claim rather than by reporting an outcome. A script fault is a
- *  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) {
         super(message);
         this.name = "RealmFault";
     }
 }
-export async function evaluate(req) {
+/** 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");
+        this.name = "Cancelled";
+    }
+}
+export async function evaluate(req, signal) {
     const budget = typeof req.timeout_ms === "number" ? req.timeout_ms : DEFAULT_TIMEOUT_MS;
     const worker = new Worker(REALM_URL);
     let timer;
+    let onAbort;
     try {
         return await new Promise((resolve, reject) => {
             timer = setTimeout(() => resolve(timedOut(budget)), budget);
+            // The abort is wired to the same promise as the budget, so both settle through the one
+            // finally below -- which is what guarantees the thread is gone before either returns.
+            if (signal) {
+                if (signal.aborted)
+                    reject(new Cancelled());
+                onAbort = () => reject(new Cancelled());
+                signal.addEventListener("abort", onAbort, { once: true });
+            }
             worker.once("message", (reply) => 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) => resolve(exited(code)));
             worker.once("error", (err) => reject(new RealmFault(errorText(err))));
             worker.postMessage({ code: req.code, input: req.input });
@@ -37,6 +48,8 @@ export async function evaluate(req) {
     }
     finally {
         clearTimeout(timer);
+        if (signal && onAbort)
+            signal.removeEventListener("abort", onAbort);
         // Awaited, and the whole point: on the timeout path a thread is still burning a core, and
         // resolving before it is gone would report an evaluation the machine is still running.
         await worker.terminate();

package/dist/import.js

@@ -1,16 +1,11 @@
 #!/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";
-import { access, mkdir, writeFile } from "node:fs/promises";
+// 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, writeFile } from "node:fs/promises";
 import { builtinModules } from "node:module";
-import { dirname, join, relative } 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";
 import { nodeResolve } from "@rollup/plugin-node-resolve";
@@ -29,11 +24,6 @@ async function exists(path) {
         return false;
     }
 }
-/** Creates the parent directory, which `.genroc-cache/` relies on: nothing else makes it. */
-async function write(path, content) {
-    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
  *  refused before this ran (internal/schema, allowedKeywords). */
@@ -86,45 +76,35 @@ 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` : "";
-        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) ? "" : "?"}: ${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) => t.replace(/\n/g, "\n  ");
 function union(parts) {
     const seen = [...new Set(parts)];
     return seen.length === 0 ? "unknown" : seen.join(" | ");
 }
 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, "_")}`);
-function deref(s, defs) {
-    let cur = s;
-    for (let i = 0; cur && typeof cur.$ref === "string" && i < 16; i++) {
-        cur = defs[cur.$ref.replace(/^#\/\$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;
-}
+const identifier = (n) => IDENT.test(n) ? n : `Def_${n.replace(/[^A-Za-z0-9_$]/g, "_")}`;
 /** 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) {
@@ -136,8 +116,8 @@ function declarations(site, defs) {
         emitted.push(`export type ${identifier(next)} = ${body};`);
     }
     return [
-        "// Generated by genroc. Do not edit - regenerate with `genctl types`.",
-        `// ${site.process}${site.task ? ` / ${site.task}` : ""}  (${site.pointer})`,
+        "// Generated by genroc. Do not edit - regenerate with `genctl generate`.",
+        `// ${where.name}  (${address(site.pointer)})`,
         "",
         ...emitted,
         emitted.length ? "" : "",
@@ -153,9 +133,8 @@ function typesPathFor(scriptPath) {
     return scriptPath.replace(/\.[^.\/]+$/, "") + ".genroc.d.ts";
 }
 // ── 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, root) {
     for (let dir = from;; dir = dirname(dir)) {
         const candidate = join(dir, "tsconfig.json");
@@ -165,26 +144,22 @@ async function nearestTsconfig(from, root) {
             return null;
     }
 }
-async function typecheck(root, 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");
-    await write(join(dir, ".gitignore"), "*\n");
-    // One tsc per distinct base config: `extends` takes a single base, so merging two would
+async function typecheck(sites) {
+    // 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();
-    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;
+    const diagnostics = [];
     for (const [base, group] of groups) {
         const config = {
-            ...(base ? { extends: relative(dir, base) } : {}),
+            ...(base ? { extends: base } : {}),
             compilerOptions: {
                 noEmit: true,
                 strict: true,
@@ -195,39 +170,36 @@ async function typecheck(root, sites) {
                 // `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.path), relative(dir, typesPathFor(s.path))]),
+            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`);
-        await write(configPath, JSON.stringify(config, null, 2));
-        await runTsc(root, configPath);
+        // 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"));
+        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, configPath) {
-    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) => (out += c));
-    proc.stderr.on("data", (c) => (err += c));
-    const code = await new Promise((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());
     }
 }
 // ── bundle ─────────────────────────────────────────────────────────────────────
@@ -250,12 +222,13 @@ const transpile = {
         return { code: out.outputText, map: out.sourceMapText ?? null };
     },
 };
-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.
- *  A package resolving to a `.d.ts` is declined — that is a type, not the implementation —
- *  which leaves node_modules to nodeResolve. */
+const BUILTIN = new Set([
+    ...builtinModules,
+    ...builtinModules.map((m) => `node:${m}`),
+]);
+/** 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) {
     let options = {};
     if (configPath) {
@@ -270,47 +243,46 @@ 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
-    // of a module that will not be there, which bundles clean and fails at runtime.
+/** 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) {
+    const site = at.site;
+    // 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: 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
-            // 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,
         ],
         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 +293,69 @@ 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) => {
+    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) };
+}));
+// 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) {
+    // 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") {
+        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 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.args[0]}" 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 writeFile(typesPathFor(at.file), declarations(at));
 }
-if (manifest.mode === "types") {
+if (manifest.mode === "generate") {
     process.exit(0);
 }
-await typecheck(manifest.root, [...byPath.values()]);
-const code = [];
-for (const site of manifest.sites) {
-    code.push(await bundle(site, manifest.root));
+await typecheck([...byPath.values()]);
+const values = [];
+for (const at of located) {
+    values.push(await bundle(at));
 }
-process.stdout.write(JSON.stringify({ code }));
+process.stdout.write(JSON.stringify({ values }));