@rivetkit/workflow-engine 2.1.11-rc.1 → 2.2.1-pr.4600.b74ff3b

package/dist/tsup/{chunk-4ME2JBMC.js → chunk-UMFB2AR3.js}

@@ -1658,7 +1658,19 @@ var DEFAULT_RETRY_BACKOFF_BASE = 100;
 var DEFAULT_RETRY_BACKOFF_MAX = 3e4;
 var DEFAULT_LOOP_HISTORY_PRUNE_INTERVAL = 20;
 var DEFAULT_STEP_TIMEOUT = 3e4;
+var DEFAULT_TRY_STEP_CATCH = [
+  "critical",
+  "timeout",
+  "exhausted"
+];
+var DEFAULT_TRY_BLOCK_CATCH = [
+  "step",
+  "join",
+  "race"
+];
 var QUEUE_HISTORY_MESSAGE_MARKER = "__rivetWorkflowQueueMessage";
+var TRY_STEP_FAILURE_SYMBOL = /* @__PURE__ */ Symbol("workflow.try-step.failure");
+var TRY_BLOCK_FAILURE_SYMBOL = /* @__PURE__ */ Symbol("workflow.try-block.failure");
 function calculateBackoff(attempts, base, max) {
   return Math.min(max, base * 2 ** attempts);
 }
@@ -1670,6 +1682,128 @@ var StepTimeoutError = class extends Error {
     this.name = "StepTimeoutError";
   }
 };
+function attachTryStepFailure(error, failure) {
+  error[TRY_STEP_FAILURE_SYMBOL] = failure;
+  return error;
+}
+function readTryStepFailure(error) {
+  if (!(error instanceof Error)) {
+    return void 0;
+  }
+  return error[TRY_STEP_FAILURE_SYMBOL];
+}
+function attachTryBlockFailure(error, failure) {
+  error[TRY_BLOCK_FAILURE_SYMBOL] = failure;
+  return error;
+}
+function readTryBlockFailure(error) {
+  if (!(error instanceof Error)) {
+    return void 0;
+  }
+  return error[TRY_BLOCK_FAILURE_SYMBOL];
+}
+function shouldRethrowTryError(error) {
+  return error instanceof StepFailedError || error instanceof SleepError || error instanceof MessageWaitError || error instanceof EvictedError || error instanceof HistoryDivergedError || error instanceof EntryInProgressError || error instanceof RollbackCheckpointError || error instanceof RollbackStopError;
+}
+function shouldCatchTryStepFailure(failure, catchKinds) {
+  const effectiveCatch = catchKinds ?? DEFAULT_TRY_STEP_CATCH;
+  return effectiveCatch.includes(failure.kind);
+}
+function shouldCatchTryBlockFailure(failure, catchKinds) {
+  var _a;
+  const effectiveCatch = catchKinds ?? DEFAULT_TRY_BLOCK_CATCH;
+  if (failure.source === "step") {
+    return ((_a = failure.step) == null ? void 0 : _a.kind) === "rollback" ? effectiveCatch.includes("rollback") : effectiveCatch.includes("step");
+  }
+  if (failure.source === "join") {
+    return effectiveCatch.includes("join");
+  }
+  if (failure.source === "race") {
+    return effectiveCatch.includes("race");
+  }
+  return effectiveCatch.includes("rollback");
+}
+function parseStoredWorkflowError(message) {
+  if (!message) {
+    return {
+      name: "Error",
+      message: "unknown error"
+    };
+  }
+  const match = /^([^:]+):\s*(.*)$/s.exec(message);
+  if (!match) {
+    return {
+      name: "Error",
+      message
+    };
+  }
+  return {
+    name: match[1],
+    message: match[2]
+  };
+}
+function getTryStepFailureFromExhaustedError(stepName, attempts, error) {
+  return {
+    kind: "exhausted",
+    stepName,
+    attempts,
+    error: parseStoredWorkflowError(error.lastError)
+  };
+}
+function mergeSchedulerYield(state, error) {
+  const nextState = state ?? {
+    messageNames: /* @__PURE__ */ new Set()
+  };
+  if (error instanceof SleepError) {
+    nextState.deadline = nextState.deadline === void 0 ? error.deadline : Math.min(nextState.deadline, error.deadline);
+    for (const messageName of error.messageNames ?? []) {
+      nextState.messageNames.add(messageName);
+    }
+    return nextState;
+  }
+  if (error instanceof MessageWaitError) {
+    for (const messageName of error.messageNames) {
+      nextState.messageNames.add(messageName);
+    }
+    return nextState;
+  }
+  nextState.deadline = nextState.deadline === void 0 ? error.retryAt : Math.min(nextState.deadline, error.retryAt);
+  return nextState;
+}
+function buildSchedulerYieldError(state) {
+  const messageNames = [...state.messageNames];
+  if (state.deadline !== void 0) {
+    return new SleepError(
+      state.deadline,
+      messageNames.length > 0 ? messageNames : void 0
+    );
+  }
+  return new MessageWaitError(messageNames);
+}
+function controlFlowErrorPriority(error) {
+  if (error instanceof EvictedError) {
+    return 0;
+  }
+  if (error instanceof HistoryDivergedError) {
+    return 1;
+  }
+  if (error instanceof EntryInProgressError) {
+    return 2;
+  }
+  if (error instanceof RollbackCheckpointError) {
+    return 3;
+  }
+  if (error instanceof RollbackStopError) {
+    return 4;
+  }
+  return 5;
+}
+function selectControlFlowError(current, candidate) {
+  if (!current) {
+    return candidate;
+  }
+  return controlFlowErrorPriority(candidate) < controlFlowErrorPriority(current) ? candidate : current;
+}
 var WorkflowContextImpl = class _WorkflowContextImpl {
   constructor(workflowId, storage, driver, messageDriver, location = emptyLocation(), abortController, mode = "forward", rollbackActions, rollbackCheckpointSet = false, historyNotifier, onError, logger, visitedKeys) {
     this.workflowId = workflowId;
@@ -1896,6 +2030,110 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
       this.entryInProgress = false;
     }
   }
