pg-workflows 0.5.0 → 0.6.1

package/README.md

@@ -441,6 +441,41 @@ await engine.resumeWorkflow({
 });
 ```
 
+### Fast-Forward
+
+Skip the current waiting step and immediately resume execution. `fastForwardWorkflow` inspects the paused step and dispatches the right internal action — `triggerEvent` for `waitFor`, timeout triggers for `delay`/`waitUntil`, resume for `pause`, and direct output writes for `poll`. If the workflow is not paused, it's a no-op.
+
+This is useful for testing, debugging, or manually advancing workflows past long waits.
+
+```typescript
+// Fast-forward a waitFor step, providing mock event data
+await engine.fastForwardWorkflow({
+  runId: run.id,
+  resourceId: 'user-123',
+  data: { approved: true, reviewer: 'admin' },
+});
+
+// Fast-forward a delay/waitUntil step (no data needed)
+await engine.fastForwardWorkflow({
+  runId: run.id,
+  resourceId: 'user-123',
+});
+
+// Fast-forward a poll step with mock result data
+await engine.fastForwardWorkflow({
+  runId: run.id,
+  resourceId: 'user-123',
+  data: { paymentId: 'pay_123', status: 'completed' },
+});
+```
+
+| Paused step type | Behavior |
+|------------------|----------|
+| `step.waitFor()` | Triggers the event with `data` (defaults to `{}`) |
+| `step.delay()` / `step.waitUntil()` | Triggers the timeout event to skip the wait |
+| `step.poll()` | Writes `data` as the poll result and triggers resolution |
+| `step.pause()` | Delegates to `resumeWorkflow()` |
+
 ---
 
 ## Examples
@@ -588,6 +623,7 @@ When `boss` is omitted, pg-boss is created automatically with an isolated schema
 | `resumeWorkflow({ runId, resourceId?, options? })` | Resume a paused workflow |
 | `cancelWorkflow({ runId, resourceId? })` | Cancel a workflow |
 | `triggerEvent({ runId, resourceId?, eventName, data?, options? })` | Send an event to a workflow |
+| `fastForwardWorkflow({ runId, resourceId?, data? })` | Skip the current waiting step and resume execution |
 | `getRun({ runId, resourceId? })` | Get workflow run details |
 | `checkProgress({ runId, resourceId? })` | Get workflow progress |
 | `getRuns(filters)` | List workflow runs with pagination |

package/dist/index.cjs

@@ -271,15 +271,23 @@ async function runMigrations(db) {
         job_id varchar(256)
       );
     `, []);
-    await db.executeSql(`
-      CREATE INDEX workflow_runs_workflow_id_idx ON workflow_runs USING btree (workflow_id);
-    `, []);
     await db.executeSql(`
       CREATE INDEX workflow_runs_created_at_idx ON workflow_runs USING btree (created_at);
+      CREATE INDEX workflow_runs_resource_id_created_at_idx ON workflow_runs USING btree (resource_id, created_at DESC);
+      CREATE INDEX workflow_runs_status_created_at_idx ON workflow_runs USING btree (status, created_at DESC);
+      CREATE INDEX workflow_runs_workflow_id_created_at_idx ON workflow_runs USING btree (workflow_id, created_at DESC);
+      CREATE INDEX workflow_runs_resource_id_workflow_id_created_at_idx ON workflow_runs USING btree (resource_id, workflow_id, created_at DESC);
     `, []);
