pg-workflows 0.9.0 → 0.10.0

package/dist/index.cjs

@@ -90,10 +90,15 @@ var WORKFLOW_RUN_DLQ_QUEUE_NAME = "workflow_run_dlq";
 var DEFAULT_PGBOSS_SCHEMA = "pgboss_v12_pgworkflow";
 var MAX_WORKFLOW_ID_LENGTH = 256;
 var MAX_RESOURCE_ID_LENGTH = 256;
+var INVOKE_CHILD_WORKFLOW_TIMELINE_SUFFIX = "invoke-child-workflow";
+var WAIT_FOR_TIMELINE_SUFFIX = "wait-for";
+var invokeChildWorkflowTimelineKey = (stepId) => `${stepId}-${INVOKE_CHILD_WORKFLOW_TIMELINE_SUFFIX}`;
+var waitForTimelineKey = (stepId) => `${stepId}-${WAIT_FOR_TIMELINE_SUFFIX}`;
+var isInvokeChildWorkflowTimelineEntry = (entry) => !!entry && typeof entry === "object" && ("invokeChildWorkflow" in entry);
 
 // src/db/migration.ts
 var MIGRATION_LOCK_ID = 738291645;
-var CURRENT_SCHEMA_VERSION = 3;
+var CURRENT_SCHEMA_VERSION = 4;
 async function runMigrations(db) {
   if (await isSchemaUpToDate(db)) {
     return;
@@ -151,6 +156,11 @@ async function runMigrations(db) {
     commands.push("ALTER TABLE workflow_runs ALTER COLUMN resource_id TYPE varchar(256)");
     commands.push("ALTER TABLE workflow_runs ALTER COLUMN workflow_id TYPE varchar(256)");
   }
+  if (currentVersion < 4) {
+    commands.push("ALTER TABLE workflow_runs ADD COLUMN IF NOT EXISTS parent_run_id varchar(32)");
+    commands.push("ALTER TABLE workflow_runs ADD COLUMN IF NOT EXISTS parent_step_id varchar(256)");
+    commands.push("ALTER TABLE workflow_runs ADD COLUMN IF NOT EXISTS parent_resource_id varchar(256)");
+  }
   if (currentVersion === 0) {
     commands.push(`INSERT INTO workflow_schema_version (version) VALUES (${CURRENT_SCHEMA_VERSION})`);
   } else {
@@ -213,7 +223,10 @@ function mapRowToWorkflowRun(row) {
     retryCount: row.retry_count,
     maxRetries: row.max_retries,
     jobId: row.job_id,
-    idempotencyKey: row.idempotency_key
+    idempotencyKey: row.idempotency_key,
+    parentRunId: row.parent_run_id,
+    parentStepId: row.parent_step_id,
+    parentResourceId: row.parent_resource_id
   };
 }
 async function insertWorkflowRun({
@@ -224,7 +237,10 @@ async function insertWorkflowRun({
   input,
   maxRetries,
   timeoutAt,
-  idempotencyKey
+  idempotencyKey,
+  parentRunId,
+  parentStepId,
+  parentResourceId
 }, db) {
   const runId = generateKSUID("run");
   const now = new Date;
@@ -241,9 +257,12 @@ async function insertWorkflowRun({
       updated_at,
       timeline,
       retry_count,
-      idempotency_key
+      idempotency_key,
+      parent_run_id,
+      parent_step_id,
+      parent_resource_id
     )
-    VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)
+    VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16)
     ON CONFLICT (idempotency_key) WHERE idempotency_key IS NOT NULL DO NOTHING
     RETURNING *`, [
     runId,
@@ -258,7 +277,10 @@ async function insertWorkflowRun({
     now,
     "{}",
     0,
-    idempotencyKey ?? null
+    idempotencyKey ?? null,
+    parentRunId ?? null,
+    parentStepId ?? null,
+    parentResourceId ?? null
   ]);
   if (result.rows[0]) {
     return { run: mapRowToWorkflowRun(result.rows[0]), created: true };
@@ -529,6 +551,7 @@ var StepType;
   StepType2["WAIT_UNTIL"] = "waitUntil";
   StepType2["DELAY"] = "delay";
   StepType2["POLL"] = "poll";
+  StepType2["INVOKE_CHILD_WORKFLOW"] = "invokeChildWorkflow";
 })(StepType ||= {});
 
 // src/client.ts
@@ -636,7 +659,8 @@ class WorkflowClient {
         };
         await this.boss.send(WORKFLOW_RUN_QUEUE_NAME, job, {
           startAfter: new Date,
-          expireInSeconds: options?.expireInSeconds ?? defaultExpireInSeconds
+          expireInSeconds: options?.expireInSeconds ?? defaultExpireInSeconds,
+          db: _db
         });
       }
       return insertedRun;
@@ -699,6 +723,11 @@ class WorkflowClient {
     if (current.status !== "paused" /* PAUSED */) {
       throw new WorkflowEngineError(`Cannot resume workflow run in '${current.status}' status, must be 'paused'`, current.workflowId, runId);
     }
+    const currentStepId = current.currentStepId;
+    const currentStepTimelineEntry = current.timeline[invokeChildWorkflowTimelineKey(currentStepId)];
+    if (isInvokeChildWorkflowTimelineEntry(currentStepTimelineEntry)) {
+      return current;
+    }
     return this.triggerEvent({
       runId,
       resourceId,
@@ -717,8 +746,12 @@ class WorkflowClient {
     if (run.status !== "paused" /* PAUSED */) {
       return run;
     }
-    const stepId = run.currentStepId;
-    const waitForEntry = run.timeline[`${stepId}-wait-for`];
+    const currentStepId = run.currentStepId;
+    const currentStepTimelineEntry = run.timeline[invokeChildWorkflowTimelineKey(currentStepId)];
+    if (isInvokeChildWorkflowTimelineEntry(currentStepTimelineEntry)) {
+      return run;
+    }
+    const waitForEntry = run.timeline[waitForTimelineKey(currentStepId)];
     if (!waitForEntry || typeof waitForEntry !== "object" || !("waitFor" in waitForEntry)) {
       return run;
     }
@@ -736,7 +769,7 @@ class WorkflowClient {
           resourceId,
           data: {
             timeline: import_es_toolkit.merge(freshRun.timeline, {
-              [stepId]: {
+              [currentStepId]: {
                 output: data ?? {},
                 timestamp: new Date
               }
@@ -836,7 +869,10 @@ function createWorkflowRef(id, options) {
     retries: defineOptions?.retries
   });
   Object.defineProperty(ref, "id", { value: id, enumerable: true });
-  Object.defineProperty(ref, "inputSchema", { value: options?.inputSchema, enumerable: true });
+  Object.defineProperty(ref, "inputSchema", {
+    value: options?.inputSchema,
+    enumerable: true
+  });
   return ref;
 }
 function createWorkflowFactory(plugins = []) {
@@ -931,7 +967,7 @@ function parseWorkflowHandler(handler) {
       const propertyAccess = node.expression;
       const objectName = propertyAccess.expression.getText(sourceFile);
       const methodName = propertyAccess.name.text;
-      if (objectName === "step" && (methodName === "run" || methodName === "waitFor" || methodName === "pause" || methodName === "waitUntil" || methodName === "delay" || methodName === "sleep" || methodName === "poll")) {
+      if (objectName === "step" && (methodName === "run" || methodName === "waitFor" || methodName === "pause" || methodName === "waitUntil" || methodName === "delay" || methodName === "sleep" || methodName === "poll" || methodName === "invokeChildWorkflow")) {
         const firstArg = node.arguments[0];
         if (firstArg) {
           const { id, isDynamic } = extractStepId(firstArg);
@@ -964,7 +1000,8 @@ var StepTypeToIcon = {
   ["pause" /* PAUSE */]: "⏸",
   ["waitUntil" /* WAIT_UNTIL */]: "⏲",
   ["delay" /* DELAY */]: "⏱",
-  ["poll" /* POLL */]: "↻"
+  ["poll" /* POLL */]: "↻",
+  ["invokeChildWorkflow" /* INVOKE_CHILD_WORKFLOW */]: "↪"
 };
 var defaultLogger2 = {
   log: (_message) => console.warn(_message),
@@ -976,6 +1013,7 @@ var retrySendOptions = (maxRetries) => ({
   retryBackoff: true,
   retryDelay: 1
 });
+var getInvokeChildWorkflowEventName = (childRunId) => `__invoke_child_workflow_completed:${childRunId}`;
 var defaultHeartbeatSeconds = process.env.WORKFLOW_RUN_HEARTBEAT_SECONDS ? Number.parseInt(process.env.WORKFLOW_RUN_HEARTBEAT_SECONDS, 10) : 30;
 
 class WorkflowEngine {
@@ -1081,31 +1119,57 @@ class WorkflowEngine {
     this.workflows.clear();
     return this;
   }
-  async startWorkflow(refOrParams, inputArg, optionsArg) {
-    let workflowId;
-    let input;
-    let resourceId;
-    let idempotencyKey;
-    let options;
+  resolveWorkflowRunParameters(refOrParams, inputArg, optionsArg) {
     if (typeof refOrParams === "function" && "id" in refOrParams) {
-      workflowId = refOrParams.id;
-      input = inputArg;
-      options = optionsArg;
-      resourceId = optionsArg?.resourceId;
-      idempotencyKey = optionsArg?.idempotencyKey;
-    } else {
-      const params = refOrParams;
-      workflowId = params.workflowId;
-      input = params.input;
-      resourceId = params.resourceId;
-      idempotencyKey = params.idempotencyKey;
-      options = params.options;
+      return {
+        workflowId: refOrParams.id,
+        input: inputArg,
+        options: optionsArg,
+        resourceId: optionsArg?.resourceId,
+        idempotencyKey: optionsArg?.idempotencyKey
+      };
     }
-    validateWorkflowId(workflowId);
-    validateResourceId(resourceId);
+    const params = refOrParams;
+    return {
+      workflowId: params.workflowId,
+      input: params.input,
+      resourceId: params.resourceId ?? params.options?.resourceId,
+      idempotencyKey: params.idempotencyKey ?? params.options?.idempotencyKey,
+      options: params.options
+    };
+  }
+  async startWorkflow(refOrParams, inputArg, optionsArg) {
+    const { workflowId, input, resourceId, idempotencyKey, options } = this.resolveWorkflowRunParameters(refOrParams, inputArg, optionsArg);
     if (!this._started) {
       await this.start(false, { batchSize: options?.batchSize ?? 1 });
     }
+    const { run } = await this.createWorkflowRun({
+      workflowId,
+      input,
+      resourceId,
+      idempotencyKey,
+      options
+    });
+    this.logger.log("Started workflow run", {
+      runId: run.id,
+      workflowId
+    });
+    return run;
+  }
+  async createWorkflowRun({
+    workflowId,
+    input,
+    resourceId,
+    idempotencyKey,
+    options,
+    parentRunId,
+    parentStepId,
+    parentResourceId,
+    enqueue = true,
+    db
+  }) {
+    validateWorkflowId(workflowId);
+    validateResourceId(resourceId);
     const workflow2 = this.workflows.get(workflowId);
     if (!workflow2) {
       throw new WorkflowEngineError(`Unknown workflow ${workflowId}`);
@@ -1122,38 +1186,60 @@ class WorkflowEngine {
       }
     }
     const initialStepId = workflow2.steps[0]?.id ?? "__start__";
-    const run = await withPostgresTransaction(this.boss.getDb(), async (_db) => {
-      const timeoutAt = options?.timeout ? new Date(Date.now() + options.timeout) : workflow2.timeout ? new Date(Date.now() + workflow2.timeout) : null;
-      const { run: insertedRun, created } = await insertWorkflowRun({
-        resourceId,
-        workflowId,
-        currentStepId: initialStepId,
-        status: "running" /* RUNNING */,
-        input,
-        maxRetries: options?.retries ?? workflow2.retries ?? 0,
-        timeoutAt,
-        idempotencyKey
-      }, _db);
-      if (created) {
-        const job = {
-          runId: insertedRun.id,
-          resourceId,
-          workflowId,
-          input
-        };
-        await this.boss.send(WORKFLOW_RUN_QUEUE_NAME, job, {
-          startAfter: new Date,
-          expireInSeconds: options?.expireInSeconds ?? defaultExpireInSeconds2,
-          ...retrySendOptions(insertedRun.maxRetries)
-        });
+    const timeoutAt = options?.timeout ? new Date(Date.now() + options.timeout) : workflow2.timeout ? new Date(Date.now() + workflow2.timeout) : null;
+    const insertRun = async (targetDb) => await insertWorkflowRun({
+      resourceId,
+      workflowId,
+      currentStepId: initialStepId,
+      status: "running" /* RUNNING */,
+      input,
+      maxRetries: options?.retries ?? workflow2.retries ?? 0,
+      timeoutAt,
+      idempotencyKey,
+      parentRunId,
+      parentStepId,
+      parentResourceId
+    }, targetDb);
+    const insertAndEnqueue = async (targetDb) => {
+      const result = await insertRun(targetDb);
+      if (enqueue && result.created) {
+        await this.enqueueWorkflowRun(result.run, options, targetDb);
       }
-      return insertedRun;
-    }, this.pool);
-    this.logger.log("Started workflow run", {
+      return result;
+    };
+    const { run, created } = db ? await insertAndEnqueue(db) : await withPostgresTransaction(this.boss.getDb(), insertAndEnqueue, this.pool);
+    return { run, created };
+  }
+  async enqueueWorkflowRun(run, options, db) {
+    const job = {
       runId: run.id,
-      workflowId
+      resourceId: run.resourceId ?? undefined,
+      workflowId: run.workflowId,
+      input: run.input
+    };
+    await this.boss.send(WORKFLOW_RUN_QUEUE_NAME, job, {
+      startAfter: new Date,
+      expireInSeconds: options?.expireInSeconds ?? defaultExpireInSeconds2,
+      ...retrySendOptions(run.maxRetries),
+      ...db ? { db } : {}
+    });
+  }
+  async notifyParentOfChildTerminalRun(childRun) {
+    if (!childRun.parentRunId || !childRun.parentStepId) {
+      return;
+    }
+    const parentRun = await getWorkflowRun({
+      runId: childRun.parentRunId,
+      resourceId: childRun.parentResourceId ?? undefined
+    }, { db: this.db });
+    if (!parentRun || parentRun.status === "completed" /* COMPLETED */ || parentRun.status === "failed" /* FAILED */ || parentRun.status === "cancelled" /* CANCELLED */) {
+      return;
+    }
+    await this.triggerEvent({
+      runId: parentRun.id,
+      resourceId: parentRun.resourceId ?? undefined,
+      eventName: getInvokeChildWorkflowEventName(childRun.id)
     });
-    return run;
   }
   async pauseWorkflow({
     runId,
@@ -1185,6 +1271,9 @@ class WorkflowEngine {
     if (current.status !== "paused" /* PAUSED */) {
       throw new WorkflowEngineError(`Cannot resume workflow run in '${current.status}' status, must be 'paused'`, current.workflowId, runId);
     }
+    if (this.getInvokeChildWorkflowStepEntry(current.timeline, current.currentStepId)) {
+      return current;
+    }
     return this.triggerEvent({
       runId,
       resourceId,
@@ -1204,6 +1293,9 @@ class WorkflowEngine {
       return run;
     }
     const stepId = run.currentStepId;
+    if (this.getInvokeChildWorkflowStepEntry(run.timeline, stepId)) {
+      return run;
+    }
     const waitForStep = this.getWaitForStepEntry(run.timeline, stepId);
     if (!waitForStep) {
       return run;
@@ -1252,6 +1344,7 @@ class WorkflowEngine {
       expectedStatuses: ["pending" /* PENDING */, "running" /* RUNNING */, "paused" /* PAUSED */]
     });
     this.logger.log(`cancelled workflow run with id ${runId}`);
+    await this.notifyParentOfChildTerminalRun(run);
     return run;
   }
   async triggerEvent({
@@ -1489,6 +1582,22 @@ class WorkflowEngine {
           }
           const timeoutMs = options?.timeout ? parseDuration(options.timeout) : undefined;
           return this.pollStep({ run, stepId, conditionFn, intervalMs, timeoutMs });
+        },
+        invokeChildWorkflow: async (stepId, refOrParams, inputArg, optionsArg) => {
+          if (!run) {
+            throw new WorkflowEngineError("Missing workflow run", workflowId, runId);
+          }
+          const resolvedChildCall = this.resolveWorkflowRunParameters(refOrParams, inputArg, optionsArg);
+          const childWorkflowInvocation = {
+            run,
+            stepId,
+            workflowId: resolvedChildCall.workflowId,
+            input: resolvedChildCall.input,
+            options: resolvedChildCall.options,
+            resourceId: resolvedChildCall.resourceId,
+            idempotencyKey: resolvedChildCall.idempotencyKey
+          };
+          return this.invokeChildWorkflowStep(childWorkflowInvocation);
         }
       };
       let step = { ...baseStep };
@@ -1513,7 +1622,7 @@ class WorkflowEngine {
       const shouldComplete = run.status === "running" /* RUNNING */ && (noParsedSteps || isLastParsedStep || hasPluginSteps && result !== undefined);
       if (shouldComplete) {
         const normalizedResult = result === undefined ? {} : result;
-        await this.updateRun({
+        const completedRun = await this.updateRun({
           runId,
           resourceId: scopedResourceId,
           data: {
@@ -1523,6 +1632,7 @@ class WorkflowEngine {
             jobId: job?.id
           }
         });
+        await this.notifyParentOfChildTerminalRun(completedRun);
         this.logger.log("Workflow run completed.", {
           runId,
           workflowId
@@ -1530,7 +1640,7 @@ class WorkflowEngine {
       }
     } catch (error) {
       if (runId) {
-        await this.updateRun({
+        const updatedRun = await this.updateRun({
           runId,
           resourceId: scopedResourceId,
           data: {
@@ -1538,6 +1648,9 @@ class WorkflowEngine {
             jobId: job?.id
           }
         });
+        if (updatedRun.status === "completed" /* COMPLETED */ || updatedRun.status === "failed" /* FAILED */ || updatedRun.status === "cancelled" /* CANCELLED */) {
+          await this.notifyParentOfChildTerminalRun(updatedRun);
+        }
       }
       throw error;
     }
@@ -1549,7 +1662,7 @@ class WorkflowEngine {
     const run = await getWorkflowRun({ runId }, { db: this.db });
     if (!run || run.status !== "running" /* RUNNING */)
       return;
-    await this.updateRun({
+    const failedRun = await this.updateRun({
       runId,
       resourceId: run.resourceId ?? undefined,
       data: {
@@ -1557,6 +1670,7 @@ class WorkflowEngine {
         error: run.error ?? "Workflow run worker died or job expired before completion"
       }
     });
+    await this.notifyParentOfChildTerminalRun(failedRun);
     this.logger.log("Marked stuck workflow run as failed", {
       runId,
       workflowId: run.workflowId
@@ -1567,9 +1681,195 @@ class WorkflowEngine {
     return stepEntry && typeof stepEntry === "object" && "output" in stepEntry ? stepEntry : null;
   }
   getWaitForStepEntry(timeline, stepId) {
-    const entry = timeline[`${stepId}-wait-for`];
+    const entry = timeline[waitForTimelineKey(stepId)];
     return entry && typeof entry === "object" && "waitFor" in entry ? entry : null;
   }
+  getInvokeChildWorkflowStepEntry(timeline, stepId) {
+    const entry = timeline[invokeChildWorkflowTimelineKey(stepId)];
+    return isInvokeChildWorkflowTimelineEntry(entry) ? entry : null;
+  }
+  getCompletedChildOutput(childRun) {
+    return childRun.output === undefined ? {} : childRun.output;
+  }
+  throwForNonCompletedChild(childRun) {
+    throw new WorkflowEngineError(`Child workflow ${childRun.workflowId} ${childRun.status}${childRun.error ? `: ${childRun.error}` : ""}`, childRun.workflowId, childRun.id);
+  }
+  assertInvokeChildWorkflowStepOwnership({
+    childRun,
+    parentRun,
+    stepId,
+    workflowId
+  }) {
+    const expectedParentResourceId = parentRun.resourceId ?? null;
+    const matches = childRun.workflowId === workflowId && childRun.parentRunId === parentRun.id && childRun.parentStepId === stepId && childRun.parentResourceId === expectedParentResourceId;
+    if (!matches) {
+      throw new WorkflowEngineError(`Idempotency key resolved to workflow run ${childRun.id}, which does not belong to invokeChildWorkflow step '${stepId}'`, workflowId, parentRun.id);
+    }
+  }
+  async invokeChildWorkflowStep({
+    run,
+    stepId,
+    workflowId,
+    input,
+    resourceId,
+    idempotencyKey,
+    options
+  }) {
+    let invokeOutput;
+    let hasInvokeOutput = false;
+    const childResourceId = resourceId ?? run.resourceId ?? undefined;
+    const childIdempotencyKey = idempotencyKey;
+    await withPostgresTransaction(this.db, async (db) => {
+      const lockedRun = await this.getRun({ runId: run.id, resourceId: run.resourceId ?? undefined }, { exclusiveLock: true, db });
+      if (lockedRun.status === "cancelled" /* CANCELLED */ || lockedRun.status === "paused" /* PAUSED */ || lockedRun.status === "failed" /* FAILED */) {
+        return;
+      }
+      const lockedCached = this.getCachedStepEntry(lockedRun.timeline, stepId);
+      if (lockedCached?.output !== undefined) {
+        invokeOutput = lockedCached.output;
+        hasInvokeOutput = true;
+        return;
+      }
+      const lockedInvoke = this.getInvokeChildWorkflowStepEntry(lockedRun.timeline, stepId);
+      if (lockedInvoke) {
+        const existingChildResourceId = "childResourceId" in lockedInvoke.invokeChildWorkflow ? lockedInvoke.invokeChildWorkflow.childResourceId ?? undefined : childResourceId;
+        const existingChildRun = await this.getRun({
+          runId: lockedInvoke.invokeChildWorkflow.childRunId,
+          resourceId: existingChildResourceId
+        });
+        if (existingChildRun.status === "completed" /* COMPLETED */) {
+          invokeOutput = this.getCompletedChildOutput(existingChildRun);
+          hasInvokeOutput = true;
+          await this.updateRun({
+            runId: run.id,
+            resourceId: run.resourceId ?? undefined,
+            data: {
+              timeline: import_es_toolkit2.merge(lockedRun.timeline, {
+                [stepId]: {
+                  output: invokeOutput,
+                  timestamp: new Date
+                }
+              })
+            }
+          }, { db });
+          return;
+        }
+        if (existingChildRun.status === "failed" /* FAILED */ || existingChildRun.status === "cancelled" /* CANCELLED */) {
+          this.throwForNonCompletedChild(existingChildRun);
+        }
+        await this.pauseRunForWait({
+          run: lockedRun,
+          stepId,
+          eventName: getInvokeChildWorkflowEventName(existingChildRun.id),
+          skipOutput: true,
+          db
+        });
+        return;
+      }
+      const result = await this.createWorkflowRun({
+        workflowId,
+        input,
+        resourceId: childResourceId,
+        idempotencyKey: childIdempotencyKey,
+        options,
+        parentRunId: run.id,
+        parentStepId: stepId,
+        parentResourceId: run.resourceId ?? undefined,
+        enqueue: true,
+        db
+      });
+      const childRun = result.run;
+      if (!result.created) {
+        this.assertInvokeChildWorkflowStepOwnership({
+          childRun,
+          parentRun: lockedRun,
+          stepId,
+          workflowId
+        });
+        if (childRun.status === "completed" /* COMPLETED */) {
+          invokeOutput = this.getCompletedChildOutput(childRun);
+          hasInvokeOutput = true;
+          await this.updateRun({
+            runId: run.id,
+            resourceId: run.resourceId ?? undefined,
+            data: {
+              timeline: import_es_toolkit2.merge(lockedRun.timeline, {
+                [invokeChildWorkflowTimelineKey(stepId)]: {
+                  invokeChildWorkflow: {
+                    childRunId: childRun.id,
+                    childWorkflowId: childRun.workflowId,
+                    childResourceId: childRun.resourceId
+                  },
+                  timestamp: new Date
+                },
+                [stepId]: {
+                  output: invokeOutput,
+                  timestamp: new Date
+                }
+              })
+            }
+          }, { db });
+          return;
+        }
+        if (childRun.status === "failed" /* FAILED */ || childRun.status === "cancelled" /* CANCELLED */) {
+          this.throwForNonCompletedChild(childRun);
+        }
+      }
+      await this.pauseRunForWait({
+        run: lockedRun,
+        stepId,
+        eventName: getInvokeChildWorkflowEventName(childRun.id),
+        skipOutput: true,
+        db,
+        timeline: import_es_toolkit2.merge(lockedRun.timeline, {
+          [invokeChildWorkflowTimelineKey(stepId)]: {
+            invokeChildWorkflow: {
+              childRunId: childRun.id,
+              childWorkflowId: childRun.workflowId,
+              childResourceId: childRun.resourceId
+            },
+            timestamp: new Date
+          }
+        })
+      });
+    }, this.pool);
+    if (hasInvokeOutput) {
+      return invokeOutput;
+    }
+  }
+  async pauseRunForWait({
+    run,
+    stepId,
+    eventName,
+    timeoutEvent,
+    skipOutput,
+    db,
+    timeline
+  }) {
+    const baseTimeline = timeline ?? run.timeline;
+    const waitFor = {};
+    if (eventName)
+      waitFor.eventName = eventName;
+    if (timeoutEvent)
+      waitFor.timeoutEvent = timeoutEvent;
+    if (skipOutput)
+      waitFor.skipOutput = true;
+    await this.updateRun({
+      runId: run.id,
+      resourceId: run.resourceId ?? undefined,
+      data: {
+        status: "paused" /* PAUSED */,
+        currentStepId: stepId,
+        pausedAt: new Date,
+        timeline: import_es_toolkit2.merge(baseTimeline, {
+          [waitForTimelineKey(stepId)]: {
+            waitFor,
+            timestamp: new Date
+          }
+        })
+      }
+    }, { db });
+  }
   async runStep({
     stepId,
     run,
@@ -1658,21 +1958,7 @@ ${error.stack}` : String(error)
     const timeoutEvent = timeoutDate ? `__timeout_${stepId}` : undefined;
     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,
-          pausedAt: new Date,
-          timeline: import_es_toolkit2.merge(freshRun.timeline, {
-            [`${stepId}-wait-for`]: {
-              waitFor: { eventName, timeoutEvent },
-              timestamp: new Date
-            }
-          })
-        }
-      }, { db });
+      return this.pauseRunForWait({ run: freshRun, stepId, eventName, timeoutEvent, db });
     }, this.pool);
     if (timeoutDate && timeoutEvent) {
       try {
@@ -1786,7 +2072,7 @@ ${error.stack}` : String(error)
           pausedAt: new Date,
           timeline: import_es_toolkit2.merge(freshRun.timeline, {
             [`${stepId}-poll`]: { startedAt: startedAt.toISOString() },
-            [`${stepId}-wait-for`]: {
+            [waitForTimelineKey(stepId)]: {
               waitFor: { timeoutEvent: pollEvent, skipOutput: true },
               timestamp: new Date
             }
@@ -1861,5 +2147,5 @@ ${error.stack}` : String(error)
   }
 }
 
-//# debugId=CBDC1CAB86CECE9C64756E2164756E21
+//# debugId=8E8C82F1948B934364756E2164756E21
 //# sourceMappingURL=index.js.map