@rivetkit/workflow-engine 2.1.6 → 2.1.8

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

@@ -1,3 +1,53 @@
+// src/error-utils.ts
+var WORKFLOW_ERROR_REPORTED_SYMBOL = /* @__PURE__ */ Symbol("workflow.error.reported");
+function extractErrorInfo(error) {
+  if (error instanceof Error) {
+    const result = {
+      name: error.name,
+      message: error.message,
+      stack: error.stack
+    };
+    const metadata = {};
+    for (const key of Object.keys(error)) {
+      if (key !== "name" && key !== "message" && key !== "stack") {
+        const value = error[key];
+        if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null) {
+          metadata[key] = value;
+        }
+      }
+    }
+    if (Object.keys(metadata).length > 0) {
+      result.metadata = metadata;
+    }
+    return result;
+  }
+  return {
+    name: "Error",
+    message: String(error)
+  };
+}
+function markErrorReported(error) {
+  error[WORKFLOW_ERROR_REPORTED_SYMBOL] = true;
+  return error;
+}
+function isErrorReported(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return Boolean(
+    error[WORKFLOW_ERROR_REPORTED_SYMBOL]
+  );
+}
+function getErrorEventTag(event) {
+  if ("step" in event) {
+    return "step";
+  }
+  if ("rollback" in event) {
+    return "rollback";
+  }
+  return "workflow";
+}
+
 // src/errors.ts
 var CriticalError = class extends Error {
   constructor(message) {
@@ -63,11 +113,12 @@ var StepExhaustedError = class extends Error {
   }
 };
 var StepFailedError = class extends Error {
-  constructor(stepName, originalError, attempts) {
+  constructor(stepName, originalError, attempts, retryAt) {
     super(`Step "${stepName}" failed (attempt ${attempts})`);
     this.stepName = stepName;
     this.originalError = originalError;
     this.attempts = attempts;
+    this.retryAt = retryAt;
     this.name = "StepFailedError";
     this.cause = originalError;
   }
@@ -101,6 +152,133 @@ var EntryInProgressError = class extends Error {
   }
 };
 
+// src/keys.ts
+import * as tuple from "fdb-tuple";
+var KEY_PREFIX = {
+  NAMES: 1,
+  // Name registry: [1, index]
+  HISTORY: 2,
+  // History entries: [2, ...locationSegments]
+  WORKFLOW: 3,
+  // Workflow metadata: [3, field]
+  ENTRY_METADATA: 4
+  // Entry metadata: [4, entryId]
+};
+var WORKFLOW_FIELD = {
+  STATE: 1,
+  OUTPUT: 2,
+  ERROR: 3,
+  INPUT: 4
+};
+function segmentToTuple(segment) {
+  if (typeof segment === "number") {
+    return segment;
+  }
+  return [segment.loop, segment.iteration];
+}
+function locationToTupleElements(location) {
+  return location.map(segmentToTuple);
+}
+function bufferToUint8Array(buf) {
+  return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+}
+function uint8ArrayToBuffer(arr) {
+  return Buffer.from(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function pack2(items) {
+  const buf = tuple.pack(items);
+  return bufferToUint8Array(buf);
+}
+function unpack2(data) {
+  const buf = uint8ArrayToBuffer(data);
+  return tuple.unpack(buf);
+}
+function buildNameKey(index) {
+  return pack2([KEY_PREFIX.NAMES, index]);
+}
+function buildNamePrefix() {
+  return pack2([KEY_PREFIX.NAMES]);
+}
+function buildHistoryKey(location) {
+  return pack2([KEY_PREFIX.HISTORY, ...locationToTupleElements(location)]);
+}
+function buildHistoryPrefix(location) {
+  return pack2([KEY_PREFIX.HISTORY, ...locationToTupleElements(location)]);
+}
+function buildLoopIterationRange(loopLocation, loopSegment, fromIteration, toIteration) {
+  const loopLocationSegments = locationToTupleElements(loopLocation);
+  return {
+    start: pack2([
+      KEY_PREFIX.HISTORY,
+      ...loopLocationSegments,
+      [loopSegment, fromIteration]
+    ]),
+    end: pack2([
+      KEY_PREFIX.HISTORY,
+      ...loopLocationSegments,
+      [loopSegment, toIteration]
+    ])
+  };
+}
+function buildHistoryPrefixAll() {
+  return pack2([KEY_PREFIX.HISTORY]);
+}
+function buildWorkflowStateKey() {
+  return pack2([KEY_PREFIX.WORKFLOW, WORKFLOW_FIELD.STATE]);
+}
+function buildWorkflowOutputKey() {
+  return pack2([KEY_PREFIX.WORKFLOW, WORKFLOW_FIELD.OUTPUT]);
+}
+function buildWorkflowErrorKey() {
+  return pack2([KEY_PREFIX.WORKFLOW, WORKFLOW_FIELD.ERROR]);
+}
+function buildWorkflowInputKey() {
+  return pack2([KEY_PREFIX.WORKFLOW, WORKFLOW_FIELD.INPUT]);
+}
+function buildEntryMetadataKey(entryId) {
+  return pack2([KEY_PREFIX.ENTRY_METADATA, entryId]);
+}
+function buildEntryMetadataPrefix() {
+  return pack2([KEY_PREFIX.ENTRY_METADATA]);
+}
+function parseNameKey(key) {
+  const elements = unpack2(key);
+  if (elements.length !== 2 || elements[0] !== KEY_PREFIX.NAMES) {
+    throw new Error("Invalid name key");
+  }
+  return elements[1];
+}
+function parseEntryMetadataKey(key) {
+  const elements = unpack2(key);
+  if (elements.length !== 2 || elements[0] !== KEY_PREFIX.ENTRY_METADATA) {
+    throw new Error("Invalid entry metadata key");
+  }
+  return elements[1];
+}
+function keyStartsWith(key, prefix) {
+  if (key.length < prefix.length) {
+    return false;
+  }
+  for (let i = 0; i < prefix.length; i++) {
+    if (key[i] !== prefix[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function compareKeys(a, b) {
+  const minLen = Math.min(a.length, b.length);
+  for (let i = 0; i < minLen; i++) {
+    if (a[i] !== b[i]) {
+      return a[i] - b[i];
+    }
+  }
+  return a.length - b.length;
+}
+function keyToHex(key) {
+  return Array.from(key).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
 // src/location.ts
 function isLoopIterationMarker(segment) {
   return typeof segment === "object" && "loop" in segment;
@@ -1223,111 +1401,6 @@ function deserializeName(bytes) {
   return decoder.decode(bytes);
 }
 
-// src/keys.ts
-import * as tuple from "fdb-tuple";
-var KEY_PREFIX = {
-  NAMES: 1,
-  // Name registry: [1, index]
-  HISTORY: 2,
-  // History entries: [2, ...locationSegments]
-  WORKFLOW: 3,
-  // Workflow metadata: [3, field]
-  ENTRY_METADATA: 4
-  // Entry metadata: [4, entryId]
-};
-var WORKFLOW_FIELD = {
-  STATE: 1,
-  OUTPUT: 2,
-  ERROR: 3,
-  INPUT: 4
-};
-function segmentToTuple(segment) {
-  if (typeof segment === "number") {
-    return segment;
-  }
-  return [segment.loop, segment.iteration];
-}
-function locationToTupleElements(location) {
-  return location.map(segmentToTuple);
-}
-function bufferToUint8Array(buf) {
-  return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
-}
-function uint8ArrayToBuffer(arr) {
-  return Buffer.from(arr.buffer, arr.byteOffset, arr.byteLength);
-}
-function pack2(items) {
-  const buf = tuple.pack(items);
-  return bufferToUint8Array(buf);
-}
-function unpack2(data) {
-  const buf = uint8ArrayToBuffer(data);
-  return tuple.unpack(buf);
-}
-function buildNameKey(index) {
-  return pack2([KEY_PREFIX.NAMES, index]);
-}
-function buildNamePrefix() {
-  return pack2([KEY_PREFIX.NAMES]);
-}
-function buildHistoryKey(location) {
-  return pack2([KEY_PREFIX.HISTORY, ...locationToTupleElements(location)]);
-}
-function buildHistoryPrefix(location) {
-  return pack2([KEY_PREFIX.HISTORY, ...locationToTupleElements(location)]);
-}
-function buildHistoryPrefixAll() {
-  return pack2([KEY_PREFIX.HISTORY]);
-}
-function buildWorkflowStateKey() {
-  return pack2([KEY_PREFIX.WORKFLOW, WORKFLOW_FIELD.STATE]);
-}
-function buildWorkflowOutputKey() {
-  return pack2([KEY_PREFIX.WORKFLOW, WORKFLOW_FIELD.OUTPUT]);
-}
-function buildWorkflowErrorKey() {
-  return pack2([KEY_PREFIX.WORKFLOW, WORKFLOW_FIELD.ERROR]);
-}
-function buildWorkflowInputKey() {
-  return pack2([KEY_PREFIX.WORKFLOW, WORKFLOW_FIELD.INPUT]);
-}
-function buildEntryMetadataKey(entryId) {
-  return pack2([KEY_PREFIX.ENTRY_METADATA, entryId]);
-}
-function buildEntryMetadataPrefix() {
-  return pack2([KEY_PREFIX.ENTRY_METADATA]);
-}
-function parseNameKey(key) {
-  const elements = unpack2(key);
-  if (elements.length !== 2 || elements[0] !== KEY_PREFIX.NAMES) {
-    throw new Error("Invalid name key");
-  }
-  return elements[1];
-}
-function keyStartsWith(key, prefix) {
-  if (key.length < prefix.length) {
-    return false;
-  }
-  for (let i = 0; i < prefix.length; i++) {
-    if (key[i] !== prefix[i]) {
-      return false;
-    }
-  }
-  return true;
-}
-function compareKeys(a, b) {
-  const minLen = Math.min(a.length, b.length);
-  for (let i = 0; i < minLen; i++) {
-    if (a[i] !== b[i]) {
-      return a[i] - b[i];
-    }
-  }
-  return a.length - b.length;
-}
-function keyToHex(key) {
-  return Array.from(key).map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-
 // src/storage.ts
 function createStorage() {
   return {
@@ -1406,6 +1479,13 @@ async function loadStorage(driver) {
     const key = locationToKey(storage, parsed.location);
     storage.history.entries.set(key, parsed);
   }
+  const metadataEntries = await driver.list(buildEntryMetadataPrefix());
+  for (const entry of metadataEntries) {
+    const entryId = parseEntryMetadataKey(entry.key);
+    const metadata = deserializeEntryMetadata(entry.value);
+    metadata.dirty = false;
+    storage.entryMetadata.set(entryId, metadata);
+  }
   const stateValue = await driver.get(buildWorkflowStateKey());
   if (stateValue) {
     storage.state = deserializeWorkflowState(stateValue);
@@ -1437,7 +1517,7 @@ async function loadMetadata(storage, driver, entryId) {
   }
   return getOrCreateMetadata(storage, entryId);
 }
-async function flush(storage, driver, onHistoryUpdated) {
+async function flush(storage, driver, onHistoryUpdated, pendingDeletions) {
   const writes = [];
   let historyUpdated = false;
   for (let i = storage.flushedNameCount; i < storage.nameRegistry.length; i++) {
@@ -1492,6 +1572,22 @@ async function flush(storage, driver, onHistoryUpdated) {
   if (writes.length > 0) {
     await driver.batch(writes);
   }
+  if (pendingDeletions) {
+    const deleteOps = [];
+    for (const prefix of pendingDeletions.prefixes) {
+      deleteOps.push(driver.deletePrefix(prefix));
+    }
+    for (const range of pendingDeletions.ranges) {
+      deleteOps.push(driver.deleteRange(range.start, range.end));
+    }
+    for (const key of pendingDeletions.keys) {
+      deleteOps.push(driver.delete(key));
+    }
+    if (deleteOps.length > 0) {
+      await Promise.all(deleteOps);
+      historyUpdated = true;
+    }
+  }
   storage.flushedNameCount = storage.nameRegistry.length;
   storage.flushedState = storage.state;
   storage.flushedOutput = storage.output;
@@ -1501,21 +1597,27 @@ async function flush(storage, driver, onHistoryUpdated) {
   }
 }
 async function deleteEntriesWithPrefix(storage, driver, prefixLocation, onHistoryUpdated) {
-  const entryIds = [];
+  const deletions = collectDeletionsForPrefix(storage, prefixLocation);
+  await driver.deletePrefix(deletions.prefixes[0]);
+  await Promise.all(deletions.keys.map((key) => driver.delete(key)));
+  if (deletions.keys.length > 0 && onHistoryUpdated) {
+    onHistoryUpdated();
+  }
+}
+function collectDeletionsForPrefix(storage, prefixLocation) {
+  const pending = {
+    prefixes: [buildHistoryPrefix(prefixLocation)],
+    keys: [],
+    ranges: []
+  };
   for (const [key, entry] of storage.history.entries) {
     if (isLocationPrefix(prefixLocation, entry.location)) {
-      entryIds.push(entry.id);
+      pending.keys.push(buildEntryMetadataKey(entry.id));
       storage.entryMetadata.delete(entry.id);
       storage.history.entries.delete(key);
     }
   }
-  await driver.deletePrefix(buildHistoryPrefix(prefixLocation));
-  await Promise.all(
-    entryIds.map((id) => driver.delete(buildEntryMetadataKey(id)))
-  );
-  if (entryIds.length > 0 && onHistoryUpdated) {
-    onHistoryUpdated();
-  }
+  return pending;
 }
 function getEntry(storage, location) {
   const key = locationToKey(storage, location);
@@ -1554,9 +1656,7 @@ function setLongTimeout(listener, after) {
 var DEFAULT_MAX_RETRIES = 3;
 var DEFAULT_RETRY_BACKOFF_BASE = 100;
 var DEFAULT_RETRY_BACKOFF_MAX = 3e4;
-var DEFAULT_LOOP_COMMIT_INTERVAL = 20;
-var DEFAULT_LOOP_HISTORY_EVERY = 20;
-var DEFAULT_LOOP_HISTORY_KEEP = 20;
+var DEFAULT_LOOP_HISTORY_PRUNE_INTERVAL = 20;
 var DEFAULT_STEP_TIMEOUT = 3e4;
 var QUEUE_HISTORY_MESSAGE_MARKER = "__rivetWorkflowQueueMessage";
 function calculateBackoff(attempts, base, max) {
@@ -1571,7 +1671,7 @@ var StepTimeoutError = class extends Error {
   }
 };
 var WorkflowContextImpl = class _WorkflowContextImpl {
-  constructor(workflowId, storage, driver, messageDriver, location = emptyLocation(), abortController, mode = "forward", rollbackActions, rollbackCheckpointSet = false, historyNotifier, logger) {
+  constructor(workflowId, storage, driver, messageDriver, location = emptyLocation(), abortController, mode = "forward", rollbackActions, rollbackCheckpointSet = false, historyNotifier, onError, logger, visitedKeys) {
     this.workflowId = workflowId;
     this.storage = storage;
     this.driver = driver;
@@ -1582,12 +1682,14 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
     this.rollbackActions = rollbackActions;
     this.rollbackCheckpointSet = rollbackCheckpointSet;
     this.historyNotifier = historyNotifier;
+    this.onError = onError;
     this.logger = logger;
+    this.visitedKeys = visitedKeys ?? /* @__PURE__ */ new Set();
   }
   entryInProgress = false;
   abortController;
   currentLocation;
-  visitedKeys = /* @__PURE__ */ new Set();
+  visitedKeys;
   mode;
   rollbackActions;
   rollbackCheckpointSet;
@@ -1595,6 +1697,7 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
   usedNamesInExecution = /* @__PURE__ */ new Set();
   pendingCompletableMessageIds = /* @__PURE__ */ new Set();
   historyNotifier;
+  onError;
   logger;
   get abortSignal() {
     return this.abortController.signal;
@@ -1637,7 +1740,9 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
       this.rollbackActions,
       this.rollbackCheckpointSet,
       this.historyNotifier,
-      this.logger
+      this.onError,
+      this.logger,
+      this.visitedKeys
     );
   }
   /**
@@ -1647,6 +1752,36 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
     if (!this.logger) return;
     this.logger[level](data);
   }
+  async notifyError(event) {
+    if (!this.onError) {
+      return;
+    }
+    try {
+      await this.onError(event);
+    } catch (error) {
+      this.log("warn", {
+        msg: "workflow error hook failed",
+        hookEventType: getErrorEventTag(event),
+        error: extractErrorInfo(error)
+      });
+    }
+  }
+  async notifyStepError(config2, attempt, error, opts) {
+    const maxRetries = config2.maxRetries ?? DEFAULT_MAX_RETRIES;
+    await this.notifyError({
+      step: {
+        workflowId: this.workflowId,
+        stepName: config2.name,
+        attempt,
+        maxRetries,
+        remainingRetries: Math.max(0, maxRetries - (attempt - 1)),
+        willRetry: opts.willRetry,
+        retryDelay: opts.retryDelay,
+        retryAt: opts.retryAt,
+        error: extractErrorInfo(error)
+      }
+    });
+  }
   /**
    * Mark a key as visited.
    */
@@ -1790,10 +1925,24 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
       if (metadata2.status === "completed" || stepData.output !== void 0) {
         return stepData.output;
       }
-      const maxRetries = config2.maxRetries ?? DEFAULT_MAX_RETRIES;
-      if (metadata2.attempts >= maxRetries) {
+      const maxRetries2 = config2.maxRetries ?? DEFAULT_MAX_RETRIES;
+      if (metadata2.attempts > maxRetries2) {
         const lastError = stepData.error ?? metadata2.error;
-        throw new StepExhaustedError(config2.name, lastError);
+        const exhaustedError = markErrorReported(
+          new StepExhaustedError(config2.name, lastError)
+        );
+        if (metadata2.status !== "exhausted") {
+          metadata2.status = "exhausted";
+          metadata2.dirty = true;
+          await this.flushStorage();
+          await this.notifyStepError(
+            config2,
+            metadata2.attempts,
+            exhaustedError,
+            { willRetry: false }
+          );
+        }
+        throw exhaustedError;
       }
       const backoffDelay = calculateBackoff(
         metadata2.attempts,
@@ -1808,7 +1957,11 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
     }
     const entry = existing ?? createEntry(location, { type: "step", data: {} });
     if (!existing) {
-      this.log("debug", { msg: "executing new step", step: config2.name, key });
+      this.log("debug", {
+        msg: "executing new step",
+        step: config2.name,
+        key
+      });
       const nameIndex = registerName(this.storage, config2.name);
       entry.location = [...location];
       entry.location[entry.location.length - 1] = nameIndex;
@@ -1817,6 +1970,9 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
       this.log("debug", { msg: "retrying step", step: config2.name, key });
     }
     const metadata = getOrCreateMetadata(this.storage, entry.id);
+    const maxRetries = config2.maxRetries ?? DEFAULT_MAX_RETRIES;
+    const retryBackoffBase = config2.retryBackoffBase ?? DEFAULT_RETRY_BACKOFF_BASE;
+    const retryBackoffMax = config2.retryBackoffMax ?? DEFAULT_RETRY_BACKOFF_MAX;
     metadata.status = "running";
     metadata.attempts++;
     metadata.lastAttemptAt = Date.now();
@@ -1836,10 +1992,18 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
       metadata.error = void 0;
       metadata.completedAt = Date.now();
       if (!config2.ephemeral) {
-        this.log("debug", { msg: "flushing step", step: config2.name, key });
+        this.log("debug", {
+          msg: "flushing step",
+          step: config2.name,
+          key
+        });
         await this.flushStorage();
       }
-      this.log("debug", { msg: "step completed", step: config2.name, key });
+      this.log("debug", {
+        msg: "step completed",
+        step: config2.name,
+        key
+      });
       return output;
     } catch (error) {
       if (error instanceof StepTimeoutError) {
@@ -1850,7 +2014,10 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
         metadata.status = "exhausted";
         metadata.error = String(error);
         await this.flushStorage();
-        throw new CriticalError(error.message);
+        await this.notifyStepError(config2, metadata.attempts, error, {
+          willRetry: false
+        });
+        throw markErrorReported(new CriticalError(error.message));
       }
       if (error instanceof CriticalError || error instanceof RollbackError) {
         if (entry.kind.type === "step") {
@@ -1860,16 +2027,45 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
         metadata.status = "exhausted";
         metadata.error = String(error);
         await this.flushStorage();
-        throw error;
+        await this.notifyStepError(config2, metadata.attempts, error, {
+          willRetry: false
+        });
+        throw markErrorReported(error);
       }
       if (entry.kind.type === "step") {
         entry.kind.data.error = String(error);
       }
       entry.dirty = true;
-      metadata.status = "failed";
+      const willRetry = metadata.attempts <= maxRetries;
+      metadata.status = willRetry ? "failed" : "exhausted";
       metadata.error = String(error);
       await this.flushStorage();
-      throw new StepFailedError(config2.name, error, metadata.attempts);
+      if (willRetry) {
+        const retryDelay = calculateBackoff(
+          metadata.attempts,
+          retryBackoffBase,
+          retryBackoffMax
+        );
+        const retryAt = metadata.lastAttemptAt + retryDelay;
+        await this.notifyStepError(config2, metadata.attempts, error, {
+          willRetry: true,
+          retryDelay,
+          retryAt
+        });
+        throw new StepFailedError(
+          config2.name,
+          error,
+          metadata.attempts,
+          retryAt
+        );
+      }
+      const exhaustedError = markErrorReported(
+        new StepExhaustedError(config2.name, String(error))
+      );
+      await this.notifyStepError(config2, metadata.attempts, error, {
+        willRetry: false
+      });
+      throw exhaustedError;
     }
   }
   /**
@@ -1970,7 +2166,11 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
         );
       }
       const loopData = existing.kind.data;
-      metadata = await loadMetadata(this.storage, this.driver, existing.id);
+      metadata = await loadMetadata(
+        this.storage,
+        this.driver,
+        existing.id
+      );
       if (rollbackMode) {
         if (loopData.output !== void 0) {
           return loopData.output;
@@ -2008,10 +2208,15 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
       metadata.error = void 0;
       metadata.dirty = true;
     }
-    const commitInterval = config2.commitInterval ?? DEFAULT_LOOP_COMMIT_INTERVAL;
-    const historyEvery = config2.historyEvery ?? config2.commitInterval ?? DEFAULT_LOOP_HISTORY_EVERY;
-    const historyKeep = config2.historyKeep ?? config2.commitInterval ?? DEFAULT_LOOP_HISTORY_KEEP;
+    const historyPruneInterval = config2.historyPruneInterval ?? DEFAULT_LOOP_HISTORY_PRUNE_INTERVAL;
+    const historySize = config2.historySize ?? historyPruneInterval;
+    let lastPrunedUpTo = 0;
+    let deferredFlush = null;
     while (true) {
+      if (deferredFlush) {
+        await deferredFlush;
+        deferredFlush = null;
+      }
       if (rollbackMode && rollbackSingleIteration) {
         if (rollbackIterationRan) {
           return rollbackOutput;
@@ -2046,13 +2251,13 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
           metadata.completedAt = Date.now();
           metadata.dirty = true;
         }
-        await this.flushStorage();
-        await this.forgetOldIterations(
+        const deletions = this.collectLoopPruning(
           location,
           iteration + 1,
-          historyEvery,
-          historyKeep
+          historySize,
+          lastPrunedUpTo
         );
+        await this.flushStorageWithDeletions(deletions);
         if (rollbackMode && rollbackSingleIteration) {
           rollbackOutput = result.value;
           rollbackIterationRan = true;
@@ -2064,60 +2269,75 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
         state = result.state;
       }
       iteration++;
-      if (iteration % commitInterval === 0) {
+      if (!rollbackMode) {
         if (entry.kind.type === "loop") {
           entry.kind.data.state = state;
           entry.kind.data.iteration = iteration;
         }
         entry.dirty = true;
-        await this.flushStorage();
-        await this.forgetOldIterations(
+      }
+      if (iteration % historyPruneInterval === 0) {
+        const deletions = this.collectLoopPruning(
           location,
           iteration,
-          historyEvery,
-          historyKeep
+          historySize,
+          lastPrunedUpTo
         );
+        lastPrunedUpTo = Math.max(0, iteration - historySize);
+        deferredFlush = this.flushStorageWithDeletions(deletions);
       }
     }
   }
   /**
-   * Delete old loop iteration entries to save storage space.
-   *
-   * Loop locations always end with a NameIndex (number) because loops are
-   * created via appendName(). Even for nested loops, the innermost loop's
-   * location ends with its name index:
+   * Collect pending deletions for loop history pruning.
    *
-   *   ctx.loop("outer") → location: [outerIndex]
-   *     iteration 0    → location: [{ loop: outerIndex, iteration: 0 }]
-   *       ctx.loop("inner") → location: [{ loop: outerIndex, iteration: 0 }, innerIndex]
-   *
-   * This function removes iterations older than (currentIteration - historyKeep)
-   * every historyEvery iterations.
+   * Only deletes iterations in the range [fromIteration, keepFrom) where
+   * keepFrom = currentIteration - historySize. This avoids re-scanning
+   * already-deleted iterations.
    */
-  async forgetOldIterations(loopLocation, currentIteration, historyEvery, historyKeep) {
-    if (historyEvery <= 0 || historyKeep <= 0) {
-      return;
+  collectLoopPruning(loopLocation, currentIteration, historySize, fromIteration) {
+    if (currentIteration <= historySize) {
+      return void 0;
     }
-    if (currentIteration === 0 || currentIteration % historyEvery !== 0) {
-      return;
+    const keepFrom = Math.max(0, currentIteration - historySize);
+    if (fromIteration >= keepFrom) {
+      return void 0;
     }
-    const keepFrom = Math.max(0, currentIteration - historyKeep);
     const loopSegment = loopLocation[loopLocation.length - 1];
     if (typeof loopSegment !== "number") {
       throw new Error("Expected loop location to end with a name index");
     }
-    for (let i = 0; i < keepFrom; i++) {
-      const iterationLocation = [
-        ...loopLocation,
-        { loop: loopSegment, iteration: i }
-      ];
-      await deleteEntriesWithPrefix(
-        this.storage,
-        this.driver,
-        iterationLocation,
-        this.historyNotifier
-      );
+    const range = buildLoopIterationRange(
+      loopLocation,
+      loopSegment,
+      fromIteration,
+      keepFrom
+    );
+    const metadataKeys = [];
+    for (const [key, entry] of this.storage.history.entries) {
+      if (!isLocationPrefix(loopLocation, entry.location)) {
+        continue;
+      }
+      const iterationSegment = entry.location[loopLocation.length];
+      if (!iterationSegment || typeof iterationSegment === "number" || iterationSegment.loop !== loopSegment || iterationSegment.iteration < fromIteration || iterationSegment.iteration >= keepFrom) {
+        continue;
+      }
+      metadataKeys.push(buildEntryMetadataKey(entry.id));
+      this.storage.entryMetadata.delete(entry.id);
+      this.storage.history.entries.delete(key);
     }
+    return {
+      prefixes: [],
+      keys: metadataKeys,
+      ranges: [range]
+    };
+  }
+  /**
+   * Flush storage with optional pending deletions so pruning
+   * happens alongside the state write.
+   */
+  async flushStorageWithDeletions(deletions) {
+    await flush(this.storage, this.driver, this.historyNotifier, deletions);
   }
   // === Sleep ===
   async sleep(name, durationMs) {
@@ -2945,7 +3165,7 @@ async function awaitWithEviction(promise, abortSignal) {
     cleanup();
   }
 }
-async function executeRollback(workflowId, workflowFn, input, driver, messageDriver, abortController, storage, historyNotifier, logger) {
+async function executeRollback(workflowId, workflowFn, input, driver, messageDriver, abortController, storage, historyNotifier, onError, logger) {
   const rollbackActions = [];
   const ctx = new WorkflowContextImpl(
     workflowId,
@@ -2958,6 +3178,7 @@ async function executeRollback(workflowId, workflowFn, input, driver, messageDri
     rollbackActions,
     false,
     historyNotifier,
+    onError,
     logger
   );
   try {
@@ -2983,6 +3204,7 @@ async function executeRollback(workflowId, workflowFn, input, driver, messageDri
     if (metadata.rollbackCompletedAt !== void 0) {
       continue;
     }
+    let rollbackEvent;
     try {
       await awaitWithEviction(
         action.rollback(rollbackContext, action.output),
@@ -2995,13 +3217,39 @@ async function executeRollback(workflowId, workflowFn, input, driver, messageDri
         throw error;
       }
       metadata.rollbackError = error instanceof Error ? error.message : String(error);
+      if (onError) {
+        rollbackEvent = {
+          rollback: {
+            workflowId,
+            stepName: action.name,
+            error: extractErrorInfo(error)
+          }
+        };
+      }
+      if (error instanceof Error) {
+        markErrorReported(error);
+      }
       throw error;
     } finally {
       metadata.dirty = true;
       await flush(storage, driver, historyNotifier);
+      if (rollbackEvent && onError) {
+        await notifyError(onError, logger, rollbackEvent);
+      }
     }
   }
 }
+async function notifyError(onError, logger, event) {
+  try {
+    await onError(event);
+  } catch (error) {
+    logger == null ? void 0 : logger.warn({
+      msg: "workflow error hook failed",
+      hookEventType: getErrorEventTag(event),
+      error: extractErrorInfo(error)
+    });
+  }
+}
 async function setSleepState(storage, driver, workflowId, deadline, messageNames, historyNotifier) {
   storage.state = "sleeping";
   await flush(storage, driver, historyNotifier);
@@ -3021,10 +3269,9 @@ async function setEvictedState(storage, driver, historyNotifier) {
   await flush(storage, driver, historyNotifier);
   return { state: storage.state };
 }
-async function setRetryState(storage, driver, workflowId, historyNotifier) {
+async function setRetryState(storage, driver, workflowId, retryAt, historyNotifier) {
   storage.state = "sleeping";
   await flush(storage, driver, historyNotifier);
-  const retryAt = Date.now() + 100;
   await driver.setAlarm(workflowId, retryAt);
   return { state: "sleeping", sleepUntil: retryAt };
 }
@@ -3065,7 +3312,7 @@ async function waitForSleep(runtime, deadline, abortSignal) {
     }
   }
 }
-async function executeLiveWorkflow(workflowId, workflowFn, input, driver, messageDriver, abortController, runtime, onHistoryUpdated, logger) {
+async function executeLiveWorkflow(workflowId, workflowFn, input, driver, messageDriver, abortController, runtime, onHistoryUpdated, onError, logger) {
   let lastResult;
   while (true) {
     const result = await executeWorkflow(
@@ -3076,6 +3323,7 @@ async function executeLiveWorkflow(workflowId, workflowFn, input, driver, messag
       messageDriver,
       abortController,
       onHistoryUpdated,
+      onError,
       logger
     );
     lastResult = result;
@@ -3157,6 +3405,7 @@ function runWorkflow(workflowId, workflowFn, input, driver, options = {}) {
     abortController,
     liveRuntime,
     options.onHistoryUpdated,
+    options.onError,
     logger
   ) : executeWorkflow(
     workflowId,
@@ -3166,6 +3415,7 @@ function runWorkflow(workflowId, workflowFn, input, driver, options = {}) {
     messageDriver,
     abortController,
     options.onHistoryUpdated,
+    options.onError,
     logger
   );
   return {
@@ -3257,7 +3507,92 @@ function runWorkflow(workflowId, workflowFn, input, driver, options = {}) {
     }
   };
 }
-async function executeWorkflow(workflowId, workflowFn, input, driver, messageDriver, abortController, onHistoryUpdated, logger) {
+async function replayWorkflowFromStep(workflowId, driver, entryId, options) {
+  const storage = await loadStorage(driver);
+  const entries = await Promise.all(
+    Array.from(storage.history.entries.entries()).map(
+      async ([key, entry]) => ({
+        key,
+        entry,
+        metadata: await loadMetadata(storage, driver, entry.id)
+      })
+    )
+  );
+  const ordered = [...entries].sort((a, b) => {
+    if (a.metadata.createdAt !== b.metadata.createdAt) {
+      return a.metadata.createdAt - b.metadata.createdAt;
+    }
+    return a.key.localeCompare(b.key);
+  });
+  let entriesToDelete = ordered;
+  if (entryId !== void 0) {
+    const target = entries.find(({ entry }) => entry.id === entryId);
+    if (!target) {
+      throw new Error(`Workflow step not found: ${entryId}`);
+    }
+    if (target.entry.kind.type !== "step") {
+      throw new Error("Workflow replay target must be a step");
+    }
+    const replayBoundary = findReplayBoundaryEntry(entries, target);
+    const targetIndex = ordered.findIndex(
+      ({ entry }) => entry.id === replayBoundary.entry.id
+    );
+    entriesToDelete = ordered.slice(targetIndex);
+  }
+  const entryIdsToDelete = new Set(
+    entriesToDelete.map(({ entry }) => entry.id)
+  );
+  if (entries.some(
+    ({ entry, metadata }) => metadata.status === "running" && !entryIdsToDelete.has(entry.id)
+  )) {
+    throw new Error(
+      "Cannot replay a workflow while a step is currently running"
+    );
+  }
+  await Promise.all(
+    entriesToDelete.flatMap(({ entry }) => [
+      driver.delete(buildHistoryKey(entry.location)),
+      driver.delete(buildEntryMetadataKey(entry.id))
+    ])
+  );
+  for (const { key, entry } of entriesToDelete) {
+    storage.history.entries.delete(key);
+    storage.entryMetadata.delete(entry.id);
+  }
+  storage.output = void 0;
+  storage.flushedOutput = void 0;
+  storage.error = void 0;
+  storage.flushedError = void 0;
+  storage.state = "sleeping";
+  storage.flushedState = "sleeping";
+  await Promise.all([
+    driver.delete(buildWorkflowOutputKey()),
+    driver.delete(buildWorkflowErrorKey()),
+    driver.set(buildWorkflowStateKey(), serializeWorkflowState("sleeping"))
+  ]);
+  if ((options == null ? void 0 : options.scheduleAlarm) ?? true) {
+    await driver.setAlarm(workflowId, Date.now());
+  }
+  return createHistorySnapshot(storage);
+}
+function findReplayBoundaryEntry(entries, target) {
+  let boundary = target;
+  let boundaryDepth = -1;
+  for (const candidate of entries) {
+    if (candidate.entry.kind.type !== "loop") {
+      continue;
+    }
+    if (candidate.entry.location.length >= target.entry.location.length || !isLocationPrefix(candidate.entry.location, target.entry.location)) {
+      continue;
+    }
+    if (candidate.entry.location.length > boundaryDepth) {
+      boundary = candidate;
+      boundaryDepth = candidate.entry.location.length;
+    }
+  }
+  return boundary;
+}
+async function executeWorkflow(workflowId, workflowFn, input, driver, messageDriver, abortController, onHistoryUpdated, onError, logger) {
   var _a;
   const storage = await loadStorage(driver);
   const historyNotifier = onHistoryUpdated ? () => onHistoryUpdated(createHistorySnapshot(storage)) : void 0;
@@ -3299,6 +3634,7 @@ async function executeWorkflow(workflowId, workflowFn, input, driver, messageDri
         abortController,
         storage,
         historyNotifier,
+        onError,
         logger
       );
     } catch (error) {
@@ -3326,6 +3662,7 @@ async function executeWorkflow(workflowId, workflowFn, input, driver, messageDri
     void 0,
     false,
     historyNotifier,
+    onError,
     logger
   );
   storage.state = "running";
@@ -3363,11 +3700,20 @@ async function executeWorkflow(workflowId, workflowFn, input, driver, messageDri
         storage,
         driver,
         workflowId,
+        error.retryAt,
         historyNotifier
       );
     }
     if (error instanceof RollbackCheckpointError) {
       await setFailedState(storage, driver, error, historyNotifier);
+      if (onError && !isErrorReported(error)) {
+        await notifyError(onError, logger, {
+          workflow: {
+            workflowId,
+            error: extractErrorInfo(error)
+          }
+        });
+      }
       throw error;
     }
     storage.error = extractErrorInfo(error);
@@ -3383,6 +3729,7 @@ async function executeWorkflow(workflowId, workflowFn, input, driver, messageDri
         abortController,
         storage,
         historyNotifier,
+        onError,
         logger
       );
     } catch (rollbackError) {
@@ -3393,37 +3740,23 @@ async function executeWorkflow(workflowId, workflowFn, input, driver, messageDri
     }
     storage.state = "failed";
     await flush(storage, driver, historyNotifier);
-    throw error;
-  }
-}
-function extractErrorInfo(error) {
-  if (error instanceof Error) {
-    const result = {
-      name: error.name,
-      message: error.message,
-      stack: error.stack
-    };
-    const metadata = {};
-    for (const key of Object.keys(error)) {
-      if (key !== "name" && key !== "message" && key !== "stack") {
-        const value = error[key];
-        if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null) {
-          metadata[key] = value;
+    if (onError && !isErrorReported(error)) {
+      await notifyError(onError, logger, {
+        workflow: {
+          workflowId,
+          error: extractErrorInfo(error)
         }
+      });
+      if (error instanceof CriticalError || error instanceof RollbackError || error instanceof StepExhaustedError) {
+        markErrorReported(error);
       }
     }
-    if (Object.keys(metadata).length > 0) {
-      result.metadata = metadata;
-    }
-    return result;
+    throw error;
   }
-  return {
-    name: "Error",
-    message: String(error)
-  };
 }
 
 export {
+  extractErrorInfo,
   CriticalError,
   RollbackError,
   RollbackCheckpointError,
@@ -3437,6 +3770,9 @@ export {
   RaceError,
   CancelledError,
   EntryInProgressError,
+  keyStartsWith,
+  compareKeys,
+  keyToHex,
   isLoopIterationMarker,
   registerName,
   resolveName,
@@ -3447,9 +3783,6 @@ export {
   parentLocation,
   isLocationPrefix,
   locationsEqual,
-  keyStartsWith,
-  compareKeys,
-  keyToHex,
   createStorage,
   createHistorySnapshot,
   generateId,
@@ -3465,12 +3798,11 @@ export {
   DEFAULT_MAX_RETRIES,
   DEFAULT_RETRY_BACKOFF_BASE,
   DEFAULT_RETRY_BACKOFF_MAX,
-  DEFAULT_LOOP_COMMIT_INTERVAL,
-  DEFAULT_LOOP_HISTORY_EVERY,
-  DEFAULT_LOOP_HISTORY_KEEP,
+  DEFAULT_LOOP_HISTORY_PRUNE_INTERVAL,
   DEFAULT_STEP_TIMEOUT,
   WorkflowContextImpl,
   Loop,
-  runWorkflow
+  runWorkflow,
+  replayWorkflowFromStep
 };
-//# sourceMappingURL=chunk-JTLDEP6X.js.map
+//# sourceMappingURL=chunk-4ME2JBMC.js.map