+  } else {
     await db.executeSql(`
-      CREATE INDEX workflow_runs_resource_id_idx ON workflow_runs USING btree (resource_id);
-    `, []);
+      DROP INDEX IF EXISTS workflow_runs_workflow_id_idx;
+      DROP INDEX IF EXISTS workflow_runs_resource_id_idx;
+      CREATE INDEX IF NOT EXISTS workflow_runs_created_at_idx ON workflow_runs USING btree (created_at);
+      CREATE INDEX IF NOT EXISTS workflow_runs_resource_id_created_at_idx ON workflow_runs USING btree (resource_id, created_at DESC);
+      CREATE INDEX IF NOT EXISTS workflow_runs_status_created_at_idx ON workflow_runs USING btree (status, created_at DESC);
+      CREATE INDEX IF NOT EXISTS workflow_runs_workflow_id_created_at_idx ON workflow_runs USING btree (workflow_id, created_at DESC);
+      CREATE INDEX IF NOT EXISTS workflow_runs_resource_id_workflow_id_created_at_idx ON workflow_runs USING btree (resource_id, workflow_id, created_at DESC);
+      `, []);
   }
 }
 
@@ -322,13 +330,13 @@ async function insertWorkflowRun({
   const runId = generateKSUID("run");
   const now = new Date;
   const result = await db.executeSql(`INSERT INTO workflow_runs (
-      id, 
-      resource_id, 
-      workflow_id, 
-      current_step_id, 
-      status, 
-      input, 
-      max_retries, 
+      id,
+      resource_id,
+      workflow_id,
+      current_step_id,
+      status,
+      input,
+      max_retries,
       timeout_at,
       created_at,
       updated_at,
@@ -375,7 +383,8 @@ async function getWorkflowRun({
 async function updateWorkflowRun({
   runId,
   resourceId,
-  data
+  data,
+  expectedStatuses
 }, db) {
   const now = new Date;
   const updates = ["updated_at = $1"];
@@ -431,10 +440,20 @@ async function updateWorkflowRun({
     values.push(data.jobId);
     paramIndex++;
   }
-  const whereClause = resourceId ? `WHERE id = $${paramIndex} AND resource_id = $${paramIndex + 1}` : `WHERE id = $${paramIndex}`;
   values.push(runId);
+  const idParam = paramIndex;
+  paramIndex++;
   if (resourceId) {
     values.push(resourceId);
+    paramIndex++;
+  }
+  if (expectedStatuses && expectedStatuses.length > 0) {
+    values.push(expectedStatuses);
+    paramIndex++;
+  }
+  let whereClause = resourceId ? `WHERE id = $${idParam} AND resource_id = $${idParam + 1}` : `WHERE id = $${idParam}`;
+  if (expectedStatuses && expectedStatuses.length > 0) {
+    whereClause += ` AND status = ANY($${paramIndex - 1})`;
   }
   const query = `
     UPDATE workflow_runs 
@@ -475,37 +494,50 @@ async function getWorkflowRuns({
     values.push(workflowId);
     paramIndex++;
   }
-  if (startingAfter) {
-    const cursorResult = await db.executeSql("SELECT created_at FROM workflow_runs WHERE id = $1 LIMIT 1", [startingAfter]);
-    if (cursorResult.rows[0]?.created_at) {
-      conditions.push(`created_at < $${paramIndex}`);
-      values.push(typeof cursorResult.rows[0].created_at === "string" ? new Date(cursorResult.rows[0].created_at) : cursorResult.rows[0].created_at);
-      paramIndex++;
+  const cursorIds = [startingAfter, endingBefore].filter(Boolean);
+  if (cursorIds.length > 0) {
+    const cursorResult = await db.executeSql("SELECT id, created_at FROM workflow_runs WHERE id = ANY($1)", [cursorIds]);
+    const cursorMap = new Map;
+    for (const row of cursorResult.rows) {
+      cursorMap.set(row.id, typeof row.created_at === "string" ? new Date(row.created_at) : row.created_at);
     }
-  }
-  if (endingBefore) {
-    const cursorResult = await db.executeSql("SELECT created_at FROM workflow_runs WHERE id = $1 LIMIT 1", [endingBefore]);
-    if (cursorResult.rows[0]?.created_at) {
-      conditions.push(`created_at > $${paramIndex}`);
-      values.push(typeof cursorResult.rows[0].created_at === "string" ? new Date(cursorResult.rows[0].created_at) : cursorResult.rows[0].created_at);
-      paramIndex++;
+    if (startingAfter) {
+      const cursor = cursorMap.get(startingAfter);
+      if (cursor) {
+        conditions.push(`created_at < $${paramIndex}`);
+        values.push(cursor);
+        paramIndex++;
+      }
+    }
+    if (endingBefore) {
+      const cursor = cursorMap.get(endingBefore);
+      if (cursor) {
+        conditions.push(`created_at > $${paramIndex}`);
+        values.push(cursor);
+        paramIndex++;
+      }
     }
   }
   const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
   const actualLimit = Math.min(Math.max(limit, 1), 100) + 1;
+  const isBackward = !!endingBefore && !startingAfter;
   const query = `
     SELECT * FROM workflow_runs
     ${whereClause}
-    ORDER BY created_at DESC
+    ORDER BY created_at ${isBackward ? "ASC" : "DESC"}
     LIMIT $${paramIndex}
   `;
   values.push(actualLimit);
   const result = await db.executeSql(query, values);
   const rows = result.rows;
-  const hasMore = rows.length > (limit ?? 20);
-  const rawItems = hasMore ? rows.slice(0, limit) : rows;
+  const hasExtraRow = rows.length > (limit ?? 20);
+  const rawItems = hasExtraRow ? rows.slice(0, limit) : rows;
+  if (isBackward) {
+    rawItems.reverse();
+  }
   const items = rawItems.map((row) => mapRowToWorkflowRun(row));
-  const hasPrev = !!endingBefore;
+  const hasMore = isBackward ? items.length > 0 : hasExtraRow;
+  const hasPrev = isBackward ? hasExtraRow : !!startingAfter && items.length > 0;
   const nextCursor = hasMore && items.length > 0 ? items[items.length - 1]?.id ?? null : null;
   const prevCursor = hasPrev && items.length > 0 ? items[0]?.id ?? null : null;
   return { items, nextCursor, prevCursor, hasMore, hasPrev };
@@ -711,7 +743,8 @@ class WorkflowEngine {
       data: {
         status: "paused" /* PAUSED */,
         pausedAt: new Date
-      }
+      },
+      expectedStatuses: ["running" /* RUNNING */, "pending" /* PENDING */]
     });
     this.logger.log("Paused workflow run", {
       runId,
@@ -725,6 +758,10 @@ class WorkflowEngine {
     options
   }) {
     await this.checkIfHasStarted();
+    const current = await this.getRun({ runId, resourceId });
+    if (current.status !== "paused" /* PAUSED */) {
+      throw new WorkflowEngineError(`Cannot resume workflow run in '${current.status}' status, must be 'paused'`, current.workflowId, runId);
+    }
     return this.triggerEvent({
       runId,
       resourceId,
@@ -733,6 +770,51 @@ class WorkflowEngine {
       options
     });
   }
+  async fastForwardWorkflow({
+    runId,
+    resourceId,
+    data
+  }) {
+    await this.checkIfHasStarted();
+    const run = await this.getRun({ runId, resourceId });
+    if (run.status !== "paused" /* PAUSED */) {
+      return run;
+    }
+    const stepId = run.currentStepId;
+    const waitForStep = this.getWaitForStepEntry(run.timeline, stepId);
+    if (!waitForStep) {
+      return run;
+    }
+    const { eventName, timeoutEvent, skipOutput } = waitForStep.waitFor;
+    if (eventName === PAUSE_EVENT_NAME) {
+      return this.resumeWorkflow({ runId, resourceId });
+    }
+    if (skipOutput && timeoutEvent) {
+      await withPostgresTransaction(this.db, async (db) => {
+        const freshRun = await this.getRun({ runId, resourceId }, { exclusiveLock: true, db });
+        return this.updateRun({
+          runId,
+          resourceId,
+          data: {
+            timeline: import_es_toolkit.merge(freshRun.timeline, {
+              [stepId]: {
+                output: data ?? {},
+                timestamp: new Date
+              }
+            })
+          }
+        }, { db });
+      }, this.pool);
+      return this.triggerEvent({ runId, resourceId, eventName: timeoutEvent });
+    }
+    if (eventName) {
+      return this.triggerEvent({ runId, resourceId, eventName, data: data ?? {} });
+    }
+    if (timeoutEvent) {
+      return this.triggerEvent({ runId, resourceId, eventName: timeoutEvent, data: data ?? {} });
+    }
+    return run;
+  }
   async cancelWorkflow({
     runId,
     resourceId
@@ -743,7 +825,8 @@ class WorkflowEngine {
       resourceId,
       data: {
         status: "cancelled" /* CANCELLED */
-      }
+      },
+      expectedStatuses: ["pending" /* PENDING */, "running" /* RUNNING */, "paused" /* PAUSED */]
     });
     this.logger.log(`cancelled workflow run with id ${runId}`);
     return run;
@@ -768,7 +851,7 @@ class WorkflowEngine {
         data
       }
     };
-    this.boss.send(WORKFLOW_RUN_QUEUE_NAME, job, {
+    await this.boss.send(WORKFLOW_RUN_QUEUE_NAME, job, {
       expireInSeconds: options?.expireInSeconds ?? defaultExpireInSeconds
     });
     this.logger.log(`event ${eventName} sent for workflow run with id ${runId}`);
@@ -784,10 +867,17 @@ class WorkflowEngine {
   async updateRun({
     runId,
     resourceId,
-    data
+    data,
+    expectedStatuses
   }, { db } = {}) {
-    const run = await updateWorkflowRun({ runId, resourceId, data }, db ?? this.db);
+    const run = await updateWorkflowRun({ runId, resourceId, data, expectedStatuses }, db ?? this.db);
     if (!run) {
+      if (expectedStatuses) {
+        const current = await getWorkflowRun({ runId, resourceId }, { db: db ?? this.db });
+        if (current) {
+          throw new WorkflowEngineError(`Cannot update workflow run in '${current.status}' status, expected: ${expectedStatuses.join(", ")}`, current.workflowId, runId);
+        }
+      }
       throw new WorkflowRunNotFoundError(runId);
     }
     return run;
@@ -870,36 +960,40 @@ class WorkflowEngine {
         throw new WorkflowEngineError("Missing current step id", workflowId, runId);
       }
       if (run.status === "paused" /* PAUSED */) {
-        const waitForStepEntry = run.timeline[`${run.currentStepId}-wait-for`];
-        const waitForStep = waitForStepEntry && typeof waitForStepEntry === "object" && "waitFor" in waitForStepEntry ? waitForStepEntry : null;
-        const currentStep = this.getCachedStepEntry(run.timeline, run.currentStepId);
-        const waitFor = waitForStep?.waitFor;
-        const hasCurrentStepOutput = currentStep?.output !== undefined;
-        const eventMatches = waitFor && event?.name && (event.name === waitFor.eventName || event.name === waitFor.timeoutEvent) && !hasCurrentStepOutput;
-        if (eventMatches) {
-          const isTimeout = event?.name === waitFor?.timeoutEvent;
-          const skipOutput = waitFor?.skipOutput;
-          run = await this.updateRun({
-            runId,
-            resourceId: scopedResourceId,
-            data: {
-              status: "running" /* RUNNING */,
-              pausedAt: null,
-              resumedAt: new Date,
-              jobId: job?.id,
-              ...skipOutput ? {} : {
-                timeline: import_es_toolkit.merge(run.timeline, {
-                  [run.currentStepId]: {
-                    output: event?.data ?? {},
-                    ...isTimeout ? { timedOut: true } : {},
-                    timestamp: new Date
-                  }
-                })
+        run = await withPostgresTransaction(this.db, async (db) => {
+          const lockedRun = await this.getRun({ runId, resourceId: scopedResourceId }, { exclusiveLock: true, db });
+          if (lockedRun.status !== "paused" /* PAUSED */) {
+            return lockedRun;
+          }
+          const waitForStep = this.getWaitForStepEntry(lockedRun.timeline, lockedRun.currentStepId);
+          const currentStep = this.getCachedStepEntry(lockedRun.timeline, lockedRun.currentStepId);
+          const waitFor = waitForStep?.waitFor;
+          const hasCurrentStepOutput = currentStep?.output !== undefined;
+          const eventMatches = waitFor && event?.name && (event.name === waitFor.eventName || event.name === waitFor.timeoutEvent) && !hasCurrentStepOutput;
+          if (eventMatches) {
+            const isTimeout = event?.name === waitFor?.timeoutEvent;
+            const skipOutput = waitFor?.skipOutput;
+            return this.updateRun({
+              runId,
+              resourceId: scopedResourceId,
+              data: {
+                status: "running" /* RUNNING */,
+                pausedAt: null,
+                resumedAt: new Date,
+                jobId: job?.id,
+                ...skipOutput ? {} : {
+                  timeline: import_es_toolkit.merge(lockedRun.timeline, {
+                    [lockedRun.currentStepId]: {
+                      output: event?.data ?? {},
+                      ...isTimeout ? { timedOut: true } : {},
+                      timestamp: new Date
+                    }
+                  })
+                }
               }
-            }
-          });
-        } else {
-          run = await this.updateRun({
+            }, { db });
+          }
+          return this.updateRun({
             runId,
             resourceId: scopedResourceId,
             data: {
@@ -908,8 +1002,8 @@ class WorkflowEngine {
               resumedAt: new Date,
               jobId: job?.id
             }
-          });
-        }
+          }, { db });
+        }, this.pool);
       }
       const baseStep = {
         run: async (stepId, handler) => {
@@ -1039,6 +1133,10 @@ class WorkflowEngine {
     const stepEntry = timeline[stepId];
     return stepEntry && typeof stepEntry === "object" && "output" in stepEntry ? stepEntry : null;
   }
+  getWaitForStepEntry(timeline, stepId) {
+    const entry = timeline[`${stepId}-wait-for`];
+    return entry && typeof entry === "object" && "waitFor" in entry ? entry : null;
+  }
   async runStep({
     stepId,
     run,
@@ -1080,7 +1178,7 @@ class WorkflowEngine {
           runId: run.id,
           resourceId: run.resourceId ?? undefined,
           data: {
-            timeline: import_es_toolkit.merge(run.timeline, {
+            timeline: import_es_toolkit.merge(persistedRun.timeline, {
               [stepId]: {
                 output,
                 timestamp: new Date
@@ -1125,33 +1223,45 @@ ${error.stack}` : String(error)
       return cached.timedOut ? undefined : cached.output;
     }
     const timeoutEvent = timeoutDate ? `__timeout_${stepId}` : undefined;
-    await this.updateRun({
-      runId: run.id,
-      resourceId: run.resourceId ?? undefined,
-      data: {
-        status: "paused" /* PAUSED */,
-        currentStepId: stepId,
-        pausedAt: new Date,
-        timeline: import_es_toolkit.merge(run.timeline, {
-          [`${stepId}-wait-for`]: {
-            waitFor: { eventName, timeoutEvent },
-            timestamp: new Date
-          }
-        })
-      }
-    });
-    if (timeoutDate && timeoutEvent) {
-      const job = {
+    await withPostgresTransaction(this.db, async (db) => {
+      const freshRun = await this.getRun({ runId: run.id, resourceId: run.resourceId ?? undefined }, { exclusiveLock: true, db });
+      return this.updateRun({
         runId: run.id,
         resourceId: run.resourceId ?? undefined,
-        workflowId: run.workflowId,
-        input: run.input,
-        event: { name: timeoutEvent, data: { date: timeoutDate.toISOString() } }
-      };
-      await this.boss.send(WORKFLOW_RUN_QUEUE_NAME, job, {
-        startAfter: timeoutDate.getTime() <= Date.now() ? new Date : timeoutDate,
-        expireInSeconds: defaultExpireInSeconds
-      });
+        data: {
+          status: "paused" /* PAUSED */,
+          currentStepId: stepId,
+          pausedAt: new Date,
+          timeline: import_es_toolkit.merge(freshRun.timeline, {
+            [`${stepId}-wait-for`]: {
+              waitFor: { eventName, timeoutEvent },
+              timestamp: new Date
+            }
+          })
+        }
+      }, { db });
+    }, this.pool);
+    if (timeoutDate && timeoutEvent) {
+      try {
+        const job = {
+          runId: run.id,
+          resourceId: run.resourceId ?? undefined,
+          workflowId: run.workflowId,
+          input: run.input,
+          event: { name: timeoutEvent, data: { date: timeoutDate.toISOString() } }
+        };
+        await this.boss.send(WORKFLOW_RUN_QUEUE_NAME, job, {
+          startAfter: timeoutDate.getTime() <= Date.now() ? new Date : timeoutDate,
+          expireInSeconds: defaultExpireInSeconds
+        });
+      } catch (error) {
+        await this.updateRun({
+          runId: run.id,
+          resourceId: run.resourceId ?? undefined,
+          data: { status: "running" /* RUNNING */, pausedAt: null }
+        });
+        throw error;
+      }
     }
     this.logger.log(`Step ${stepId} waiting${eventName ? ` for event "${eventName}"` : ""}${timeoutDate ? ` until ${timeoutDate.toISOString()}` : ""}`, { runId: run.id, workflowId: run.workflowId });
   }
@@ -1176,59 +1286,99 @@ ${error.stack}` : String(error)
     const pollStateEntry = persistedRun.timeline[`${stepId}-poll`];
     const startedAt = pollStateEntry && typeof pollStateEntry === "object" && "startedAt" in pollStateEntry ? new Date(pollStateEntry.startedAt) : new Date;
     if (timeoutMs !== undefined && Date.now() >= startedAt.getTime() + timeoutMs) {
-      await this.updateRun({
+      await withPostgresTransaction(this.db, async (db) => {
+        const freshRun = await this.getRun({ runId: run.id, resourceId: run.resourceId ?? undefined }, { exclusiveLock: true, db });
+        return this.updateRun({
+          runId: run.id,
+          resourceId: run.resourceId ?? undefined,
+          data: {
+            currentStepId: stepId,
+            timeline: import_es_toolkit.merge(freshRun.timeline, {
+              [stepId]: { output: {}, timedOut: true, timestamp: new Date }
+            })
+          }
+        }, { db });
+      }, this.pool);
+      return { timedOut: true };
+    }
+    let result;
+    try {
+      result = await conditionFn();
+    } catch (error) {
+      this.logger.error(`Poll conditionFn for step ${stepId} threw an error, treating as non-match and continuing to poll`, error, { runId: run.id, workflowId: run.workflowId });
+      if (timeoutMs !== undefined && Date.now() >= startedAt.getTime() + timeoutMs) {
+        await withPostgresTransaction(this.db, async (db) => {
+          const freshRun = await this.getRun({ runId: run.id, resourceId: run.resourceId ?? undefined }, { exclusiveLock: true, db });
+          return this.updateRun({
+            runId: run.id,
+            resourceId: run.resourceId ?? undefined,
+            data: {
+              currentStepId: stepId,
+              timeline: import_es_toolkit.merge(freshRun.timeline, {
+                [stepId]: { output: {}, timedOut: true, timestamp: new Date }
+              })
+            }
+          }, { db });
+        }, this.pool);
+        return { timedOut: true };
+      }
+      result = false;
+    }
+    if (result !== false) {
+      await withPostgresTransaction(this.db, async (db) => {
+        const freshRun = await this.getRun({ runId: run.id, resourceId: run.resourceId ?? undefined }, { exclusiveLock: true, db });
+        return this.updateRun({
+          runId: run.id,
+          resourceId: run.resourceId ?? undefined,
+          data: {
+            currentStepId: stepId,
+            timeline: import_es_toolkit.merge(freshRun.timeline, {
+              [stepId]: { output: result, timestamp: new Date }
+            })
+          }
+        }, { db });
+      }, this.pool);
+      return { timedOut: false, data: result };
+    }
+    const pollEvent = `__poll_${stepId}`;
+    await withPostgresTransaction(this.db, async (db) => {
+      const freshRun = await this.getRun({ runId: run.id, resourceId: run.resourceId ?? undefined }, { exclusiveLock: true, db });
+      return this.updateRun({
         runId: run.id,
         resourceId: run.resourceId ?? undefined,
         data: {
+          status: "paused" /* PAUSED */,
           currentStepId: stepId,
-          timeline: import_es_toolkit.merge(persistedRun.timeline, {
-            [stepId]: { output: {}, timedOut: true, timestamp: new Date }
+          pausedAt: new Date,
+          timeline: import_es_toolkit.merge(freshRun.timeline, {
+            [`${stepId}-poll`]: { startedAt: startedAt.toISOString() },
+            [`${stepId}-wait-for`]: {
+              waitFor: { timeoutEvent: pollEvent, skipOutput: true },
+              timestamp: new Date
+            }
           })
         }
+      }, { db });
+    }, this.pool);
+    try {
+      await this.boss.send(WORKFLOW_RUN_QUEUE_NAME, {
+        runId: run.id,
+        resourceId: run.resourceId ?? undefined,
+        workflowId: run.workflowId,
+        input: run.input,
+        event: { name: pollEvent, data: {} }
+      }, {
+        startAfter: new Date(Date.now() + intervalMs),
+        expireInSeconds: defaultExpireInSeconds
       });
-      return { timedOut: true };
-    }
-    const result = await conditionFn();
-    if (result !== false) {
+    } catch (error) {
       await this.updateRun({
         runId: run.id,
         resourceId: run.resourceId ?? undefined,
-        data: {
-          currentStepId: stepId,
-          timeline: import_es_toolkit.merge(persistedRun.timeline, {
-            [stepId]: { output: result, timestamp: new Date }
-          })
-        }
+        data: { status: "running" /* RUNNING */, pausedAt: null }
       });
-      return { timedOut: false, data: result };
+      throw error;
     }
-    const pollEvent = `__poll_${stepId}`;
-    await this.updateRun({
-      runId: run.id,
-      resourceId: run.resourceId ?? undefined,
-      data: {
-        status: "paused" /* PAUSED */,
-        currentStepId: stepId,
-        pausedAt: new Date,
-        timeline: import_es_toolkit.merge(persistedRun.timeline, {
-          [`${stepId}-poll`]: { startedAt: startedAt.toISOString() },
-          [`${stepId}-wait-for`]: {
-            waitFor: { timeoutEvent: pollEvent, skipOutput: true },
-            timestamp: new Date
-          }
-        })
-      }
-    });
-    await this.boss.send(WORKFLOW_RUN_QUEUE_NAME, {
-      runId: run.id,
-      resourceId: run.resourceId ?? undefined,
-      workflowId: run.workflowId,
-      input: run.input,
-      event: { name: pollEvent, data: {} }
-    }, {
-      startAfter: new Date(Date.now() + intervalMs),
-      expireInSeconds: defaultExpireInSeconds
-    });
     this.logger.log(`Step ${stepId} polling every ${intervalMs}ms...`, {
       runId: run.id,
       workflowId: run.workflowId
@@ -1273,5 +1423,5 @@ ${error.stack}` : String(error)
   }
 }
 
-//# debugId=CB5A27C81F2BF17864756E2164756E21
+//# debugId=12BE08AB4C2E4D0564756E2164756E21
 //# sourceMappingURL=index.js.map

package/dist/index.d.cts

@@ -211,6 +211,11 @@ declare class WorkflowEngine {
 			expireInSeconds?: number;
 		};
 	}): Promise<WorkflowRun>;
+	fastForwardWorkflow({ runId, resourceId, data }: {
+		runId: string;
+		resourceId?: string;
+		data?: Record<string, unknown>;
+	}): Promise<WorkflowRun>;
 	cancelWorkflow({ runId, resourceId }: {
 		runId: string;
 		resourceId?: string;
@@ -231,10 +236,11 @@ declare class WorkflowEngine {
 		exclusiveLock?: boolean;
 		db?: Db;
 	}): Promise<WorkflowRun>;
-	updateRun({ runId, resourceId, data }: {
+	updateRun({ runId, resourceId, data, expectedStatuses }: {
 		runId: string;
 		resourceId?: string;
 		data: Partial<WorkflowRun>;
+		expectedStatuses?: string[];
 	}, { db }?: {
 		db?: Db;
 	}): Promise<WorkflowRun>;
@@ -251,6 +257,7 @@ declare class WorkflowEngine {
 	private resolveScopedResourceId;
 	private handleWorkflowRun;
 	private getCachedStepEntry;
+	private getWaitForStepEntry;
 	private runStep;
 	private waitStep;
 	private pollStep;