@genroc/eval-node 0.0.0-edge.d1df786 → 0.0.0-edge.d46a8ebf

package/import.ts

@@ -1,17 +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";
-import { access, mkdir, writeFile } from "node:fs/promises";
+// The code-phase resolver: manifest on stdin, `{"code": [...]}` on stdout, diagnostic on stderr
+// with a non-zero exit (specs/source-resolution.md). Two modes share one `tsc` pass: "types"
+// writes declarations only, "build" 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";
@@ -22,20 +17,37 @@ import ts from "typescript";
 type Schema = Record<string, any>;
 
 type Site = {
-  resolver: string;
-  process: string;
+  // Which namespace the directive sits in: `process`, `task` or `action`.
+  level: "process" | "task" | "action";
   task?: string;
-  pointer: string;
-  path: string;
-  input?: Schema;
-  output?: Schema;
+  // What the site IS, at action level: the action's type, and the process a child call names.
+  action?: string;
+  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;
+  // 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>;
+};
+
+type ManifestProcess = {
+  name: string;
+  // The definition's own location, split because a relative argument is relative to the
+  // DIRECTORY — joining is ours to do, and this is the base.
+  dir: string;
+  file: string;
+  sites: Site[];
+  // Only what this process's fragments reach — a `$ref` in `types` points here.
+  $defs?: Record<string, Schema>;
 };
 
 type Manifest = {
   mode: "types" | "build";
   root: string;
-  schemas: Record<string, Schema>;
-  sites: Site[];
+  processes: ManifestProcess[];
 };
 
 function die(message: string): never {
@@ -52,12 +64,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
@@ -72,13 +78,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";
@@ -111,16 +120,26 @@ 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) ? "" : "?"}: ${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(" | ");
@@ -128,32 +147,17 @@ 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, "_")}`);
-
-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;
-}
-
-/** 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: Site, defs: Record<string, Schema>): Schema | undefined {
-  const action = deref(site.input, defs);
-  const bound = action?.properties?.input;
-  return bound ?? site.input;
-}
+const identifier = (n: string) =>
+  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: Site, defs: Record<string, Schema>): string {
+function declarations(at: Located): string {
+  const { site, where } = at;
+  const defs = where.$defs ?? {};
   const used = new Set<string>();
-  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: string[] = [];
   const done = new Set<string>();
@@ -167,7 +171,7 @@ function declarations(site: Site, defs: Record<string, Schema>): string {
 
   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 ? "" : "",
@@ -186,10 +190,12 @@ 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. */
-async function nearestTsconfig(from: string, root: string): Promise<string | null> {
+/** The tsconfig the author's editor reads, so editor and apply agree. Stops at the project
+ *  root. */
+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,26 +203,21 @@ async function nearestTsconfig(from: string, root: string): Promise<string | nul
   }
 }
 
-async function typecheck(root: string, sites: Site[]): 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
+async function typecheck(sites: Located[]): Promise<void> {
+  // 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, Site[]>();
-  for (const site of sites) {
-    const base = (await nearestTsconfig(dirname(site.path), root)) ?? "";
+  const groups = new Map<string, Located[]>();
+  for (const at of sites) {
+    const base = (await nearestTsconfig(dirname(at.file), root)) ?? "";
     const group = groups.get(base);
-    if (group) group.push(site);
-    else groups.set(base, [site]);
+    if (group) group.push(at);
+    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,
@@ -227,40 +228,45 @@ async function typecheck(root: string, sites: Site[]): 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.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: 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(),
+    );
   }
 }
 
@@ -285,68 +291,82 @@ 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
- *  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) {
     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. */
-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
-  // 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: Located): Promise<string> {
+  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: unknown) => die(`${site.path}: ${e instanceof Error ? e.message : String(e)}`));
+  }).catch((e: unknown) =>
+    die(`${at.file}: ${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(`${at.file}: a script must \`export default\` the function to run`);
+  }
+  return output[0].code;
 }
 
 // ── main ───────────────────────────────────────────────────────────────────────
@@ -359,40 +379,91 @@ 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");
+// 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");
+
+/** 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
+ *  `genctl schema`. A key no identifier can spell is bracketed, as the grammar spells it. */
+function address(pointer: (string | number)[]): string {
+  return pointer
+    .map((seg) =>
+      typeof seg === "string" && /^[A-Za-z_][A-Za-z0-9_]*$/.test(seg)
+        ? `.${seg}`
+        : `[${JSON.stringify(seg)}]`,
+    )
+    .join("")
+    .replace(/^\./, "");
+}
+const located: Located[] = manifest.processes.flatMap((where) =>
+  where.sites.map((site) => ({
+    site,
+    where,
+    file: resolve(where.dir, site.argument),
+  })),
+);
+
+// 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.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<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 byPath = new Map<string, Located>();
+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)))
+    JSON.stringify(seen.site.types) !== JSON.stringify(at.site.types)
   ) {
     die(
-      `${site.path} is imported at ${seen.pointer} and ${site.pointer} with different input types.\n` +
+      `${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 ?? {}) as Record<string, Schema>;
-  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") {
+  console.log(JSON.stringify(manifest, null, 2));
   process.exit(0);
 }
 
-await typecheck(manifest.root, [...byPath.values()]);
+await typecheck([...byPath.values()]);
 
 const code: string[] = [];
-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/package.json

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