houdini 2.0.0-go.2 → 2.0.0-go.20

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Alec Aivazis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/build/cmd/generate.d.ts

@@ -1,3 +1,4 @@
+import { type PipelineHook } from '../lib/index.js';
 export declare function generate(args?: {
     pullSchema: boolean;
     persistOutput?: string;
@@ -7,4 +8,6 @@ export declare function generate(args?: {
     verbose: boolean;
     mode?: string;
     preserveDatabase: boolean;
+    afterPhase?: PipelineHook;
+    beforePhase?: PipelineHook;
 }): Promise<void>;

package/build/cmd/generate.js

@@ -1,7 +1,12 @@
 #!/usr/bin/env node
 
 import { format_error } from "../lib/error.js";
-import { codegen_setup, init_db, run_pipeline } from "../lib/index.js";
+import {
+  codegen_setup,
+  init_db,
+  run_pipeline,
+  PIPELINE_HOOKS
+} from "../lib/index.js";
 import { get_config } from "../lib/project.js";
 import pull_schema from "./pullSchema.js";
 async function generate(args = {
@@ -30,10 +35,33 @@ async function generate(args = {
     };
     process.on("SIGINT", on_close);
     process.on("SIGTERM", on_close);
-    await run_pipeline(trigger_hook, { after: "Schema" });
+    if (args.afterPhase && !PIPELINE_HOOKS.includes(args.afterPhase)) {
+      throw new Error(
+        `Invalid --after-phase: ${args.afterPhase}. Valid phases are: ${PIPELINE_HOOKS.join(
+          ", "
+        )}`
+      );
+    }
+    if (args.beforePhase && !PIPELINE_HOOKS.includes(args.beforePhase)) {
+      throw new Error(
+        `Invalid --before-phase: ${args.beforePhase}. Valid phases are: ${PIPELINE_HOOKS.join(", ")}`
+      );
+    }
+    const pipelineOptions = {
+      after: "Schema"
+    };
+    if (args.afterPhase) {
+      pipelineOptions.after = args.afterPhase;
+    }
+    if (args.beforePhase) {
+      pipelineOptions.through = args.beforePhase;
+    }
+    const results = await run_pipeline(trigger_hook, pipelineOptions);
+    const docCount = Object.values(results.GenerateDocuments ?? {}).flat().length;
+    console.log(`\u{1F3A9} Generated ${docCount} ${docCount === 1 ? "document" : "documents"}`);
     await on_close();
   } catch (e) {
-    format_error(e, function(error) {
+    format_error(e, (error) => {
       console.error(error.stack?.split("\n").slice(1).join("\n"));
     });
     try {

package/build/cmd/index.js

@@ -8,7 +8,13 @@ const program = new Command();
 program.command("generate").description("generate the application runtime").option("-p, --pull-schema", "pull the latest schema before generating").option("-r, --preserve-database", "preserve any existing generated logic").option("-o, --output [outputPath]", "persist queries to a queryMap file").option(
   "-h, --headers <headers...>",
   "headers to use when pulling your schema. Should be passed as KEY=VALUE"
-).option("-v, --verbose", "verbose error messages").action(generate);
+).option("-v, --verbose", "verbose error messages").option(
+  "--after-phase <phase>",
+  "start the pipeline after the specified phase (Config, AfterLoad, Schema, ExtractDocuments, AfterExtract, BeforeValidate, Validate, AfterValidate, BeforeGenerate, GenerateDocuments, GenerateRuntime, AfterGenerate)"
+).option(
+  "--before-phase <phase>",
+  "run the pipeline up to and including the specified phase (Config, AfterLoad, Schema, ExtractDocuments, AfterExtract, BeforeValidate, Validate, AfterValidate, BeforeGenerate, GenerateDocuments, GenerateRuntime, AfterGenerate)"
+).action(generate);
 program.command("init").arguments("[path]").usage("[path] [options]").description("initialize a new houdini project").option(
   "-h, --headers <headers...>",
   "header to use when pulling your schema. Should be passed as KEY=VALUE"

package/build/cmd/init.js

@@ -164,12 +164,14 @@ async function init(_path, args) {
   const configPath = path.join(targetPath, "houdini.config.js");
   const s = p.spinner();
   s.start(`\u{1F6A7} Generating houdini's files...`);
+  const runtimeDir = ".houdini";
   await houdiniConfig(
     configPath,
     schemaPath,
     module,
     frameworkInfo,
-    is_remote_endpoint ? url : null
+    is_remote_endpoint ? url : null,
+    runtimeDir
   );
   await houdiniClient(sourceDir, typescript, frameworkInfo, url);
   if (frameworkInfo.framework === "svelte") {
@@ -177,8 +179,11 @@ async function init(_path, args) {
   } else if (frameworkInfo.framework === "kit") {
     await svelteConfig(targetPath, typescript);
   }
-  await gitIgnore(targetPath);
-  await graphqlRC(targetPath);
+  await gitIgnore({
+    targetPath,
+    schemaPath: is_remote_endpoint ? schemaPath : void 0
+  });
+  await graphqlRC(targetPath, runtimeDir);
   await viteConfig(targetPath, frameworkInfo, typescript);
   await tjsConfig(targetPath, frameworkInfo);
   await packageJSON(targetPath, frameworkInfo);
@@ -211,14 +216,14 @@ function finale_logs(package_manager) {
     )
   );
 }
-async function houdiniConfig(configPath, schemaPath, module, frameworkInfo, url) {
+async function houdiniConfig(configPath, schemaPath, module, frameworkInfo, url, runtimeDir) {
   const config = {};
   if (url !== null) {
     config.watchSchema = {
       url
     };
   }
-  config.runtimeDir = ".houdini";
+  config.runtimeDir = runtimeDir;
   if (schemaPath !== "./schema.graphql") {
     config.schemaPath = schemaPath;
   }
@@ -244,7 +249,7 @@ const config = ${configObj}`;
   const content = module === "esm" ? `${content_base}
 
 export default config
-` : `${content_base}}
+` : `${content_base}
 
 module.exports = config
 `;
@@ -264,7 +269,7 @@ export default new HoudiniClient({
     // fetchParams({ session }) {
     //     return {
     //         headers: {
-    //             Authentication: \`Bearer \${session.token}\`,
+    //             Authorization: \`Bearer \${session.token}\`,
     //         }
     //     }
     // }
@@ -323,24 +328,34 @@ export default config;
 `;
   await fs.writeFile(svelteConfigPath, typescript ? newContentTs : newContentJs);
 }
-async function gitIgnore(targetPath) {
+async function gitIgnore({ targetPath, schemaPath }) {
   const filepath = path.join(targetPath, ".gitignore");
   const existing = await fs.readFile(filepath) || "";
+  let newIgnores = "";
   if (!existing.includes("\n.houdini\n")) {
-    await fs.writeFile(filepath, existing + "\n.houdini\n");
+    newIgnores += ".houdini\n";
+  }
+  if (schemaPath && !existing.includes(`
+${schemaPath}
+`)) {
+    newIgnores += `${schemaPath}
+`;
+  }
+  if (newIgnores) {
+    await fs.writeFile(filepath, existing + "\n" + newIgnores);
   }
 }
-async function graphqlRC(targetPath) {
+async function graphqlRC(targetPath, runtimeDir) {
   const target = path.join(targetPath, ".graphqlrc.yaml");
   const content = `projects:
   default:
     schema:
       - ./schema.graphql
-      - ./.houdini/graphql/schema.graphql
+      - ./${runtimeDir}/graphql/schema.graphql
     documents:
       - '**/*.gql'
       - '**/*.svelte'
-      - ./.houdini/graphql/documents.gql
+      - ./${runtimeDir}/graphql/documents.gql
 `;
   await fs.writeFile(target, content);
 }
@@ -420,12 +435,12 @@ async function packageJSON(targetPath, frameworkInfo) {
   }
   packageJSON2.devDependencies = {
     ...packageJSON2.devDependencies,
-    houdini: "^2.0.0-go.2"
+    houdini: "^2.0.0-go.20"
   };
   if (frameworkInfo.framework === "svelte" || frameworkInfo.framework === "kit") {
     packageJSON2.devDependencies = {
       ...packageJSON2.devDependencies,
-      "houdini-svelte": "^2.0.0-go.2"
+      "houdini-svelte": "^3.0.0-go.21"
     };
   } else {
     throw new Error(`Unmanaged framework: "${JSON.stringify(frameworkInfo)}"`);

package/build/lib/ast.d.ts

@@ -12,5 +12,5 @@ export declare function find_exported_fn(body: Statement[], name: string): {
     declaration: FunctionDeclaration | FunctionExpression | ArrowFunctionExpression | null | Identifier | CallExpression;
     export: ExportNamedDeclaration;
 } | null;
-export declare function find_exported_id(program: Program, name: string): recast.types.namedTypes.ExportNamedDeclaration | undefined;
+export declare function find_exported_id(program: Program, name: string): recast.types.namedTypes.ExportNamedDeclaration;
 export {};

package/build/lib/codegen.d.ts

@@ -42,9 +42,10 @@ export type CompilerProxy = {
     database_path: string;
     run_pipeline: (options: RunPipelineOptions) => Promise<Record<PipelineHook, Record<string, any>>>;
 };
+export declare function plugin_db_key(name: string): string;
 export declare function codegen_setup(config: Config, mode: string, db: DatabaseSync, db_file: string): Promise<CompilerProxy>;
-declare const PIPELINE_HOOKS: readonly ["Config", "AfterLoad", "Schema", "ExtractDocuments", "AfterExtract", "BeforeValidate", "Validate", "AfterValidate", "BeforeGenerate", "GenerateDocuments", "GenerateRuntime", "AfterGenerate"];
-type PipelineHook = (typeof PIPELINE_HOOKS)[number];
+export declare const PIPELINE_HOOKS: readonly ["Config", "AfterLoad", "Schema", "ExtractDocuments", "AfterExtract", "BeforeValidate", "Validate", "AfterValidate", "BeforeGenerate", "GenerateDocuments", "GenerateRuntime", "AfterGenerate"];
+export type PipelineHook = (typeof PIPELINE_HOOKS)[number];
 export type RunPipelineOptions = {
     task_id?: string;
     after?: PipelineHook;
@@ -52,4 +53,3 @@ export type RunPipelineOptions = {
     through?: PipelineHook;
 };
 export declare function run_pipeline(trigger_hook: CompilerProxy['trigger_hook'], options?: RunPipelineOptions): Promise<Record<PipelineHook, Record<string, any>>>;
-export {};

package/build/lib/codegen.js

@@ -1,11 +1,14 @@
 import { spawn } from "node:child_process";
 import path from "node:path";
+import { createInterface } from "node:readline";
 import sqlite from "node:sqlite";
 import { WebSocket } from "ws";
 import * as conventions from "../router/conventions.js";
 import { create_schema, write_config } from "./database.js";
 import { format_hook_error } from "./error.js";
 import * as fs from "./fs.js";
+import { Logger } from "./logger.js";
+import { LogLevel } from "./types.js";
 function connect_db(config) {
   const filepath = conventions.db_path(config);
   const db = new sqlite.DatabaseSync(filepath);
@@ -37,29 +40,43 @@ async function init_db(config, preserve) {
   }
   return [connect_db(config)[0], db_file];
 }
+function plugin_db_key(name) {
+  if (!name.startsWith("./") && !name.startsWith("../") && !path.isAbsolute(name)) {
+    return name;
+  }
+  return name.replace(/\./g, "_").replace(/\//g, "__");
+}
 async function codegen_setup(config, mode, db, db_file) {
+  const logger = new Logger(config.config_file.logLevel ?? LogLevel.Summary);
   await fs.mkdirpSync(conventions.houdini_root(config));
+  const rawTransport = config.config_file.pluginTransport ?? "websocket";
+  const resolvedTransport = rawTransport.startsWith("env:") ? process.env[rawTransport.slice("env:".length)] ?? "websocket" : rawTransport;
+  const useStdio = resolvedTransport === "stdio";
   const plugins = {};
   const plugin_specs = [];
   const spec_results = {};
-  const wait_for_plugin = (name) => new Promise((resolve, reject) => {
+  const stdioStdin = /* @__PURE__ */ new Map();
+  const triggerHookRef = { fn: null };
+  const wait_for_plugin_db = (configKey, dbKey) => new Promise((resolve, reject) => {
     const find_plugin = db.prepare("SELECT * FROM plugins WHERE name = ?");
     const interval = setInterval(() => {
-      const row = find_plugin.get(name);
+      const row = find_plugin.get(dbKey);
       if (row) {
         clearInterval(interval);
         db.prepare("UPDATE plugins set config = ? where name = ?").run(
-          JSON.stringify(config.plugins.find((p) => p.name === name)?.config ?? {}),
-          name
+          JSON.stringify(
+            config.plugins.find((p) => p.name === configKey)?.config ?? {}
+          ),
+          dbKey
         );
         const spec = {
           name: row.name,
           port: row.port,
           hooks: new Set(JSON.parse(row.hooks)),
           order: row.plugin_order,
-          directory: config.plugins.find((p) => p.name === name)?.directory || ""
+          directory: config.plugins.find((p) => p.name === configKey)?.directory || ""
         };
-        spec_results[name] = spec;
+        spec_results[configKey] = spec;
         if (row.config_module) {
           import(row.config_module).then((module) => {
             if (module && typeof module.default === "function") {
@@ -70,20 +87,142 @@ async function codegen_setup(config, mode, db, db_file) {
         } else {
           resolver(spec);
         }
-        resolver(spec);
       }
     }, 10);
     const timeout = setTimeout(() => {
       clearInterval(interval);
-      reject(new Error(`Timeout waiting for plugin ${name} to register`));
+      reject(new Error(`Timeout waiting for plugin ${configKey} to register`));
     }, 1e4);
     const resolver = (spec) => {
       clearTimeout(timeout);
       resolve(spec);
     };
   });
+  const wait_for_plugin_stdio = (name, child) => new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error(`Timeout waiting for plugin ${name} to register`));
+    }, 1e4);
+    const rl = createInterface({ input: child.stdout });
+    let registered = false;
+    rl.on("line", (line) => {
+      try {
+        const msg = JSON.parse(line);
+        if (!registered) {
+          if (msg.type !== "register") {
+            clearTimeout(timeout);
+            reject(new Error(`Plugin ${name} sent ${msg.type} before registering`));
+            return;
+          }
+          registered = true;
+          clearTimeout(timeout);
+          const spec = {
+            name: msg.name ?? plugin_db_key(name),
+            port: msg.port ?? 0,
+            hooks: new Set(msg.hooks ?? []),
+            order: msg.order,
+            directory: config.plugins.find((p) => p.name === name)?.directory || ""
+          };
+          spec_results[name] = spec;
+          db.prepare(
+            `INSERT OR IGNORE INTO plugins (name, hooks, port, plugin_order, include_runtime, config_module, client_plugins)
+							 VALUES (?, ?, ?, ?, ?, ?, ?)`
+          ).run(
+            spec.name,
+            JSON.stringify([...spec.hooks]),
+            spec.port,
+            spec.order,
+            msg.includeRuntime ?? null,
+            msg.configModule ?? null,
+            msg.clientPlugins ?? null
+          );
+          db.prepare("UPDATE plugins SET config = ? WHERE name = ?").run(
+            JSON.stringify(
+              config.plugins.find((p) => p.name === name)?.config ?? {}
+            ),
+            spec.name
+          );
+          if (msg.configModule) {
+            import(msg.configModule).then((module) => {
+              if (module && typeof module.default === "function") {
+                config.config_file = module.default(config.config_file);
+              }
+              resolve(spec);
+            }).catch((err) => {
+              reject(
+                new Error(
+                  `Failed to load configModule for ${name}: ${err.message}`
+                )
+              );
+            });
+          } else {
+            resolve(spec);
+          }
+          return;
+        }
+        if (msg.type === "response") {
+          const pending = pendingRequests.get(msg.id);
+          if (!pending)
+            return;
+          clearTimeout(pending.timeout);
+          pendingRequests.delete(msg.id);
+          if (msg.error) {
+            const errors = Array.isArray(msg.error) ? msg.error : [msg.error];
+            errors.forEach(
+              (error) => format_hook_error(config.root_dir, error, name, pending.hook)
+            );
+            pending.reject(new Error(`Failed to call ${name}`));
+          } else {
+            pending.resolve(msg.result);
+          }
+        } else if (msg.type === "invoke") {
+          if (!triggerHookRef.fn) {
+            const reply = JSON.stringify({
+              id: msg.id,
+              type: "invoke_result",
+              error: { message: "orchestrator not ready" }
+            }) + "\n";
+            child.stdin?.write(reply);
+            return;
+          }
+          triggerHookRef.fn(msg.hook, {
+            parallel_safe: msg.parallel,
+            payload: msg.payload,
+            task_id: msg.taskId
+          }).then((result) => {
+            const reply = JSON.stringify({ id: msg.id, type: "invoke_result", result }) + "\n";
+            child.stdin?.write(reply);
+          }).catch((err) => {
+            const reply = JSON.stringify({
+              id: msg.id,
+              type: "invoke_result",
+              error: { message: err.message }
+            }) + "\n";
+            child.stdin?.write(reply);
+          });
+        }
+      } catch (err) {
+        if (!registered) {
+          reject(err instanceof Error ? err : new Error(String(err)));
+        }
+      }
+    });
+    rl.on("close", () => {
+      if (!registered) {
+        clearTimeout(timeout);
+        reject(new Error(`Plugin ${name} stdout closed before registering`));
+      } else {
+        for (const [id, pending] of pendingRequests.entries()) {
+          if (pending.plugin !== name)
+            continue;
+          clearTimeout(pending.timeout);
+          pendingRequests.delete(id);
+          pending.reject(new Error(`Plugin ${name} closed unexpectedly`));
+        }
+      }
+    });
+  });
   db.prepare("DELETE FROM plugins").run();
-  console.time("Start Plugins");
+  logger.time("Start Plugins");
   await Promise.all(
     config.plugins.map(async (plugin) => {
       let executable = plugin.executable;
@@ -93,21 +232,35 @@ async function codegen_setup(config, mode, db, db_file) {
         executable = "node";
         args.unshift(plugin.executable);
       }
-      console.time(`Spawn ${plugin.name}`);
+      const dbKey = plugin_db_key(plugin.name);
+      args.push("--plugin-key", dbKey);
+      if (useStdio) {
+        args.push("--transport", "stdio");
+      }
+      logger.time(`Spawn ${plugin.name}`);
+      const child = spawn(executable, args, {
+        stdio: useStdio ? ["pipe", "pipe", "inherit"] : ["inherit", "inherit", "inherit"],
+        detached: process.platform !== "win32"
+      });
+      if (useStdio) {
+        stdioStdin.set(dbKey, child.stdin);
+        child.stdin.on("error", (err) => {
+          if (err.code !== "EPIPE") {
+            console.error(`[${plugin.name}] stdin error:`, err.message);
+          }
+        });
+      }
       plugins[plugin.name] = {
-        process: spawn(executable, args, {
-          stdio: "inherit",
-          detached: process.platform !== "win32"
-        }),
-        ...await wait_for_plugin(plugin.name)
+        process: child,
+        ...await (useStdio ? wait_for_plugin_stdio(plugin.name, child) : wait_for_plugin_db(plugin.name, dbKey))
       };
-      console.timeEnd(`Spawn ${plugin.name}`);
+      logger.timeEnd(`Spawn ${plugin.name}`, LogLevel.Verbose);
     })
   );
   for (const plugin of config.plugins) {
     plugin_specs.push(spec_results[plugin.name]);
   }
-  console.timeEnd("Start Plugins");
+  logger.timeEnd("Start Plugins", LogLevel.Summary);
   const wsConnections = /* @__PURE__ */ new Map();
   let messageCounter = 0;
   const pendingRequests = /* @__PURE__ */ new Map();
@@ -171,24 +324,39 @@ async function codegen_setup(config, mode, db, db_file) {
       throw new Error(`unknown plugin: ${name}`);
     }
     const { port, directory } = plugin;
-    const ws = await getOrCreateWS(name, port);
-    return new Promise((resolve, reject) => {
-      const messageId = String(++messageCounter);
-      const timeout = setTimeout(() => {
-        pendingRequests.delete(messageId);
-        reject(new Error(`WebSocket request timeout for ${name}/${hook}`));
-      }, 3e4);
-      pendingRequests.set(messageId, { resolve, reject, timeout, hook });
-      const message = {
-        id: messageId,
-        type: "request",
-        hook,
-        payload,
-        taskId: task_id,
-        pluginDirectory: directory
-      };
-      ws.send(JSON.stringify(message));
-    });
+    const messageId = String(++messageCounter);
+    const message = {
+      id: messageId,
+      type: "request",
+      hook,
+      payload,
+      taskId: task_id,
+      pluginDirectory: directory
+    };
+    if (useStdio) {
+      const stdin = stdioStdin.get(name);
+      if (!stdin) {
+        throw new Error(`No stdio channel for plugin ${name}`);
+      }
+      return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          pendingRequests.delete(messageId);
+          reject(new Error(`Request timeout for ${name}/${hook}`));
+        }, 3e4);
+        pendingRequests.set(messageId, { resolve, reject, timeout, hook, plugin: name });
+        stdin.write(JSON.stringify(message) + "\n");
+      });
+    } else {
+      const ws = await getOrCreateWS(name, port);
+      return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          pendingRequests.delete(messageId);
+          reject(new Error(`WebSocket request timeout for ${name}/${hook}`));
+        }, 3e4);
+        pendingRequests.set(messageId, { resolve, reject, timeout, hook, plugin: name });
+        ws.send(JSON.stringify(message));
+      });
+    }
   };
   const trigger_hook = async (hook, {
     parallel_safe,
@@ -196,24 +364,28 @@ async function codegen_setup(config, mode, db, db_file) {
     task_id
   } = {}) => {
     const timeName = hook + (task_id ? ` (${task_id})` : "");
-    console.time(timeName);
+    logger.time(timeName);
     const plugins2 = plugin_specs.filter(({ hooks }) => hooks.has(hook));
     const result = {};
-    if (parallel_safe) {
-      await Promise.all(
-        plugins2.map(async (plugin) => {
-          result[plugin.name] = await invoke_hook(plugin.name, hook, payload, task_id);
-        })
-      );
-    } else {
-      for (const { name } of plugins2) {
-        result[name] = await invoke_hook(name, hook, payload, task_id);
+    try {
+      if (parallel_safe) {
+        await Promise.all(
+          plugins2.map(async (plugin) => {
+            result[plugin.name] = await invoke_hook(plugin.name, hook, payload, task_id);
+          })
+        );
+      } else {
+        for (const { name } of plugins2) {
+          result[name] = await invoke_hook(name, hook, payload, task_id);
+        }
       }
+    } finally {
+      logger.timeEnd(timeName, task_id ? LogLevel.Verbose : LogLevel.Summary);
     }
-    console.timeEnd(timeName);
     return result;
   };
-  await write_config(db, config, invoke_hook, plugin_specs, mode);
+  triggerHookRef.fn = trigger_hook;
+  await write_config(db, config, invoke_hook, plugin_specs, mode, logger);
   await trigger_hook("Config");
   await trigger_hook("AfterLoad");
   await trigger_hook("Schema");
@@ -232,8 +404,16 @@ async function codegen_setup(config, mode, db, db_file) {
         }
       }
       wsConnections.clear();
-      for (const [, { timeout }] of pendingRequests.entries()) {
+      for (const [, stdin] of stdioStdin.entries()) {
+        try {
+          stdin.end();
+        } catch {
+        }
+      }
+      stdioStdin.clear();
+      for (const [, { timeout, reject }] of pendingRequests.entries()) {
         clearTimeout(timeout);
+        reject(new Error("codegen closed"));
       }
       pendingRequests.clear();
       await new Promise((resolve) => setTimeout(resolve, 100));
@@ -315,13 +495,25 @@ async function run_pipeline(trigger_hook, options = {}) {
     if (hook === "Validate" || hook === "GenerateDocuments") {
       opts.parallel_safe = true;
     }
+    if (hook === "GenerateDocuments" && i + 1 <= endIndex && PIPELINE_HOOKS[i + 1] === "GenerateRuntime") {
+      const [gdResult, grResult] = await Promise.all([
+        trigger_hook("GenerateDocuments", { task_id, parallel_safe: true }),
+        trigger_hook("GenerateRuntime", { task_id })
+      ]);
+      results["GenerateDocuments"] = gdResult;
+      results["GenerateRuntime"] = grResult;
+      i++;
+      continue;
+    }
     results[hook] = await trigger_hook(hook, opts);
   }
   return results;
 }
 export {
+  PIPELINE_HOOKS,
   codegen_setup,
   connect_db,
   init_db,
+  plugin_db_key,
   run_pipeline
 };