@genroc/eval-node 0.0.0-edge.e4b0e52 → 0.0.0-edge.e5b183fc

package/dist/import.js

@@ -6,12 +6,10 @@
 // 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 { 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";
 import { nodeResolve } from "@rollup/plugin-node-resolve";
@@ -30,11 +28,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). */
@@ -90,15 +83,17 @@ function objectType(s, used) {
         const doc = typeof sub.description === "string"
             ? `  /** ${sub.description} */\n`
             : "";
-        lines.push(`${doc}  ${propKey(key)}${required.has(key) ? "" : "?"}: ${tsType(sub, used)};`);
+        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(" | ");
@@ -106,13 +101,6 @@ function union(parts) {
 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;
-}
 /** 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) {
@@ -162,11 +150,7 @@ async function nearestTsconfig(from, root) {
     }
 }
 async function typecheck(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
+    // 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 at of sites) {
@@ -177,10 +161,10 @@ async function typecheck(sites) {
         else
             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,
@@ -196,37 +180,33 @@ async function typecheck(sites) {
                 // base config there is nothing to opt in with, so the default 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`);
-        await write(configPath, JSON.stringify(config, null, 2));
-        await runTsc(root, configPath);
+        // Never written: the name only anchors `@types` lookup at the root. It must not be
+        // `tsconfig.json`: that is the base the config `extends` whenever the author keeps one at
+        // the root, and tsc refuses a config that extends its own path as circular.
+        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 ─────────────────────────────────────────────────────────────────────
@@ -383,7 +363,7 @@ for (const at of located) {
     byPath.set(at.file, at);
 }
 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));

package/dist/worker.js

@@ -62,15 +62,15 @@ async function fetchObject(ref) {
 /** Put each listed value back where its path says it belongs. Paths are arrays of keys, so this
  *  needs no parser: the whole reason they are not JSON Pointer strings. */
 async function resolveObjects(job) {
-    let input = job.input;
+    let input = job.external_input;
     for (const e of job.objects ?? []) {
         const value = await fetchObject(e.ref);
         if (e.path.length === 0) {
             input = value;
             continue;
         }
-        // The path is rooted at the entry and starts with "input", which is the value being rebuilt.
-        const rest = e.path[0] === "input" ? e.path.slice(1) : e.path;
+        // The path is rooted at the entry and starts with "external_input", the value being rebuilt.
+        const rest = e.path[0] === "external_input" ? e.path.slice(1) : e.path;
         if (rest.length === 0) {
             input = value;
             continue;

package/import.ts

@@ -7,12 +7,10 @@
 // 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 { 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";
@@ -70,12 +68,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 +129,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 +154,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 {
@@ -223,12 +209,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 +219,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,
@@ -257,41 +238,42 @@ async function typecheck(sites: Located[]): 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.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: the name only anchors `@types` lookup at the root. It must not be
+    // `tsconfig.json`: that is the base the config `extends` whenever the author keeps one at
+    // the root, and tsc refuses a config that extends its own path as circular.
+    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(),
+    );
   }
 }
 
@@ -490,7 +472,7 @@ 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") {

package/package.json

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

package/worker.ts

@@ -43,8 +43,8 @@ type ObjectEntry = { path: (string | number)[]; ref: string; size: number };
 type QueueTask = {
   token: string;
   process: string;
-  task_id: string;
-  input: unknown;
+  task: string;
+  external_input: unknown;
   objects?: ObjectEntry[];
   raises?: Record<string, unknown>;
 };
@@ -76,15 +76,15 @@ async function fetchObject(ref: string): Promise<unknown> {
 /** Put each listed value back where its path says it belongs. Paths are arrays of keys, so this
  *  needs no parser: the whole reason they are not JSON Pointer strings. */
 async function resolveObjects(job: QueueTask): Promise<unknown> {
-  let input: any = job.input;
+  let input: any = job.external_input;
   for (const e of job.objects ?? []) {
     const value = await fetchObject(e.ref);
     if (e.path.length === 0) {
       input = value;
       continue;
     }
-    // The path is rooted at the entry and starts with "input", which is the value being rebuilt.
-    const rest = e.path[0] === "input" ? e.path.slice(1) : e.path;
+    // The path is rooted at the entry and starts with "external_input", the value being rebuilt.
+    const rest = e.path[0] === "external_input" ? e.path.slice(1) : e.path;
     if (rest.length === 0) {
       input = value;
       continue;