@cascade-flow/runner 0.2.5 → 0.2.7

package/dist/checkpoint-ipc.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Checkpoint IPC Types and Utilities
+ *
+ * Handles communication between the subprocess (step execution) and parent process
+ * (worker) for checkpoint operations. Uses file-based IPC for simplicity.
+ *
+ * Flow:
+ * 1. Subprocess writes request to req-{id}.json
+ * 2. Parent reads request, checks cache
+ * 3. Parent writes response to res-{id}.json (hit/miss)
+ * 4. If miss: subprocess executes fn, writes result to result-{id}.json
+ * 5. Parent persists checkpoint to backend
+ */
+/**
+ * Request from subprocess to parent for checkpoint lookup/save
+ */
+export type CheckpointRequest = {
+    requestId: string;
+    name: string;
+    sequenceNumber: number;
+};
+/**
+ * Response from parent to subprocess
+ */
+export type CheckpointResponse = {
+    requestId: string;
+    hit: boolean;
+    data?: string;
+};
+/**
+ * Result from subprocess after executing checkpoint function (on cache miss)
+ */
+export type CheckpointResult = {
+    requestId: string;
+    data: string;
+};
+/**
+ * Data passed to onCheckpoint callback
+ */
+export type CheckpointData = {
+    name: string;
+    sequenceNumber: number;
+    data: string;
+};
+/**
+ * Failure from subprocess when checkpoint function throws (on cache miss)
+ */
+export type CheckpointFailure = {
+    requestId: string;
+    name: string;
+    sequenceNumber: number;
+    error: string;
+};
+/**
+ * Data passed to onCheckpointFailed callback
+ */
+export type CheckpointFailedData = {
+    name: string;
+    sequenceNumber: number;
+    error: string;
+};
+/**
+ * Get path for checkpoint request file
+ */
+export declare function getRequestPath(dir: string, requestId: string): string;
+/**
+ * Get path for checkpoint response file
+ */
+export declare function getResponsePath(dir: string, requestId: string): string;
+/**
+ * Get path for checkpoint result file
+ */
+export declare function getResultPath(dir: string, requestId: string): string;
+/**
+ * Get path for checkpoint failure file
+ */
+export declare function getFailurePath(dir: string, requestId: string): string;
+/**
+ * Generate unique request ID for checkpoint IPC
+ */
+export declare function generateRequestId(): string;
+//# sourceMappingURL=checkpoint-ipc.d.ts.map

package/dist/checkpoint-ipc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkpoint-ipc.d.ts","sourceRoot":"","sources":["../src/checkpoint-ipc.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,OAAO,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF;;GAEG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAErE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAEtE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAEpE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAErE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C"}

package/dist/index.d.ts

@@ -1,13 +1,27 @@
 import type { Backend, LogEntry } from "@cascade-flow/backend-interface";
 import type { StepOutput, RunnerContext } from "@cascade-flow/workflow";
 import type { LoadedStep } from "./types";
+import type { CheckpointData, CheckpointFailedData } from "./checkpoint-ipc";
 export type { LoadedStep };
+export type { CheckpointData, CheckpointFailedData } from "./checkpoint-ipc";
 /**
  * Execute a step in an isolated child process
  *
  * Wrapper around executeStepInSubprocess that generates the output path.
+ *
+ * @param stepFile - Absolute path to the step.ts file
+ * @param stepId - Unique identifier of the step
+ * @param dependencies - Resolved dependency outputs
+ * @param ctx - Runner context passed to step
+ * @param attemptNumber - Current attempt number (for retries)
+ * @param backend - Backend for generating output path
+ * @param onLog - Optional callback for real-time log emission
+ * @param onCheckpoint - Optional callback for persisting checkpoints
+ * @param onCheckpointFailed - Optional callback for persisting checkpoint failures
+ * @param existingCheckpoints - Existing checkpoints to replay (name -> data[] by sequence)
+ * @param options - Additional options (signal for abort)
  */
