@cascade-flow/runner 0.2.4 → 0.2.6

package/dist/index.js

@@ -9,8 +9,403 @@ var __export = (target, all) => {
     });
 };
 
-// src/index.ts
-import { join as join2 } from "node:path";
+// src/subprocess-executor.ts
+import { spawn } from "node:child_process";
+import { resolve, dirname, join as join2 } from "node:path";
+import { fileURLToPath } from "node:url";
+import { mkdir, readFile, unlink, access, writeFile, readdir, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { getMicrosecondTimestamp, ensureErrorMessage } from "@cascade-flow/backend-interface";
+
+// src/checkpoint-ipc.ts
+import { join } from "node:path";
+function getResponsePath(dir, requestId) {
+  return join(dir, `res-${requestId}.json`);
+}
+function getResultPath(dir, requestId) {
+  return join(dir, `result-${requestId}.json`);
+}
+function getFailurePath(dir, requestId) {
+  return join(dir, `failure-${requestId}.json`);
+}
+
+// src/subprocess-executor.ts
+var EMBEDDED_STEP_EXECUTOR = `
+import { pathToFileURL } from "node:url";
+import { join } from "node:path";
+
+function serializeError(err) {
+  if (err instanceof Error) {
+    return { message: err.message, stack: err.stack, name: err.name };
+  }
+  return { message: String(err), name: "Error" };
+}
+
+function createCheckpointFunction(checkpointDir) {
+  const checkpointSequences = new Map();
+
+  return async function checkpoint(name, fn) {
+    if (!checkpointDir) return fn();
+
+    const seq = checkpointSequences.get(name) ?? 0;
+    checkpointSequences.set(name, seq + 1);
+    const requestId = Date.now() + "-" + Math.random().toString(36).slice(2);
+
+    // Write request
+    await Bun.write(
+      join(checkpointDir, "req-" + requestId + ".json"),
+      JSON.stringify({ requestId, name, sequenceNumber: seq })
+    );
+
+    // Poll for response
+    let response = null;
+    const responsePath = join(checkpointDir, "res-" + requestId + ".json");
+    while (!response) {
+      try {
+        response = JSON.parse(await Bun.file(responsePath).text());
+      } catch {
+        await Bun.sleep(5);
+      }
+    }
+
+    if (response.hit && response.data !== undefined) {
+      return JSON.parse(response.data);
+    }
+
+    // Cache miss: execute function
+    try {
+      const result = await fn();
+      await Bun.write(
+        join(checkpointDir, "result-" + requestId + ".json"),
+        JSON.stringify({ requestId, data: JSON.stringify(result) })
+      );
+      return result;
+    } catch (err) {
+      // Write failure file for parent to consume before re-throwing
+      await Bun.write(
+        join(checkpointDir, "failure-" + requestId + ".json"),
+        JSON.stringify({
+          requestId,
+          name,
+          sequenceNumber: seq,
+          error: JSON.stringify(serializeError(err)),
+        })
+      );
+      throw err;
+    }
+  };
+}
+
+async function main() {
+  try {
+    const inputFile = process.env.CF_STEP_INPUT_FILE;
+    const outputFile = process.env.STEP_OUTPUT_FILE;
+    const checkpointDir = process.env.CF_CHECKPOINT_DIR;
+
+    if (!inputFile) {
+      throw new Error("CF_STEP_INPUT_FILE environment variable is required");
+    }
+    if (!outputFile) {
+      throw new Error("STEP_OUTPUT_FILE environment variable is required");
+    }
+
+    const input = await Bun.file(inputFile).text();
+    const { stepPath, dependencies, ctx } = JSON.parse(input);
+
+    const checkpoint = createCheckpointFunction(checkpointDir);
+    const reconstructedCtx = { ...ctx, log: console.log, checkpoint };
+
+    // Load and execute the step
+    const mod = await import(pathToFileURL(stepPath).toString());
+    const stepDef = mod.step;
+
+    if (!stepDef || typeof stepDef.fn !== "function") {
+      throw new Error("Invalid step module at " + stepPath);
+    }
+
+    const result = await stepDef.fn({ dependencies, ctx: reconstructedCtx });
+    await Bun.write(outputFile, JSON.stringify(result, null, 2));
+    process.exit(0);
+  } catch (error) {
+    const errObj = error instanceof Error
+      ? { message: error.message, stack: error.stack, name: error.name }
+      : { message: String(error), name: "Error" };
+    process.stderr.write(JSON.stringify(errObj));
+    process.exit(1);
+  }
+}
+
+main();
+`;
+function createStreamHandler(streamType, attemptNumber, emitLog) {
+  let buffer = "";
+  const handler = (chunk) => {
+    buffer += chunk.toString();
+    const lines = buffer.split(`
+`);
+    buffer = lines.pop() || "";
+    for (const line of lines) {
+      if (!line.trim())
+        continue;
+      const timestamp = getMicrosecondTimestamp();
+      emitLog({
+        timestamp,
+        stream: streamType,
+        message: line,
+        attemptNumber
+      });
+    }
+  };
+  const getBuffer = () => buffer;
+  const flushBuffer = () => {
+    if (buffer.trim()) {
+      emitLog({
+        timestamp: getMicrosecondTimestamp(),
+        stream: streamType,
+        message: buffer,
+        attemptNumber
+      });
+      buffer = "";
+    }
+  };
+  return { handler, getBuffer, flushBuffer };
+}
+function startCheckpointWatcher(dir, existing, onCheckpoint, onCheckpointFailed) {
+  const processed = new Set;
+  let running = true;
+  const poll = async () => {
+    while (running) {
+      try {
+        const files = await readdir(dir);
+        for (const file of files) {
+          if (file.startsWith("failure-") && !processed.has(file)) {
+            processed.add(file);
+            try {
+              const content = await readFile(join2(dir, file), "utf-8");
+              const failure = JSON.parse(content);
+              if (onCheckpointFailed) {
+                await onCheckpointFailed({
+                  name: failure.name,
+                  sequenceNumber: failure.sequenceNumber,
+                  error: failure.error
+                });
+              }
+            } catch {}
+            continue;
+          }
+          if (!file.startsWith("req-") || processed.has(file))
+            continue;
+          processed.add(file);
+          try {
+            const content = await readFile(join2(dir, file), "utf-8");
+            const request = JSON.parse(content);
+            const cached = existing?.get(request.name)?.[request.sequenceNumber];
+            if (cached !== undefined) {
+              const response = {
+                requestId: request.requestId,
+                hit: true,
+                data: cached
+              };
+              await writeFile(getResponsePath(dir, request.requestId), JSON.stringify(response));
+            } else {
+              const response = {
+                requestId: request.requestId,
+                hit: false
+              };
+              await writeFile(getResponsePath(dir, request.requestId), JSON.stringify(response));
+              let result = null;
+              let failed = false;
+              const resultPath = getResultPath(dir, request.requestId);
+              const failurePath = getFailurePath(dir, request.requestId);
+              while (running && !result && !failed) {
+                try {
+                  const resultContent = await readFile(resultPath, "utf-8");
+                  result = JSON.parse(resultContent);
+                } catch {
+                  try {
+                    await readFile(failurePath, "utf-8");
+                    failed = true;
+                  } catch {
+                    await new Promise((resolve2) => setTimeout(resolve2, 5));
+                  }
+                }
+              }
+              if (result && onCheckpoint) {
+                if (!existing.has(request.name)) {
+                  existing.set(request.name, []);
+                }
+                const arr = existing.get(request.name);
+                arr[request.sequenceNumber] = result.data;
+                await onCheckpoint({
+                  name: request.name,
+                  sequenceNumber: request.sequenceNumber,
+                  data: result.data
+                });
+              }
+            }
+          } catch (e) {}
+        }
+      } catch {}
+      await new Promise((resolve2) => setTimeout(resolve2, 10));
+    }
+  };
+  poll().catch(() => {});
+  return {
+    stop: () => {
+      running = false;
+    }
+  };
+}
+async function executeStepInSubprocess(stepFile, stepId, dependencies, ctx, attemptNumber, outputPath, onLog, onCheckpoint, onCheckpointFailed, existingCheckpoints, options) {
+  await mkdir(dirname(outputPath), { recursive: true });
+  const executorPath = resolve(dirname(fileURLToPath(import.meta.url)), "step-executor.ts");
+  let spawnArgs;
+  let tempExecutorPath = null;
+  const stepInput = JSON.stringify({ stepPath: stepFile, dependencies, ctx });
+  const inputFilePath = join2(tmpdir(), `cf-step-input-${Date.now()}-${Math.random().toString(36).slice(2)}.json`);
+  await writeFile(inputFilePath, stepInput);
+  try {
+    await access(executorPath);
+    spawnArgs = ["bun", [executorPath]];
+  } catch {
+    tempExecutorPath = join2(tmpdir(), `cf-step-executor-${Date.now()}-${Math.random().toString(36).slice(2)}.ts`);
+    await writeFile(tempExecutorPath, EMBEDDED_STEP_EXECUTOR);
+    spawnArgs = ["bun", [tempExecutorPath]];
+  }
+  let checkpointDir;
+  let checkpointWatcher;
+  const checkpointCache = existingCheckpoints ?? new Map;
+  if (onCheckpoint || onCheckpointFailed || existingCheckpoints) {
+    checkpointDir = join2(tmpdir(), `cf-checkpoint-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    await mkdir(checkpointDir, { recursive: true });
+    checkpointWatcher = startCheckpointWatcher(checkpointDir, checkpointCache, onCheckpoint, onCheckpointFailed);
+  }
+  return new Promise((resolve2, reject) => {
+    const child = spawn(spawnArgs[0], spawnArgs[1], {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        STEP_OUTPUT_FILE: outputPath,
+        CF_STEP_INPUT_FILE: inputFilePath,
+        ...checkpointDir ? { CF_CHECKPOINT_DIR: checkpointDir } : {}
+      }
+    });
+    const logs = [];
+    const logWritePromises = [];
+    let logError = null;
+    const emitLog = (entry) => {
+      logs.push(entry);
+      if (!onLog)
+        return;
+      const trackedPromise = Promise.resolve(onLog(entry)).catch((err) => {
+        if (!logError) {
+          logError = err instanceof Error ? err : new Error(String(err));
+        }
+      });
+      logWritePromises.push(trackedPromise);
+    };
+    const signal = options?.signal;
+    let aborted = false;
+    let abortReason;
+    const abortHandler = signal ? () => {
+      if (aborted)
+        return;
+      aborted = true;
+      abortReason = signal?.reason ?? new Error("Step execution aborted");
+      try {
+        child.kill("SIGKILL");
+      } catch {}
+    } : null;
+    const cleanup = () => {
+      if (signal && abortHandler) {
+        signal.removeEventListener("abort", abortHandler);
+      }
+    };
+    if (signal) {
+      if (signal.aborted) {
+        abortHandler?.();
+      } else {
+        signal.addEventListener("abort", abortHandler);
+      }
+    }
+    const stdoutHandler = createStreamHandler("stdout", attemptNumber, emitLog);
+    const stderrHandler = createStreamHandler("stderr", attemptNumber, emitLog);
+    child.stdout.on("data", stdoutHandler.handler);
+    child.stderr.on("data", stderrHandler.handler);
+    child.on("error", (err) => {
+      cleanup();
+      reject(err);
+    });
+    child.on("close", async (code, signal2) => {
+      cleanup();
+      if (checkpointWatcher) {
+        checkpointWatcher.stop();
+      }
+      if (tempExecutorPath) {
+        try {
+          await unlink(tempExecutorPath);
+        } catch {}
+      }
+      try {
+        await unlink(inputFilePath);
+      } catch {}
+      if (checkpointDir) {
+        try {
+          await rm(checkpointDir, { recursive: true, force: true });
+        } catch {}
+      }
+      stdoutHandler.flushBuffer();
+      stderrHandler.flushBuffer();
+      try {
+        await Promise.all(logWritePromises);
+      } catch {}
+      if (logError) {
+        reject(logError);
+        return;
+      }
+      if (aborted) {
+        const reason = abortReason instanceof Error ? abortReason : new Error(String(abortReason ?? "Step execution aborted"));
+        reject(reason);
+        return;
+      }
+      if (code === 0) {
+        try {
+          const outputContent = await readFile(outputPath, "utf-8");
+          const result = JSON.parse(outputContent);
+          try {
+            await unlink(outputPath);
+          } catch {}
+          resolve2({ result, logs });
+        } catch (err) {
+          reject(new Error(`Failed to read/parse output file ${outputPath}: ${err}`));
+        }
+      } else if (signal2) {
+        const error = new Error(`Step process killed by signal: ${signal2}`);
+        error.isCrash = true;
+        reject(error);
+      } else {
+        const lastStderrLog = logs.filter((l) => l.stream === "stderr").pop();
+        if (lastStderrLog) {
+          try {
+            const errorObj = JSON.parse(lastStderrLog.message);
+            const errorMessage = ensureErrorMessage(errorObj.message);
+            const error = new Error(errorMessage);
+            error.stack = errorObj.stack;
+            error.name = errorObj.name || "Error";
+            reject(error);
+          } catch {
+            const errorMessage = logs.filter((l) => l.stream === "stderr").map((l) => l.message).join(`
+`);
+            reject(new Error(errorMessage || `Step process exited with code ${code}`));
+          }
+        } else {
+          reject(new Error(`Step process exited with code ${code}`));
+        }
+      }
+    });
+    child.stdin.end();
+  });
+}
 
 // src/discovery.ts
 import fs from "node:fs/promises";
@@ -12626,202 +13021,24 @@ async function discoverSteps(root = path.resolve("steps")) {
   }
   return loaded;
 }
-
-// src/validation.ts
-function detectCycles(steps) {
-  const visiting = new Set;
-  const visited = new Set;
-  function dfs(s) {
-    if (visited.has(s.id))
-      return;
-    if (visiting.has(s.id)) {
-      throw new Error(`Cycle detected involving step "${s.name}" (id: ${s.id})`);
-    }
-    visiting.add(s.id);
-    for (const dep of Object.values(s.dependencies))
-      dfs(dep);
-    visiting.delete(s.id);
-    visited.add(s.id);
-  }
-  for (const s of steps)
-    dfs(s);
-}
-
-// src/subprocess-executor.ts
-import { spawn } from "node:child_process";
-import { resolve, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import { mkdir, readFile, unlink } from "node:fs/promises";
-import { getMicrosecondTimestamp, ensureErrorMessage } from "@cascade-flow/backend-interface";
-function createStreamHandler(streamType, attemptNumber, emitLog) {
-  let buffer = "";
-  const handler = (chunk) => {
-    buffer += chunk.toString();
-    const lines = buffer.split(`
-`);
-    buffer = lines.pop() || "";
-    for (const line of lines) {
-      if (!line.trim())
-        continue;
-      const timestamp = getMicrosecondTimestamp();
-      emitLog({
-        timestamp,
-        stream: streamType,
-        message: line,
-        attemptNumber
-      });
-    }
-  };
-  const getBuffer = () => buffer;
-  const flushBuffer = () => {
-    if (buffer.trim()) {
-      emitLog({
-        timestamp: getMicrosecondTimestamp(),
-        stream: streamType,
-        message: buffer,
-        attemptNumber
-      });
-      buffer = "";
-    }
-  };
-  return { handler, getBuffer, flushBuffer };
-}
-async function executeStepInSubprocess(stepFile, stepId, dependencies, ctx, attemptNumber, outputPath, onLog, options) {
-  const executorPath = resolve(dirname(fileURLToPath(import.meta.url)), "step-executor");
-  await mkdir(dirname(outputPath), { recursive: true });
-  return new Promise((resolve2, reject) => {
-    const child = spawn("bun", [executorPath], {
-      stdio: ["pipe", "pipe", "pipe"],
-      env: {
-        ...process.env,
-        STEP_OUTPUT_FILE: outputPath
-      }
-    });
-    const logs = [];
-    const logWritePromises = [];
-    let logError = null;
-    const emitLog = (entry) => {
-      logs.push(entry);
-      if (!onLog)
-        return;
-      const trackedPromise = Promise.resolve(onLog(entry)).catch((err) => {
-        if (!logError) {
-          logError = err instanceof Error ? err : new Error(String(err));
-        }
-      });
-      logWritePromises.push(trackedPromise);
-    };
-    const signal = options?.signal;
-    let aborted2 = false;
-    let abortReason;
-    const abortHandler = signal ? () => {
-      if (aborted2)
-        return;
-      aborted2 = true;
-      abortReason = signal?.reason ?? new Error("Step execution aborted");
-      try {
-        child.kill("SIGKILL");
-      } catch {}
-    } : null;
-    const cleanup = () => {
-      if (signal && abortHandler) {
-        signal.removeEventListener("abort", abortHandler);
-      }
-    };
-    if (signal) {
-      if (signal.aborted) {
-        abortHandler?.();
-      } else {
-        signal.addEventListener("abort", abortHandler);
-      }
-    }
-    const stdoutHandler = createStreamHandler("stdout", attemptNumber, emitLog);
-    const stderrHandler = createStreamHandler("stderr", attemptNumber, emitLog);
-    child.stdout.on("data", stdoutHandler.handler);
-    child.stderr.on("data", stderrHandler.handler);
-    child.on("error", (err) => {
-      cleanup();
-      reject(err);
-    });
-    child.on("close", async (code, signal2) => {
-      cleanup();
-      stdoutHandler.flushBuffer();
-      stderrHandler.flushBuffer();
-      try {
-        await Promise.all(logWritePromises);
-      } catch {}
-      if (logError) {
-        reject(logError);
-        return;
-      }
-      if (aborted2) {
-        const reason = abortReason instanceof Error ? abortReason : new Error(String(abortReason ?? "Step execution aborted"));
-        reject(reason);
-        return;
-      }
-      if (code === 0) {
-        try {
-          const outputContent = await readFile(outputPath, "utf-8");
-          const result = JSON.parse(outputContent);
-          try {
-            await unlink(outputPath);
-          } catch {}
-          resolve2({ result, logs });
-        } catch (err) {
-          reject(new Error(`Failed to read/parse output file ${outputPath}: ${err}`));
-        }
-      } else if (signal2) {
-        const error46 = new Error(`Step process killed by signal: ${signal2}`);
-        error46.isCrash = true;
-        reject(error46);
-      } else {
-        const lastStderrLog = logs.filter((l) => l.stream === "stderr").pop();
-        if (lastStderrLog) {
-          try {
-            const errorObj = JSON.parse(lastStderrLog.message);
-            const errorMessage = ensureErrorMessage(errorObj.message);
-            const error46 = new Error(errorMessage);
-            error46.stack = errorObj.stack;
-            error46.name = errorObj.name || "Error";
-            reject(error46);
-          } catch {
-            const errorMessage = logs.filter((l) => l.stream === "stderr").map((l) => l.message).join(`
-`);
-            reject(new Error(errorMessage || `Step process exited with code ${code}`));
-          }
-        } else {
-          reject(new Error(`Step process exited with code ${code}`));
-        }
-      }
-    });
-    const input = JSON.stringify({ stepPath: stepFile, dependencies, ctx });
-    child.stdin.write(input);
-    child.stdin.end();
-  });
-}
-
-// src/index.ts
-import { getMicrosecondTimestamp as getMicrosecondTimestamp2 } from "@cascade-flow/backend-interface";
-import { Skip, isOptional as isOptional2 } from "@cascade-flow/workflow";
-
 // src/versioning.ts
 import { createHash } from "node:crypto";
-import { readFile as readFile2, readdir } from "node:fs/promises";
-import { join } from "node:path";
+import { readFile as readFile2, readdir as readdir2 } from "node:fs/promises";
+import { join as join3 } from "node:path";
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
 var execAsync = promisify(exec);
 async function calculateWorkflowHash(workflow) {
   const hash2 = createHash("sha256");
   try {
-    const workflowJsonPath = join(workflow.dir, "workflow.json");
+    const workflowJsonPath = join3(workflow.dir, "workflow.json");
     const workflowJsonContent = await readFile2(workflowJsonPath, "utf-8");
     hash2.update(`workflow.json:${workflowJsonContent}`);
   } catch (error46) {
     throw new Error(`Failed to read workflow.json for ${workflow.slug}: ${error46 instanceof Error ? error46.message : "Unknown error"}`);
   }
   try {
-    const inputSchemaPath = join(workflow.dir, "input-schema.ts");
+    const inputSchemaPath = join3(workflow.dir, "input-schema.ts");
     const inputSchemaContent = await readFile2(inputSchemaPath, "utf-8");
     hash2.update(`input-schema.ts:${inputSchemaContent}`);
   } catch (error46) {
@@ -12846,9 +13063,9 @@ async function calculateWorkflowHash(workflow) {
 async function collectStepFiles(stepsDir) {
   const files = [];
   async function scan(dir) {
-    const entries = await readdir(dir, { withFileTypes: true });
+    const entries = await readdir2(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join(dir, entry.name);
+      const fullPath = join3(dir, entry.name);
       if (entry.isDirectory()) {
         await scan(fullPath);
       } else if (entry.isFile() && entry.name === "step.ts") {
@@ -12882,332 +13099,68 @@ async function getGitInfo(workflowDir) {
     return;
   }
 }
-
-// src/index.ts
-async function executeStepInProcess(stepFile, stepId, dependencies, ctx, attemptNumber, backend, onLog, options) {
-  const outputPath = backend.getStepOutputPath(ctx.workflow.slug, ctx.runId, stepId, attemptNumber);
-  return executeStepInSubprocess(stepFile, stepId, dependencies, ctx, attemptNumber, outputPath, onLog, options);
-}
-async function runAll(options) {
-  const workflows = await discoverWorkflows();
-  if (workflows.length === 0) {
-    throw new Error('No workflows found. Please create a "workflows" directory with at least one workflow.');
-  }
-  const workflow = workflows.find((w) => w.slug === options.workflow);
-  if (!workflow) {
-    const available = workflows.map((w) => w.slug).join(", ");
-    throw new Error(`Workflow "${options.workflow}" not found. Available workflows: ${available}`);
-  }
-  const steps = await discoverSteps(workflow.stepsDir);
-  detectCycles(steps);
-  const byId = new Map(steps.map((s) => [s.id, s]));
-  const selected = options?.only?.length ? options.only.map((id) => {
-    const s = byId.get(id);
-    if (!s)
-      throw new Error(`Unknown step "${id}"`);
-    return s;
-  }) : steps;
-  const backend = options.backend;
-  const workflowSlug = workflow.slug;
-  const cache = new Map;
-  const skippedSteps = new Set;
-  const runId = options?.runId ?? `${getMicrosecondTimestamp2()}`;
-  const defaultCtx = {
-    runId,
-    workflow: {
-      slug: workflow.slug,
-      name: workflow.name
-    },
-    input: undefined,
-    log: (...args) => console.log("[runner]", ...args),
-    ...options?.ctx
-  };
-  const workflowStartTime = getMicrosecondTimestamp2();
-  await backend.initializeRun(workflowSlug, runId);
-  const versionId = await calculateWorkflowHash(workflow);
-  const git = await getGitInfo(workflow.dir);
-  const stepManifest = steps.map((s) => s.id);
-  await backend.createWorkflowVersion({
-    workflowSlug,
-    versionId,
-    createdAt: getMicrosecondTimestamp2(),
-    stepManifest,
-    totalSteps: steps.length,
-    git
-  });
-  const hasInputSchema = workflow.inputSchema !== undefined;
-  const hasInput = options.input !== undefined;
-  await backend.saveWorkflowStart(workflowSlug, runId, {
-    versionId,
-    workflowAttemptNumber: 1,
-    hasInputSchema,
-    hasInput
-  });
-  let validatedInput = undefined;
-  if (workflow.inputSchema) {
-    const parseResult = workflow.inputSchema.safeParse(options.input ?? {});
-    if (!parseResult.success) {
-      const validationErrors = parseResult.error.issues.map((e) => ({
-        path: e.path.join("."),
-        message: e.message
-      }));
-      const errorMessage = validationErrors.map((e) => `  ${e.path}: ${e.message}`).join(`
-`);
-      const error46 = {
-        name: "ValidationError",
-        message: `Invalid workflow input:
-${errorMessage}`
-      };
-      await backend.saveWorkflowInputValidation(workflowSlug, runId, {
-        workflowAttemptNumber: 1,
-        hasSchema: true,
-        success: false,
-        error: error46,
-        validationErrors
-      });
-      const duration3 = getMicrosecondTimestamp2() - workflowStartTime;
-      await backend.saveWorkflowFailed(workflowSlug, runId, error46, {
-        workflowAttemptNumber: 1,
-        duration: duration3,
-        completedSteps: 0
-      }, "step-failed");
-      throw new Error(error46.message);
-    }
-    validatedInput = parseResult.data;
-  } else if (options.input !== undefined) {
-    validatedInput = options.input;
-  }
-  defaultCtx.input = validatedInput;
-  if (hasInputSchema || hasInput) {
-    await backend.saveWorkflowInputValidation(workflowSlug, runId, {
-      workflowAttemptNumber: 1,
-      hasSchema: hasInputSchema,
-      success: true
-    });
-  }
-  if (options?.resume) {
-    defaultCtx.log(`Resuming run ${defaultCtx.runId}...`);
-    const workflowEvents = await backend.loadEvents(workflowSlug, defaultCtx.runId, { category: "workflow" });
-    const workflowStartedEvent = workflowEvents.find((e) => e.type === "WorkflowStarted");
-    if (workflowStartedEvent && workflowStartedEvent.type === "WorkflowStarted") {
-      const previousVersionId = workflowStartedEvent.versionId;
-      if (previousVersionId !== versionId) {
-        const previousVersion = await backend.getWorkflowVersion(workflowSlug, previousVersionId);
-        const currentVersion = await backend.getWorkflowVersion(workflowSlug, versionId);
-        defaultCtx.log(`⚠️  Workflow definition changed since original run`);
-        defaultCtx.log(`   Original: ${previousVersionId}`);
-        defaultCtx.log(`   Current:  ${versionId}`);
-        if (previousVersion?.git && currentVersion?.git) {
-          defaultCtx.log(`   Git: ${previousVersion.git.commit} → ${currentVersion.git.commit}`);
-        }
-      }
-    }
-    const existingRecords = await backend.loadRun(workflowSlug, defaultCtx.runId);
-    let resumedSteps = 0;
-    for (const record2 of existingRecords) {
-      if (record2.status === "completed" && record2.output !== undefined && record2.output !== null) {
-        try {
-          const output = JSON.parse(record2.output);
-          cache.set(record2.stepId, Promise.resolve(output));
-          const step = steps.find((s) => s.id === record2.stepId);
-          const displayName = step?.name ?? record2.stepId;
-          defaultCtx.log(`✓ ${displayName} (resumed from cache)`);
-          resumedSteps++;
-        } catch (err) {
-          const step = steps.find((s) => s.id === record2.stepId);
-          const displayName = step?.name ?? record2.stepId;
-          defaultCtx.log(`⚠ Failed to deserialize ${displayName}, will re-run`);
-        }
-      }
-    }
-    const pendingSteps = steps.length - resumedSteps;
-    await backend.saveWorkflowResumed(workflowSlug, defaultCtx.runId, {
-      originalRunId: defaultCtx.runId,
-      resumedSteps,
-      pendingSteps
-    });
-  }
-  async function execute(step, stack = []) {
-    const existing = cache.get(step.id);
-    if (existing)
-      return existing;
-    const p = (async () => {
-      const startTime = getMicrosecondTimestamp2();
-      await backend.saveStepStart(workflowSlug, defaultCtx.runId, step.id, "local", {
-        dependencies: Object.keys(step.dependencies),
-        timestamp: startTime,
-        attemptNumber: 1
-      });
-      defaultCtx.log(`→ ${step.name} (waiting deps: ${Object.keys(step.dependencies).join(", ") || "none"})`);
-      try {
-        const depEntries = Object.entries(step.dependencies);
-        const depOutputsPairs = await Promise.all(depEntries.map(async ([alias, dep]) => {
-          const output = await execute(dep, [...stack, step.id]);
-          const isSkipped = skippedSteps.has(dep.id);
-          const isOptionalDep = isOptional2(step.dependencies[alias]);
-          return [alias, isSkipped && isOptionalDep ? undefined : output];
-        }));
-        const depOutputs = Object.fromEntries(depOutputsPairs);
-        const skippedRequiredDeps = depEntries.filter(([alias, dep]) => {
-          const isSkipped = skippedSteps.has(dep.id);
-          const isOptionalDep = isOptional2(step.dependencies[alias]);
-          return isSkipped && !isOptionalDep;
-        });
-        if (skippedRequiredDeps.length > 0) {
-          const cascadedFromStep = skippedRequiredDeps[0][1];
-          const endTime2 = getMicrosecondTimestamp2();
-          await backend.saveStepSkipped(workflowSlug, defaultCtx.runId, step.id, {
-            skipType: "cascade",
-            reason: `Dependency '${cascadedFromStep.name}' was skipped`,
-            duration: endTime2 - startTime,
-            attemptNumber: 1,
-            cascadedFrom: cascadedFromStep.id
-          });
-          skippedSteps.add(step.id);
-          defaultCtx.log(`⊘ ${step.name} (skipped: dependency '${cascadedFromStep.name}' was skipped)`);
-          return {};
-        }
-        const stepFile = join2(step.dir, "step.ts");
-        const maxRetries = step.maxRetries ?? 0;
-        let lastError = null;
-        for (let attemptNumber = 1;attemptNumber <= maxRetries + 1; attemptNumber++) {
-          try {
-            const { result, logs } = await executeStepInProcess(stepFile, step.id, depOutputs, defaultCtx, attemptNumber, backend);
-            const endTime2 = getMicrosecondTimestamp2();
-            await backend.saveStepComplete(workflowSlug, defaultCtx.runId, step.id, result, {
-              timestamp: endTime2,
-              duration: endTime2 - startTime,
-              logs: logs.length > 0 ? logs : undefined,
-              attemptNumber,
-              output: result
-            }, step.exportOutput ?? false);
-            defaultCtx.log(`✓ ${step.name}`);
-            return result;
-          } catch (err) {
-            lastError = err instanceof Error ? err : new Error(String(err));
-            if (lastError.name === "Skip" || lastError instanceof Skip) {
-              const endTime2 = getMicrosecondTimestamp2();
-              const skipError = lastError;
-              await backend.saveStepSkipped(workflowSlug, defaultCtx.runId, step.id, {
-                skipType: "primary",
-                reason: skipError.reason || skipError.message.replace("Step skipped: ", ""),
-                metadata: skipError.metadata,
-                duration: endTime2 - startTime,
-                attemptNumber
-              });
-              skippedSteps.add(step.id);
-              defaultCtx.log(`⊘ ${step.name} (skipped: ${skipError.reason || skipError.message})`);
-              return {};
-            }
-            if (attemptNumber <= maxRetries) {
-              const error47 = {
-                message: lastError.message,
-                stack: lastError.stack,
-                name: lastError.name
-              };
-              const retryEvent = {
-                category: "step",
-                eventId: "",
-                timestampUs: getMicrosecondTimestamp2(),
-                workflowSlug,
-                runId: defaultCtx.runId,
-                stepId: step.id,
-                type: "StepRetrying",
-                attemptNumber,
-                nextAttempt: attemptNumber + 1,
-                error: error47,
-                maxRetries
-              };
-              await backend.appendEvent(workflowSlug, defaultCtx.runId, retryEvent);
-              defaultCtx.log(`⟳ ${step.name} retry ${attemptNumber + 1}/${maxRetries + 1} after error: ${error47.message}`);
-            }
-          }
-        }
-        const error46 = {
-          message: lastError.message,
-          stack: lastError.stack,
-          name: lastError.name
-        };
-        const failureReason = lastError.isCrash ? "worker-crash" : "exhausted-retries";
-        const endTime = getMicrosecondTimestamp2();
-        await backend.saveStepFailed(workflowSlug, defaultCtx.runId, step.id, error46, {
-          duration: endTime - startTime,
-          attemptNumber: maxRetries + 1,
-          terminal: true,
-          failureReason
-        });
-        defaultCtx.log(`✗ ${step.name} failed after ${maxRetries + 1} attempts: ${error46.message}`);
-        throw lastError;
-      } catch (err) {
-        throw err;
-      }
-    })();
-    cache.set(step.id, p);
-    return p;
-  }
-  try {
-    await Promise.all(selected.map((s) => execute(s)));
-    const results = {};
-    for (const s of steps) {
-      if (s.exportOutput && !skippedSteps.has(s.id)) {
-        const val = cache.get(s.id);
-        if (val)
-          results[s.id] = await val;
-      }
-    }
-    const workflowEndTime = getMicrosecondTimestamp2();
-    const workflowDuration = workflowEndTime - workflowStartTime;
-    await backend.saveWorkflowComplete(workflowSlug, defaultCtx.runId, results, {
-      workflowAttemptNumber: 1,
-      timestamp: workflowEndTime,
-      duration: workflowDuration,
-      totalSteps: steps.length
-    });
-    return results;
-  } catch (err) {
-    const workflowEndTime = getMicrosecondTimestamp2();
-    const workflowDuration = workflowEndTime - workflowStartTime;
-    let completedSteps = 0;
-    for (const s of steps) {
-      const val = cache.get(s.id);
-      if (val) {
-        try {
-          await val;
-          completedSteps++;
-        } catch {}
-      }
-    }
-    let failedStep;
-    if (err instanceof Error && err.message) {
-      for (const s of steps) {
-        if (err.message.includes(s.name) || err.message.includes(s.id)) {
-          failedStep = s.id;
-          break;
-        }
+// src/validation.ts
+function getAllDependents(targetStepId, allSteps) {
+  const dependentsMap = new Map;
+  for (const step of allSteps) {
+    for (const depStep of Object.values(step.dependencies)) {
+      if (!dependentsMap.has(depStep.id)) {
+        dependentsMap.set(depStep.id, []);
       }
+      dependentsMap.get(depStep.id).push(step.id);
     }
-    const error46 = {
-      message: err instanceof Error ? err.message : String(err),
-      stack: err instanceof Error ? err.stack : undefined,
-      name: err instanceof Error ? err.name : undefined
-    };
-    const failureReason = err.isCrash ? "worker-crash" : "step-failed";
-    await backend.saveWorkflowFailed(workflowSlug, defaultCtx.runId, error46, {
-      workflowAttemptNumber: 1,
-      duration: workflowDuration,
-      completedSteps,
-      failedStep
-    }, failureReason);
-    throw err;
   }
+  const allDependents = new Set;
+  const visited = new Set;
+  function dfs(stepId) {
+    if (visited.has(stepId))
+      return;
+    visited.add(stepId);
+    const dependents = dependentsMap.get(stepId) || [];
+    for (const dependent of dependents) {
+      allDependents.add(dependent);
+      dfs(dependent);
+    }
+  }
+  dfs(targetStepId);
+  return allDependents;
+}
+async function validateWorkflowVersion(workflowSlug, parentRunId, currentVersionId, backend, log) {
+  const workflowEvents = await backend.loadEvents(workflowSlug, parentRunId, { category: "workflow" });
+  const workflowStartedEvent = workflowEvents.find((e) => e.type === "WorkflowStarted");
+  if (!workflowStartedEvent || workflowStartedEvent.type !== "WorkflowStarted") {
+    throw new Error(`Parent run ${parentRunId} has no WorkflowStarted event`);
+  }
+  const parentVersionId = workflowStartedEvent.versionId;
+  if (parentVersionId !== currentVersionId && log) {
+    const previousVersion = await backend.getWorkflowVersion(workflowSlug, parentVersionId);
+    const currentVersion = await backend.getWorkflowVersion(workflowSlug, currentVersionId);
+    const message = [
+      `ℹ️  Workflow definition changed since parent run`,
+      `   Parent:  ${parentVersionId}`,
+      `   Current: ${currentVersionId}`
+    ];
+    if (previousVersion?.git && currentVersion?.git) {
+      message.push(`   Git: ${previousVersion.git.commit} → ${currentVersion.git.commit}`);
+    }
+    message.forEach((line) => log(line));
+  }
+  return parentVersionId;
+}
+
+// src/index.ts
+async function executeStepInProcess(stepFile, stepId, dependencies, ctx, attemptNumber, backend, onLog, onCheckpoint, onCheckpointFailed, existingCheckpoints, options) {
+  const outputPath = backend.getStepOutputPath(ctx.workflow.slug, ctx.runId, stepId, attemptNumber);
+  return executeStepInSubprocess(stepFile, stepId, dependencies, ctx, attemptNumber, outputPath, onLog, onCheckpoint, onCheckpointFailed, existingCheckpoints, options);
 }
 export {
-  runAll,
+  validateWorkflowVersion,
   getGitInfo,
+  getAllDependents,
   executeStepInProcess,
   discoverWorkflows,
   discoverSteps,
   calculateWorkflowHash
 };
 
-//# debugId=0A6F5DFCD4D7954F64756E2164756E21
+//# debugId=922C5B57E7B7118364756E2164756E21