@cascade-flow/runner 0.2.4 → 0.2.5

package/dist/index.js

@@ -9,8 +9,158 @@ 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 } 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 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();
+      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}`));
+        }
+      }
+    });
+    const input = JSON.stringify({ stepPath: stepFile, dependencies, ctx });
+    child.stdin.write(input);
+    child.stdin.end();
+  });
+}
 
 // src/discovery.ts
 import fs from "node:fs/promises";
@@ -12626,184 +12776,6 @@ 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";
@@ -12882,332 +12854,68 @@ async function getGitInfo(workflowDir) {
     return;
   }
 }
+// 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 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, 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;
-        }
-      }
-    }
-    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;
-  }
-}
 export {
-  runAll,
+  validateWorkflowVersion,
   getGitInfo,
+  getAllDependents,
   executeStepInProcess,
   discoverWorkflows,
   discoverSteps,
   calculateWorkflowHash
 };
 
-//# debugId=0A6F5DFCD4D7954F64756E2164756E21
+//# debugId=6283553AC8E9AA7C64756E2164756E21