-export declare function executeStepInProcess(stepFile: string, stepId: string, dependencies: Record<string, unknown>, ctx: RunnerContext, attemptNumber: number, backend: Backend, onLog?: (log: LogEntry) => void | Promise<void>, options?: {
+export declare function executeStepInProcess(stepFile: string, stepId: string, dependencies: Record<string, unknown>, ctx: RunnerContext, attemptNumber: number, backend: Backend, onLog?: (log: LogEntry) => void | Promise<void>, onCheckpoint?: (checkpoint: CheckpointData) => Promise<void>, onCheckpointFailed?: (checkpoint: CheckpointFailedData) => Promise<void>, existingCheckpoints?: Map<string, string[]>, options?: {
     signal?: AbortSignal;
 }): Promise<{
     result: StepOutput;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAEzE,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACxE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAG1C,YAAY,EAAE,UAAU,EAAE,CAAC;AAE3B;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACrC,GAAG,EAAE,aAAa,EAClB,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,OAAO,EAChB,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,QAAQ,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EAC/C,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,WAAW,CAAA;CAAE,GACjC,OAAO,CAAC;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,QAAQ,EAAE,CAAA;CAAE,CAAC,CAoBnD;AAGD,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAG/D,OAAO,EAAE,qBAAqB,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAGjE,OAAO,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAEzE,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACxE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,KAAK,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAG7E,YAAY,EAAE,UAAU,EAAE,CAAC;AAG3B,YAAY,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAE7E;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACrC,GAAG,EAAE,aAAa,EAClB,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,OAAO,EAChB,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,QAAQ,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EAC/C,YAAY,CAAC,EAAE,CAAC,UAAU,EAAE,cAAc,KAAK,OAAO,CAAC,IAAI,CAAC,EAC5D,kBAAkB,CAAC,EAAE,CAAC,UAAU,EAAE,oBAAoB,KAAK,OAAO,CAAC,IAAI,CAAC,EACxE,mBAAmB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAC3C,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,WAAW,CAAA;CAAE,GACjC,OAAO,CAAC;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,QAAQ,EAAE,CAAA;CAAE,CAAC,CAuBnD;AAGD,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAG/D,OAAO,EAAE,qBAAqB,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAGjE,OAAO,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -11,10 +11,151 @@ var __export = (target, all) => {
 
 // src/subprocess-executor.ts
 import { spawn } from "node:child_process";
-import { resolve, dirname } from "node:path";
+import { resolve, dirname, join as join2 } from "node:path";
 import { fileURLToPath } from "node:url";
-import { mkdir, readFile, unlink } from "node:fs/promises";
+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";
+import { AsyncLocalStorage } from "async_hooks";
+
+function serializeError(err) {
+  if (err instanceof Error) {
+    return { message: err.message, stack: err.stack, name: err.name };
+  }
+  return { message: String(err), name: "Error" };
+}
+
+// AsyncLocalStorage for checkpoint context
+const checkpointStorage = new AsyncLocalStorage();
+
+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 with parent injection
+    try {
+      const ctx = checkpointStorage.getStore();
+      let result = await fn();
+
+      // Inject parent checkpoint info if in a scope
+      if (ctx?.parent && typeof result === "object" && result !== null) {
+        result = { _parentCheckpoint: ctx.parent, ...result };
+      }
+
+      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;
+    }
+  };
+}
+
+// Run with checkpoint context
+function runWithCheckpoint(checkpointFn, fn) {
+  return checkpointStorage.run({ checkpoint: checkpointFn }, fn);
+}
+
+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);
+    }
+
+    // Execute step with checkpoint context
+    const result = await runWithCheckpoint(checkpoint, () =>
+      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) => {
@@ -48,15 +189,124 @@ function createStreamHandler(streamType, attemptNumber, emitLog) {
   };
   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");
+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("bun", [executorPath], {
+    const child = spawn(spawnArgs[0], spawnArgs[1], {
       stdio: ["pipe", "pipe", "pipe"],
       env: {
         ...process.env,
-        STEP_OUTPUT_FILE: outputPath
+        STEP_OUTPUT_FILE: outputPath,
+        CF_STEP_INPUT_FILE: inputFilePath,
+        ...checkpointDir ? { CF_CHECKPOINT_DIR: checkpointDir } : {}
       }
     });
     const logs = [];
@@ -107,6 +357,22 @@ async function executeStepInSubprocess(stepFile, stepId, dependencies, ctx, atte
     });
     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 {
@@ -156,8 +422,6 @@ async function executeStepInSubprocess(stepFile, stepId, dependencies, ctx, atte
         }
       }
     });
-    const input = JSON.stringify({ stepPath: stepFile, dependencies, ctx });
-    child.stdin.write(input);
     child.stdin.end();
   });
 }
@@ -12778,22 +13042,22 @@ async function discoverSteps(root = path.resolve("steps")) {
 }
 // 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) {
@@ -12818,9 +13082,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") {
@@ -12904,9 +13168,9 @@ async function validateWorkflowVersion(workflowSlug, parentRunId, currentVersion
 }
 
 // src/index.ts
-async function executeStepInProcess(stepFile, stepId, dependencies, ctx, attemptNumber, backend, onLog, options) {
+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, options);
+  return executeStepInSubprocess(stepFile, stepId, dependencies, ctx, attemptNumber, outputPath, onLog, onCheckpoint, onCheckpointFailed, existingCheckpoints, options);
 }
 export {
   validateWorkflowVersion,
@@ -12918,4 +13182,4 @@ export {
   calculateWorkflowHash
 };
 
-//# debugId=6283553AC8E9AA7C64756E2164756E21
+//# debugId=1B7890ED6FF9B69B64756E2164756E21