+  async tryStep(nameOrConfig, run) {
+    const config2 = typeof nameOrConfig === "string" ? {
+      name: nameOrConfig,
+      run
+    } : nameOrConfig;
+    try {
+      return {
+        ok: true,
+        value: await this.step(config2)
+      };
+    } catch (error) {
+      if (shouldRethrowTryError(error)) {
+        throw error;
+      }
+      const failure = readTryStepFailure(error);
+      if (!failure || !shouldCatchTryStepFailure(failure, config2.catch)) {
+        throw error;
+      }
+      return {
+        ok: false,
+        failure
+      };
+    }
+  }
+  async try(nameOrConfig, run) {
+    this.assertNotInProgress();
+    this.checkEvicted();
+    const config2 = typeof nameOrConfig === "string" ? {
+      name: nameOrConfig,
+      run
+    } : nameOrConfig;
+    this.entryInProgress = true;
+    try {
+      return await this.executeTry(config2);
+    } finally {
+      this.entryInProgress = false;
+    }
+  }
+  async executeTry(config2) {
+    this.checkDuplicateName(config2.name);
+    const location = appendName(
+      this.storage,
+      this.currentLocation,
+      config2.name
+    );
+    const blockCtx = this.createBranch(location);
+    try {
+      const value = await config2.run(blockCtx);
+      blockCtx.validateComplete();
+      return {
+        ok: true,
+        value
+      };
+    } catch (error) {
+      if (shouldRethrowTryError(error)) {
+        throw error;
+      }
+      const stepFailure = readTryStepFailure(error);
+      if (stepFailure) {
+        const failure = {
+          source: "step",
+          name: stepFailure.stepName,
+          error: stepFailure.error,
+          step: stepFailure
+        };
+        if (!shouldCatchTryBlockFailure(failure, config2.catch)) {
+          throw error;
+        }
+        return {
+          ok: false,
+          failure
+        };
+      }
+      const operationFailure = readTryBlockFailure(error);
+      if (operationFailure) {
+        const failure = {
+          ...operationFailure,
+          error: extractErrorInfo(error)
+        };
+        if (!shouldCatchTryBlockFailure(failure, config2.catch)) {
+          throw error;
+        }
+        return {
+          ok: false,
+          failure
+        };
+      }
+      if (error instanceof RollbackError) {
+        const failure = {
+          source: "block",
+          name: config2.name,
+          error: extractErrorInfo(error)
+        };
+        if (!shouldCatchTryBlockFailure(failure, config2.catch)) {
+          throw error;
+        }
+        return {
+          ok: false,
+          failure
+        };
+      }
+      throw error;
+    }
+  }
   async executeStep(config2) {
     this.ensureRollbackCheckpoint(config2);
     if (this.mode === "rollback") {
@@ -1928,9 +2166,19 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
       const maxRetries2 = config2.maxRetries ?? DEFAULT_MAX_RETRIES;
       if (metadata2.attempts > maxRetries2) {
         const lastError = stepData.error ?? metadata2.error;
-        const exhaustedError = markErrorReported(
-          new StepExhaustedError(config2.name, lastError)
+        const exhaustedError = new StepExhaustedError(
+          config2.name,
+          lastError
         );
+        attachTryStepFailure(
+          exhaustedError,
+          getTryStepFailureFromExhaustedError(
+            config2.name,
+            metadata2.attempts,
+            exhaustedError
+          )
+        );
+        markErrorReported(exhaustedError);
         if (metadata2.status !== "exhausted") {
           metadata2.status = "exhausted";
           metadata2.dirty = true;
@@ -2017,7 +2265,17 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
         await this.notifyStepError(config2, metadata.attempts, error, {
           willRetry: false
         });
-        throw markErrorReported(new CriticalError(error.message));
+        throw markErrorReported(
+          attachTryStepFailure(
+            new CriticalError(error.message),
+            {
+              kind: "timeout",
+              stepName: config2.name,
+              attempts: metadata.attempts,
+              error: extractErrorInfo(error)
+            }
+          )
+        );
       }
       if (error instanceof CriticalError || error instanceof RollbackError) {
         if (entry.kind.type === "step") {
@@ -2030,7 +2288,14 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
         await this.notifyStepError(config2, metadata.attempts, error, {
           willRetry: false
         });
-        throw markErrorReported(error);
+        throw markErrorReported(
+          attachTryStepFailure(error, {
+            kind: error instanceof RollbackError ? "rollback" : "critical",
+            stepName: config2.name,
+            attempts: metadata.attempts,
+            error: extractErrorInfo(error)
+          })
+        );
       }
       if (entry.kind.type === "step") {
         entry.kind.data.error = String(error);
@@ -2060,7 +2325,15 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
         );
       }
       const exhaustedError = markErrorReported(
-        new StepExhaustedError(config2.name, String(error))
+        attachTryStepFailure(
+          new StepExhaustedError(config2.name, String(error)),
+          {
+            kind: "exhausted",
+            stepName: config2.name,
+            attempts: metadata.attempts,
+            error: extractErrorInfo(error)
+          }
+        )
       );
       await this.notifyStepError(config2, metadata.attempts, error, {
         willRetry: false
@@ -2835,9 +3108,29 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
     const joinData = entry.kind.data;
     const results = {};
     const errors = {};
+    let schedulerYieldState;
+    let propagatedError;
+    for (const [branchName, branchStatus] of Object.entries(
+      joinData.branches
+    )) {
+      if (branchStatus.status === "completed") {
+        results[branchName] = branchStatus.output;
+        continue;
+      }
+      if (branchStatus.status === "failed") {
+        errors[branchName] = new Error(
+          branchStatus.error ?? "branch failed"
+        );
+      }
+    }
     const branchPromises = Object.entries(branches).map(
       async ([branchName, config2]) => {
         const branchStatus = joinData.branches[branchName];
+        if (!branchStatus) {
+          throw new HistoryDivergedError(
+            `Expected join branch "${branchName}" in "${name}"`
+          );
+        }
         if (branchStatus.status === "completed") {
           results[branchName] = branchStatus.output;
           return;
@@ -2853,15 +3146,38 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
         );
         const branchCtx = this.createBranch(branchLocation);
         branchStatus.status = "running";
+        branchStatus.error = void 0;
         entry.dirty = true;
         try {
           const output = await config2.run(branchCtx);
           branchCtx.validateComplete();
           branchStatus.status = "completed";
           branchStatus.output = output;
+          branchStatus.error = void 0;
           results[branchName] = output;
         } catch (error) {
+          if (error instanceof SleepError || error instanceof MessageWaitError || error instanceof StepFailedError) {
+            schedulerYieldState = mergeSchedulerYield(
+              schedulerYieldState,
+              error
+            );
+            branchStatus.status = "running";
+            branchStatus.error = void 0;
+            entry.dirty = true;
+            return;
+          }
+          if (error instanceof EvictedError || error instanceof HistoryDivergedError || error instanceof EntryInProgressError || error instanceof RollbackCheckpointError || error instanceof RollbackStopError) {
+            propagatedError = selectControlFlowError(
+              propagatedError,
+              error
+            );
+            branchStatus.status = "running";
+            branchStatus.error = void 0;
+            entry.dirty = true;
+            return;
+          }
           branchStatus.status = "failed";
+          branchStatus.output = void 0;
           branchStatus.error = String(error);
           errors[branchName] = error;
         }
@@ -2870,8 +3186,24 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
     );
     await Promise.allSettled(branchPromises);
     await this.flushStorage();
+    if (propagatedError) {
+      throw propagatedError;
+    }
+    if (Object.values(joinData.branches).some(
+      (branch) => branch.status === "pending" || branch.status === "running"
+    )) {
+      if (!schedulerYieldState) {
+        throw new Error(
+          `Join "${name}" has pending branches without a scheduler yield`
+        );
+      }
+      throw buildSchedulerYieldError(schedulerYieldState);
+    }
     if (Object.keys(errors).length > 0) {
-      throw new JoinError(errors);
+      throw attachTryBlockFailure(new JoinError(errors), {
+        source: "join",
+        name
+      });
     }
     return results;
   }
@@ -2934,28 +3266,42 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
     const raceAbortController = new AbortController();
     const branchPromises = [];
     let winnerName = null;
-    let winnerValue = null;
-    let settled = false;
-    let pendingCount = branches.length;
+    let winnerValue;
+    let hasWinner = false;
     const errors = {};
     const lateErrors = [];
-    let yieldError = null;
+    let schedulerYieldState;
+    let propagatedError;
     for (const branch of branches) {
       const branchStatus = raceData.branches[branch.name];
+      if (!branchStatus) {
+        throw new HistoryDivergedError(
+          `Expected race branch "${branch.name}" in "${name}"`
+        );
+      }
       if (branchStatus.status !== "pending" && branchStatus.status !== "running") {
-        pendingCount--;
-        if (branchStatus.status === "completed" && !settled) {
-          settled = true;
+        if (branchStatus.status === "failed") {
+          errors[branch.name] = new Error(
+            branchStatus.error ?? "branch failed"
+          );
+        }
+        if (branchStatus.status === "completed" && !hasWinner) {
+          hasWinner = true;
           winnerName = branch.name;
           winnerValue = branchStatus.output;
         }
       }
     }
-    if (settled && winnerName !== null && winnerValue !== null) {
+    if (hasWinner && winnerName !== null) {
       return { winner: winnerName, value: winnerValue };
     }
     for (const branch of branches) {
       const branchStatus = raceData.branches[branch.name];
+      if (!branchStatus) {
+        throw new HistoryDivergedError(
+          `Expected race branch "${branch.name}" in "${name}"`
+        );
+      }
       if (branchStatus.status !== "pending" && branchStatus.status !== "running") {
         continue;
       }
@@ -2969,78 +3315,98 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
         raceAbortController
       );
       branchStatus.status = "running";
+      branchStatus.error = void 0;
       entry.dirty = true;
       const branchPromise = branch.run(branchCtx).then(
         async (output) => {
-          if (settled) {
+          if (hasWinner) {
+            branchStatus.status = "completed";
+            branchStatus.output = output;
+            branchStatus.error = void 0;
+            entry.dirty = true;
+            return;
+          }
+          if (propagatedError) {
             branchStatus.status = "completed";
             branchStatus.output = output;
+            branchStatus.error = void 0;
             entry.dirty = true;
             return;
           }
-          settled = true;
+          hasWinner = true;
           winnerName = branch.name;
           winnerValue = output;
           branchCtx.validateComplete();
           branchStatus.status = "completed";
           branchStatus.output = output;
+          branchStatus.error = void 0;
           raceData.winner = branch.name;
           entry.dirty = true;
           raceAbortController.abort();
         },
         (error) => {
-          pendingCount--;
-          if (error instanceof SleepError) {
-            if (!yieldError || !(yieldError instanceof SleepError) || error.deadline < yieldError.deadline) {
-              yieldError = error;
+          if (hasWinner) {
+            if (error instanceof CancelledError || error instanceof EvictedError) {
+              branchStatus.status = "cancelled";
+            } else {
+              lateErrors.push({
+                name: branch.name,
+                error: String(error)
+              });
             }
+            entry.dirty = true;
+            return;
+          }
+          if (error instanceof SleepError || error instanceof MessageWaitError || error instanceof StepFailedError) {
+            schedulerYieldState = mergeSchedulerYield(
+              schedulerYieldState,
+              error
+            );
             branchStatus.status = "running";
+            branchStatus.error = void 0;
             entry.dirty = true;
             return;
           }
-          if (error instanceof MessageWaitError) {
-            if (!yieldError || !(yieldError instanceof SleepError)) {
-              if (!yieldError) {
-                yieldError = error;
-              } else if (yieldError instanceof MessageWaitError) {
-                yieldError = new MessageWaitError([
-                  ...yieldError.messageNames,
-                  ...error.messageNames
-                ]);
-              }
-            }
+          if (error instanceof EvictedError || error instanceof HistoryDivergedError || error instanceof EntryInProgressError || error instanceof RollbackCheckpointError || error instanceof RollbackStopError) {
+            propagatedError = selectControlFlowError(
+              propagatedError,
+              error
+            );
             branchStatus.status = "running";
+            branchStatus.error = void 0;
             entry.dirty = true;
             return;
           }
-          if (error instanceof CancelledError || error instanceof EvictedError) {
+          if (error instanceof CancelledError) {
             branchStatus.status = "cancelled";
           } else {
             branchStatus.status = "failed";
+            branchStatus.output = void 0;
             branchStatus.error = String(error);
-            if (settled) {
-              lateErrors.push({
-                name: branch.name,
-                error: String(error)
-              });
-            } else {
-              errors[branch.name] = error;
-            }
+            errors[branch.name] = error;
           }
           entry.dirty = true;
-          if (pendingCount === 0 && !settled) {
-            settled = true;
-          }
         }
       );
       branchPromises.push(branchPromise);
     }
     await Promise.allSettled(branchPromises);
-    if (yieldError && !settled) {
+    if (propagatedError) {
+      await this.flushStorage();
+      throw propagatedError;
+    }
+    if (!hasWinner && Object.values(raceData.branches).some(
+      (branch) => branch.status === "pending" || branch.status === "running"
+    )) {
       await this.flushStorage();
-      throw yieldError;
+      if (!schedulerYieldState) {
+        throw new Error(
+          `Race "${name}" has pending branches without a scheduler yield`
+        );
+      }
+      throw buildSchedulerYieldError(schedulerYieldState);
     }
-    if (winnerName !== null) {
+    if (hasWinner && winnerName !== null) {
       for (const branch of branches) {
         if (branch.name !== winnerName) {
           const branchLocation = appendName(
@@ -3064,15 +3430,21 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
         lateErrors
       );
     }
-    if (winnerName !== null && winnerValue !== null) {
+    if (hasWinner && winnerName !== null) {
       return { winner: winnerName, value: winnerValue };
     }
-    throw new RaceError(
-      "All branches failed",
-      Object.entries(errors).map(([name2, error]) => ({
-        name: name2,
-        error: String(error)
-      }))
+    throw attachTryBlockFailure(
+      new RaceError(
+        "All branches failed",
+        Object.entries(errors).map(([branchName, error]) => ({
+          name: branchName,
+          error: String(error)
+        }))
+      ),
+      {
+        source: "race",
+        name
+      }
     );
   }
   // === Removed ===
@@ -3805,4 +4177,4 @@ export {
   runWorkflow,
   replayWorkflowFromStep
 };
-//# sourceMappingURL=chunk-4ME2JBMC.js.map
+//# sourceMappingURL=chunk-UMFB2AR3.js.map