@rivetkit/workflow-engine 0.0.0-pr.4600.8dee603

package/dist/tsup/chunk-4SWXLWKL.cjs

@@ -0,0 +1,4180 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } var _class;// 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) {
+    super(message);
+    this.name = "CriticalError";
+  }
+};
+var RollbackError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RollbackError";
+  }
+};
+var RollbackCheckpointError = class extends Error {
+  constructor() {
+    super("Rollback requires a checkpoint before any rollback step");
+    this.name = "RollbackCheckpointError";
+  }
+};
+var SleepError = class extends Error {
+  constructor(deadline, messageNames) {
+    super(
+      messageNames && messageNames.length > 0 ? `Sleeping until ${deadline} or messages: ${messageNames.join(", ")}` : `Sleeping until ${deadline}`
+    );
+    this.deadline = deadline;
+    this.messageNames = messageNames;
+    this.name = "SleepError";
+  }
+};
+var MessageWaitError = class extends Error {
+  constructor(messageNames) {
+    super(`Waiting for messages: ${messageNames.join(", ")}`);
+    this.messageNames = messageNames;
+    this.name = "MessageWaitError";
+  }
+};
+var EvictedError = class extends Error {
+  constructor() {
+    super("Workflow evicted");
+    this.name = "EvictedError";
+  }
+};
+var RollbackStopError = class extends Error {
+  constructor() {
+    super("Rollback traversal halted");
+    this.name = "RollbackStopError";
+  }
+};
+var HistoryDivergedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "HistoryDivergedError";
+  }
+};
+var StepExhaustedError = class extends Error {
+  constructor(stepName, lastError) {
+    super(
+      `Step "${stepName}" exhausted retries: ${_nullishCoalesce(lastError, () => ( "unknown error"))}`
+    );
+    this.stepName = stepName;
+    this.lastError = lastError;
+    this.name = "StepExhaustedError";
+  }
+};
+var StepFailedError = class extends Error {
+  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;
+  }
+};
+var JoinError = class extends Error {
+  constructor(errors) {
+    super(`Join failed: ${Object.keys(errors).join(", ")}`);
+    this.errors = errors;
+    this.name = "JoinError";
+  }
+};
+var RaceError = class extends Error {
+  constructor(message, errors) {
+    super(message);
+    this.errors = errors;
+    this.name = "RaceError";
+  }
+};
+var CancelledError = class extends Error {
+  constructor() {
+    super("Branch cancelled");
+    this.name = "CancelledError";
+  }
+};
+var EntryInProgressError = class extends Error {
+  constructor() {
+    super(
+      "Cannot start a new workflow entry while another is in progress. Did you forget to await the previous step/loop/sleep?"
+    );
+    this.name = "EntryInProgressError";
+  }
+};
+
+// src/keys.ts
+var _fdbtuple = require('fdb-tuple'); var tuple = _interopRequireWildcard(_fdbtuple);
+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;
+}
+function registerName(storage, name) {
+  const existing = storage.nameRegistry.indexOf(name);
+  if (existing !== -1) {
+    return existing;
+  }
+  storage.nameRegistry.push(name);
+  return storage.nameRegistry.length - 1;
+}
+function resolveName(storage, index) {
+  const name = storage.nameRegistry[index];
+  if (name === void 0) {
+    throw new Error(`Name index ${index} not found in registry`);
+  }
+  return name;
+}
+function locationToKey(storage, location) {
+  return location.map((segment) => {
+    if (typeof segment === "number") {
+      return resolveName(storage, segment);
+    }
+    return `~${segment.iteration}`;
+  }).join("/");
+}
+function appendName(storage, location, name) {
+  const nameIndex = registerName(storage, name);
+  return [...location, nameIndex];
+}
+function appendLoopIteration(storage, location, loopName, iteration) {
+  const loopIndex = registerName(storage, loopName);
+  return [...location, { loop: loopIndex, iteration }];
+}
+function emptyLocation() {
+  return [];
+}
+function parentLocation(location) {
+  return location.slice(0, -1);
+}
+function isLocationPrefix(prefix, location) {
+  if (prefix.length > location.length) {
+    return false;
+  }
+  for (let i = 0; i < prefix.length; i++) {
+    const prefixSegment = prefix[i];
+    const locationSegment = location[i];
+    if (typeof prefixSegment === "number" && typeof locationSegment === "number") {
+      if (prefixSegment !== locationSegment) {
+        return false;
+      }
+    } else if (isLoopIterationMarker(prefixSegment) && isLoopIterationMarker(locationSegment)) {
+      if (prefixSegment.loop !== locationSegment.loop || prefixSegment.iteration !== locationSegment.iteration) {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  }
+  return true;
+}
+function locationsEqual(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  return isLocationPrefix(a, b);
+}
+
+// schemas/serde.ts
+var _cborx = require('cbor-x'); var cbor = _interopRequireWildcard(_cborx);
+
+// dist/schemas/v1.ts
+var _barets = require('@rivetkit/bare-ts'); var bare = _interopRequireWildcard(_barets);
+var config = /* @__PURE__ */ bare.Config({});
+function readCbor(bc) {
+  return bare.readData(bc);
+}
+function writeCbor(bc, x) {
+  bare.writeData(bc, x);
+}
+function readNameIndex(bc) {
+  return bare.readU32(bc);
+}
+function writeNameIndex(bc, x) {
+  bare.writeU32(bc, x);
+}
+function readLoopIterationMarker(bc) {
+  return {
+    loop: readNameIndex(bc),
+    iteration: bare.readU32(bc)
+  };
+}
+function writeLoopIterationMarker(bc, x) {
+  writeNameIndex(bc, x.loop);
+  bare.writeU32(bc, x.iteration);
+}
+function readPathSegment(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "NameIndex", val: readNameIndex(bc) };
+    case 1:
+      return { tag: "LoopIterationMarker", val: readLoopIterationMarker(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writePathSegment(bc, x) {
+  switch (x.tag) {
+    case "NameIndex": {
+      bare.writeU8(bc, 0);
+      writeNameIndex(bc, x.val);
+      break;
+    }
+    case "LoopIterationMarker": {
+      bare.writeU8(bc, 1);
+      writeLoopIterationMarker(bc, x.val);
+      break;
+    }
+  }
+}
+function readLocation(bc) {
+  const len = bare.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readPathSegment(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readPathSegment(bc);
+  }
+  return result;
+}
+function writeLocation(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writePathSegment(bc, x[i]);
+  }
+}
+function readEntryStatus(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return "PENDING" /* PENDING */;
+    case 1:
+      return "RUNNING" /* RUNNING */;
+    case 2:
+      return "COMPLETED" /* COMPLETED */;
+    case 3:
+      return "FAILED" /* FAILED */;
+    case 4:
+      return "EXHAUSTED" /* EXHAUSTED */;
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeEntryStatus(bc, x) {
+  switch (x) {
+    case "PENDING" /* PENDING */: {
+      bare.writeU8(bc, 0);
+      break;
+    }
+    case "RUNNING" /* RUNNING */: {
+      bare.writeU8(bc, 1);
+      break;
+    }
+    case "COMPLETED" /* COMPLETED */: {
+      bare.writeU8(bc, 2);
+      break;
+    }
+    case "FAILED" /* FAILED */: {
+      bare.writeU8(bc, 3);
+      break;
+    }
+    case "EXHAUSTED" /* EXHAUSTED */: {
+      bare.writeU8(bc, 4);
+      break;
+    }
+  }
+}
+function readSleepState(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return "PENDING" /* PENDING */;
+    case 1:
+      return "COMPLETED" /* COMPLETED */;
+    case 2:
+      return "INTERRUPTED" /* INTERRUPTED */;
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeSleepState(bc, x) {
+  switch (x) {
+    case "PENDING" /* PENDING */: {
+      bare.writeU8(bc, 0);
+      break;
+    }
+    case "COMPLETED" /* COMPLETED */: {
+      bare.writeU8(bc, 1);
+      break;
+    }
+    case "INTERRUPTED" /* INTERRUPTED */: {
+      bare.writeU8(bc, 2);
+      break;
+    }
+  }
+}
+function readBranchStatusType(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return "PENDING" /* PENDING */;
+    case 1:
+      return "RUNNING" /* RUNNING */;
+    case 2:
+      return "COMPLETED" /* COMPLETED */;
+    case 3:
+      return "FAILED" /* FAILED */;
+    case 4:
+      return "CANCELLED" /* CANCELLED */;
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeBranchStatusType(bc, x) {
+  switch (x) {
+    case "PENDING" /* PENDING */: {
+      bare.writeU8(bc, 0);
+      break;
+    }
+    case "RUNNING" /* RUNNING */: {
+      bare.writeU8(bc, 1);
+      break;
+    }
+    case "COMPLETED" /* COMPLETED */: {
+      bare.writeU8(bc, 2);
+      break;
+    }
+    case "FAILED" /* FAILED */: {
+      bare.writeU8(bc, 3);
+      break;
+    }
+    case "CANCELLED" /* CANCELLED */: {
+      bare.writeU8(bc, 4);
+      break;
+    }
+  }
+}
+function read0(bc) {
+  return bare.readBool(bc) ? readCbor(bc) : null;
+}
+function write0(bc, x) {
+  bare.writeBool(bc, x !== null);
+  if (x !== null) {
+    writeCbor(bc, x);
+  }
+}
+function read1(bc) {
+  return bare.readBool(bc) ? bare.readString(bc) : null;
+}
+function write1(bc, x) {
+  bare.writeBool(bc, x !== null);
+  if (x !== null) {
+    bare.writeString(bc, x);
+  }
+}
+function readStepEntry(bc) {
+  return {
+    output: read0(bc),
+    error: read1(bc)
+  };
+}
+function writeStepEntry(bc, x) {
+  write0(bc, x.output);
+  write1(bc, x.error);
+}
+function readLoopEntry(bc) {
+  return {
+    state: readCbor(bc),
+    iteration: bare.readU32(bc),
+    output: read0(bc)
+  };
+}
+function writeLoopEntry(bc, x) {
+  writeCbor(bc, x.state);
+  bare.writeU32(bc, x.iteration);
+  write0(bc, x.output);
+}
+function readSleepEntry(bc) {
+  return {
+    deadline: bare.readU64(bc),
+    state: readSleepState(bc)
+  };
+}
+function writeSleepEntry(bc, x) {
+  bare.writeU64(bc, x.deadline);
+  writeSleepState(bc, x.state);
+}
+function readMessageEntry(bc) {
+  return {
+    name: bare.readString(bc),
+    messageData: readCbor(bc)
+  };
+}
+function writeMessageEntry(bc, x) {
+  bare.writeString(bc, x.name);
+  writeCbor(bc, x.messageData);
+}
+function readRollbackCheckpointEntry(bc) {
+  return {
+    name: bare.readString(bc)
+  };
+}
+function writeRollbackCheckpointEntry(bc, x) {
+  bare.writeString(bc, x.name);
+}
+function readBranchStatus(bc) {
+  return {
+    status: readBranchStatusType(bc),
+    output: read0(bc),
+    error: read1(bc)
+  };
+}
+function writeBranchStatus(bc, x) {
+  writeBranchStatusType(bc, x.status);
+  write0(bc, x.output);
+  write1(bc, x.error);
+}
+function read2(bc) {
+  const len = bare.readUintSafe(bc);
+  const result = /* @__PURE__ */ new Map();
+  for (let i = 0; i < len; i++) {
+    const offset = bc.offset;
+    const key = bare.readString(bc);
+    if (result.has(key)) {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "duplicated key");
+    }
+    result.set(key, readBranchStatus(bc));
+  }
+  return result;
+}
+function write2(bc, x) {
+  bare.writeUintSafe(bc, x.size);
+  for (const kv of x) {
+    bare.writeString(bc, kv[0]);
+    writeBranchStatus(bc, kv[1]);
+  }
+}
+function readJoinEntry(bc) {
+  return {
+    branches: read2(bc)
+  };
+}
+function writeJoinEntry(bc, x) {
+  write2(bc, x.branches);
+}
+function readRaceEntry(bc) {
+  return {
+    winner: read1(bc),
+    branches: read2(bc)
+  };
+}
+function writeRaceEntry(bc, x) {
+  write1(bc, x.winner);
+  write2(bc, x.branches);
+}
+function readRemovedEntry(bc) {
+  return {
+    originalType: bare.readString(bc),
+    originalName: read1(bc)
+  };
+}
+function writeRemovedEntry(bc, x) {
+  bare.writeString(bc, x.originalType);
+  write1(bc, x.originalName);
+}
+function readEntryKind(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "StepEntry", val: readStepEntry(bc) };
+    case 1:
+      return { tag: "LoopEntry", val: readLoopEntry(bc) };
+    case 2:
+      return { tag: "SleepEntry", val: readSleepEntry(bc) };
+    case 3:
+      return { tag: "MessageEntry", val: readMessageEntry(bc) };
+    case 4:
+      return { tag: "RollbackCheckpointEntry", val: readRollbackCheckpointEntry(bc) };
+    case 5:
+      return { tag: "JoinEntry", val: readJoinEntry(bc) };
+    case 6:
+      return { tag: "RaceEntry", val: readRaceEntry(bc) };
+    case 7:
+      return { tag: "RemovedEntry", val: readRemovedEntry(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeEntryKind(bc, x) {
+  switch (x.tag) {
+    case "StepEntry": {
+      bare.writeU8(bc, 0);
+      writeStepEntry(bc, x.val);
+      break;
+    }
+    case "LoopEntry": {
+      bare.writeU8(bc, 1);
+      writeLoopEntry(bc, x.val);
+      break;
+    }
+    case "SleepEntry": {
+      bare.writeU8(bc, 2);
+      writeSleepEntry(bc, x.val);
+      break;
+    }
+    case "MessageEntry": {
+      bare.writeU8(bc, 3);
+      writeMessageEntry(bc, x.val);
+      break;
+    }
+    case "RollbackCheckpointEntry": {
+      bare.writeU8(bc, 4);
+      writeRollbackCheckpointEntry(bc, x.val);
+      break;
+    }
+    case "JoinEntry": {
+      bare.writeU8(bc, 5);
+      writeJoinEntry(bc, x.val);
+      break;
+    }
+    case "RaceEntry": {
+      bare.writeU8(bc, 6);
+      writeRaceEntry(bc, x.val);
+      break;
+    }
+    case "RemovedEntry": {
+      bare.writeU8(bc, 7);
+      writeRemovedEntry(bc, x.val);
+      break;
+    }
+  }
+}
+function readEntry(bc) {
+  return {
+    id: bare.readString(bc),
+    location: readLocation(bc),
+    kind: readEntryKind(bc)
+  };
+}
+function writeEntry(bc, x) {
+  bare.writeString(bc, x.id);
+  writeLocation(bc, x.location);
+  writeEntryKind(bc, x.kind);
+}
+function encodeEntry(x) {
+  const bc = new bare.ByteCursor(
+    new Uint8Array(config.initialBufferLength),
+    config
+  );
+  writeEntry(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeEntry(bytes) {
+  const bc = new bare.ByteCursor(bytes, config);
+  const result = readEntry(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function read3(bc) {
+  return bare.readBool(bc) ? bare.readU64(bc) : null;
+}
+function write3(bc, x) {
+  bare.writeBool(bc, x !== null);
+  if (x !== null) {
+    bare.writeU64(bc, x);
+  }
+}
+function readEntryMetadata(bc) {
+  return {
+    status: readEntryStatus(bc),
+    error: read1(bc),
+    attempts: bare.readU32(bc),
+    lastAttemptAt: bare.readU64(bc),
+    createdAt: bare.readU64(bc),
+    completedAt: read3(bc),
+    rollbackCompletedAt: read3(bc),
+    rollbackError: read1(bc)
+  };
+}
+function writeEntryMetadata(bc, x) {
+  writeEntryStatus(bc, x.status);
+  write1(bc, x.error);
+  bare.writeU32(bc, x.attempts);
+  bare.writeU64(bc, x.lastAttemptAt);
+  bare.writeU64(bc, x.createdAt);
+  write3(bc, x.completedAt);
+  write3(bc, x.rollbackCompletedAt);
+  write1(bc, x.rollbackError);
+}
+function encodeEntryMetadata(x) {
+  const bc = new bare.ByteCursor(
+    new Uint8Array(config.initialBufferLength),
+    config
+  );
+  writeEntryMetadata(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeEntryMetadata(bytes) {
+  const bc = new bare.ByteCursor(bytes, config);
+  const result = readEntryMetadata(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readWorkflowState(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return "PENDING" /* PENDING */;
+    case 1:
+      return "RUNNING" /* RUNNING */;
+    case 2:
+      return "SLEEPING" /* SLEEPING */;
+    case 3:
+      return "FAILED" /* FAILED */;
+    case 4:
+      return "COMPLETED" /* COMPLETED */;
+    case 5:
+      return "ROLLING_BACK" /* ROLLING_BACK */;
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeWorkflowState(bc, x) {
+  switch (x) {
+    case "PENDING" /* PENDING */: {
+      bare.writeU8(bc, 0);
+      break;
+    }
+    case "RUNNING" /* RUNNING */: {
+      bare.writeU8(bc, 1);
+      break;
+    }
+    case "SLEEPING" /* SLEEPING */: {
+      bare.writeU8(bc, 2);
+      break;
+    }
+    case "FAILED" /* FAILED */: {
+      bare.writeU8(bc, 3);
+      break;
+    }
+    case "COMPLETED" /* COMPLETED */: {
+      bare.writeU8(bc, 4);
+      break;
+    }
+    case "ROLLING_BACK" /* ROLLING_BACK */: {
+      bare.writeU8(bc, 5);
+      break;
+    }
+  }
+}
+function readWorkflowMetadata(bc) {
+  return {
+    state: readWorkflowState(bc),
+    output: read0(bc),
+    error: read1(bc),
+    version: read1(bc)
+  };
+}
+function writeWorkflowMetadata(bc, x) {
+  writeWorkflowState(bc, x.state);
+  write0(bc, x.output);
+  write1(bc, x.error);
+  write1(bc, x.version);
+}
+function encodeWorkflowMetadata(x) {
+  const bc = new bare.ByteCursor(
+    new Uint8Array(config.initialBufferLength),
+    config
+  );
+  writeWorkflowMetadata(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeWorkflowMetadata(bytes) {
+  const bc = new bare.ByteCursor(bytes, config);
+  const result = readWorkflowMetadata(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+
+// schemas/versioned.ts
+var _vbare = require('vbare');
+var CURRENT_VERSION = 1;
+var ENTRY_VERSIONED = _vbare.createVersionedDataHandler.call(void 0, {
+  deserializeVersion: (bytes, version) => {
+    switch (version) {
+      case 1:
+        return decodeEntry(bytes);
+      default:
+        throw new Error(`Unknown Entry version ${version}`);
+    }
+  },
+  serializeVersion: (data, version) => {
+    switch (version) {
+      case 1:
+        return encodeEntry(data);
+      default:
+        throw new Error(`Unknown Entry version ${version}`);
+    }
+  },
+  deserializeConverters: () => [],
+  serializeConverters: () => []
+});
+var ENTRY_METADATA_VERSIONED = _vbare.createVersionedDataHandler.call(void 0, {
+  deserializeVersion: (bytes, version) => {
+    switch (version) {
+      case 1:
+        return decodeEntryMetadata(bytes);
+      default:
+        throw new Error(`Unknown EntryMetadata version ${version}`);
+    }
+  },
+  serializeVersion: (data, version) => {
+    switch (version) {
+      case 1:
+        return encodeEntryMetadata(data);
+      default:
+        throw new Error(`Unknown EntryMetadata version ${version}`);
+    }
+  },
+  deserializeConverters: () => [],
+  serializeConverters: () => []
+});
+var WORKFLOW_METADATA_VERSIONED = _vbare.createVersionedDataHandler.call(void 0, {
+  deserializeVersion: (bytes, version) => {
+    switch (version) {
+      case 1:
+        return decodeWorkflowMetadata(bytes);
+      default:
+        throw new Error(
+          `Unknown WorkflowMetadata version ${version}`
+        );
+    }
+  },
+  serializeVersion: (data, version) => {
+    switch (version) {
+      case 1:
+        return encodeWorkflowMetadata(
+          data
+        );
+      default:
+        throw new Error(
+          `Unknown WorkflowMetadata version ${version}`
+        );
+    }
+  },
+  deserializeConverters: () => [],
+  serializeConverters: () => []
+});
+
+// schemas/serde.ts
+function bufferToArrayBuffer(buf) {
+  const arrayBuffer = new ArrayBuffer(buf.byteLength);
+  new Uint8Array(arrayBuffer).set(buf);
+  return arrayBuffer;
+}
+function encodeCbor(value) {
+  return bufferToArrayBuffer(cbor.encode(value));
+}
+function decodeCbor(data) {
+  return cbor.decode(new Uint8Array(data));
+}
+function assertObject(value, context) {
+  if (typeof value !== "object" || value === null) {
+    throw new Error(`${context}: expected object, got ${typeof value}`);
+  }
+}
+function assertString(value, context) {
+  if (typeof value !== "string") {
+    throw new Error(`${context}: expected string, got ${typeof value}`);
+  }
+}
+function entryStatusToBare(status) {
+  switch (status) {
+    case "pending":
+      return "PENDING" /* PENDING */;
+    case "running":
+      return "RUNNING" /* RUNNING */;
+    case "completed":
+      return "COMPLETED" /* COMPLETED */;
+    case "failed":
+      return "FAILED" /* FAILED */;
+    case "exhausted":
+      return "EXHAUSTED" /* EXHAUSTED */;
+  }
+}
+function entryStatusFromBare(status) {
+  switch (status) {
+    case "PENDING" /* PENDING */:
+      return "pending";
+    case "RUNNING" /* RUNNING */:
+      return "running";
+    case "COMPLETED" /* COMPLETED */:
+      return "completed";
+    case "FAILED" /* FAILED */:
+      return "failed";
+    case "EXHAUSTED" /* EXHAUSTED */:
+      return "exhausted";
+  }
+}
+function sleepStateToBare(state) {
+  switch (state) {
+    case "pending":
+      return "PENDING" /* PENDING */;
+    case "completed":
+      return "COMPLETED" /* COMPLETED */;
+    case "interrupted":
+      return "INTERRUPTED" /* INTERRUPTED */;
+  }
+}
+function sleepStateFromBare(state) {
+  switch (state) {
+    case "PENDING" /* PENDING */:
+      return "pending";
+    case "COMPLETED" /* COMPLETED */:
+      return "completed";
+    case "INTERRUPTED" /* INTERRUPTED */:
+      return "interrupted";
+  }
+}
+function branchStatusTypeToBare(status) {
+  switch (status) {
+    case "pending":
+      return "PENDING" /* PENDING */;
+    case "running":
+      return "RUNNING" /* RUNNING */;
+    case "completed":
+      return "COMPLETED" /* COMPLETED */;
+    case "failed":
+      return "FAILED" /* FAILED */;
+    case "cancelled":
+      return "CANCELLED" /* CANCELLED */;
+  }
+}
+function branchStatusTypeFromBare(status) {
+  switch (status) {
+    case "PENDING" /* PENDING */:
+      return "pending";
+    case "RUNNING" /* RUNNING */:
+      return "running";
+    case "COMPLETED" /* COMPLETED */:
+      return "completed";
+    case "FAILED" /* FAILED */:
+      return "failed";
+    case "CANCELLED" /* CANCELLED */:
+      return "cancelled";
+  }
+}
+function locationToBare(location) {
+  return location.map((segment) => {
+    if (typeof segment === "number") {
+      return { tag: "NameIndex", val: segment };
+    }
+    return {
+      tag: "LoopIterationMarker",
+      val: {
+        loop: segment.loop,
+        iteration: segment.iteration
+      }
+    };
+  });
+}
+function locationFromBare(location) {
+  return location.map((segment) => {
+    if (segment.tag === "NameIndex") {
+      return segment.val;
+    }
+    return {
+      loop: segment.val.loop,
+      iteration: segment.val.iteration
+    };
+  });
+}
+function branchStatusToBare(status) {
+  return {
+    status: branchStatusTypeToBare(status.status),
+    output: status.output !== void 0 ? encodeCbor(status.output) : null,
+    error: _nullishCoalesce(status.error, () => ( null))
+  };
+}
+function branchStatusFromBare(status) {
+  return {
+    status: branchStatusTypeFromBare(status.status),
+    output: status.output !== null ? decodeCbor(status.output) : void 0,
+    error: _nullishCoalesce(status.error, () => ( void 0))
+  };
+}
+function entryKindToBare(kind) {
+  switch (kind.type) {
+    case "step":
+      return {
+        tag: "StepEntry",
+        val: {
+          output: kind.data.output !== void 0 ? encodeCbor(kind.data.output) : null,
+          error: _nullishCoalesce(kind.data.error, () => ( null))
+        }
+      };
+    case "loop":
+      return {
+        tag: "LoopEntry",
+        val: {
+          state: encodeCbor(kind.data.state),
+          iteration: kind.data.iteration,
+          output: kind.data.output !== void 0 ? encodeCbor(kind.data.output) : null
+        }
+      };
+    case "sleep":
+      return {
+        tag: "SleepEntry",
+        val: {
+          deadline: BigInt(kind.data.deadline),
+          state: sleepStateToBare(kind.data.state)
+        }
+      };
+    case "message":
+      return {
+        tag: "MessageEntry",
+        val: {
+          name: kind.data.name,
+          messageData: encodeCbor(kind.data.data)
+        }
+      };
+    case "rollback_checkpoint":
+      return {
+        tag: "RollbackCheckpointEntry",
+        val: {
+          name: kind.data.name
+        }
+      };
+    case "join":
+      return {
+        tag: "JoinEntry",
+        val: {
+          branches: new Map(
+            Object.entries(kind.data.branches).map(
+              ([name, status]) => [
+                name,
+                branchStatusToBare(status)
+              ]
+            )
+          )
+        }
+      };
+    case "race":
+      return {
+        tag: "RaceEntry",
+        val: {
+          winner: kind.data.winner,
+          branches: new Map(
+            Object.entries(kind.data.branches).map(
+              ([name, status]) => [
+                name,
+                branchStatusToBare(status)
+              ]
+            )
+          )
+        }
+      };
+    case "removed":
+      return {
+        tag: "RemovedEntry",
+        val: {
+          originalType: kind.data.originalType,
+          originalName: _nullishCoalesce(kind.data.originalName, () => ( null))
+        }
+      };
+  }
+}
+function entryKindFromBare(kind) {
+  switch (kind.tag) {
+    case "StepEntry":
+      return {
+        type: "step",
+        data: {
+          output: kind.val.output !== null ? decodeCbor(kind.val.output) : void 0,
+          error: _nullishCoalesce(kind.val.error, () => ( void 0))
+        }
+      };
+    case "LoopEntry":
+      return {
+        type: "loop",
+        data: {
+          state: decodeCbor(kind.val.state),
+          iteration: kind.val.iteration,
+          output: kind.val.output !== null ? decodeCbor(kind.val.output) : void 0
+        }
+      };
+    case "SleepEntry":
+      return {
+        type: "sleep",
+        data: {
+          deadline: Number(kind.val.deadline),
+          state: sleepStateFromBare(kind.val.state)
+        }
+      };
+    case "MessageEntry":
+      return {
+        type: "message",
+        data: {
+          name: kind.val.name,
+          data: decodeCbor(kind.val.messageData)
+        }
+      };
+    case "RollbackCheckpointEntry":
+      return {
+        type: "rollback_checkpoint",
+        data: {
+          name: kind.val.name
+        }
+      };
+    case "JoinEntry":
+      return {
+        type: "join",
+        data: {
+          branches: Object.fromEntries(
+            Array.from(kind.val.branches.entries()).map(
+              ([name, status]) => [
+                name,
+                branchStatusFromBare(status)
+              ]
+            )
+          )
+        }
+      };
+    case "RaceEntry":
+      return {
+        type: "race",
+        data: {
+          winner: kind.val.winner,
+          branches: Object.fromEntries(
+            Array.from(kind.val.branches.entries()).map(
+              ([name, status]) => [
+                name,
+                branchStatusFromBare(status)
+              ]
+            )
+          )
+        }
+      };
+    case "RemovedEntry":
+      return {
+        type: "removed",
+        data: {
+          originalType: kind.val.originalType,
+          originalName: _nullishCoalesce(kind.val.originalName, () => ( void 0))
+        }
+      };
+    default:
+      throw new Error(
+        `Unknown entry kind: ${kind.tag}`
+      );
+  }
+}
+function entryToBare(entry) {
+  return {
+    id: entry.id,
+    location: locationToBare(entry.location),
+    kind: entryKindToBare(entry.kind)
+  };
+}
+function entryFromBare(bareEntry) {
+  return {
+    id: bareEntry.id,
+    location: locationFromBare(bareEntry.location),
+    kind: entryKindFromBare(bareEntry.kind),
+    dirty: false
+  };
+}
+function serializeEntry(entry) {
+  const bareEntry = entryToBare(entry);
+  return ENTRY_VERSIONED.serializeWithEmbeddedVersion(
+    bareEntry,
+    CURRENT_VERSION
+  );
+}
+function deserializeEntry(bytes) {
+  const bareEntry = ENTRY_VERSIONED.deserializeWithEmbeddedVersion(bytes);
+  return entryFromBare(bareEntry);
+}
+function entryMetadataToBare(metadata) {
+  return {
+    status: entryStatusToBare(metadata.status),
+    error: _nullishCoalesce(metadata.error, () => ( null)),
+    attempts: metadata.attempts,
+    lastAttemptAt: BigInt(metadata.lastAttemptAt),
+    createdAt: BigInt(metadata.createdAt),
+    completedAt: metadata.completedAt !== void 0 ? BigInt(metadata.completedAt) : null,
+    rollbackCompletedAt: metadata.rollbackCompletedAt !== void 0 ? BigInt(metadata.rollbackCompletedAt) : null,
+    rollbackError: _nullishCoalesce(metadata.rollbackError, () => ( null))
+  };
+}
+function entryMetadataFromBare(bareMetadata) {
+  return {
+    status: entryStatusFromBare(bareMetadata.status),
+    error: _nullishCoalesce(bareMetadata.error, () => ( void 0)),
+    attempts: bareMetadata.attempts,
+    lastAttemptAt: Number(bareMetadata.lastAttemptAt),
+    createdAt: Number(bareMetadata.createdAt),
+    completedAt: bareMetadata.completedAt !== null ? Number(bareMetadata.completedAt) : void 0,
+    rollbackCompletedAt: bareMetadata.rollbackCompletedAt !== null ? Number(bareMetadata.rollbackCompletedAt) : void 0,
+    rollbackError: _nullishCoalesce(bareMetadata.rollbackError, () => ( void 0)),
+    dirty: false
+  };
+}
+function serializeEntryMetadata(metadata) {
+  const bareMetadata = entryMetadataToBare(metadata);
+  return ENTRY_METADATA_VERSIONED.serializeWithEmbeddedVersion(
+    bareMetadata,
+    CURRENT_VERSION
+  );
+}
+function deserializeEntryMetadata(bytes) {
+  const bareMetadata = ENTRY_METADATA_VERSIONED.deserializeWithEmbeddedVersion(bytes);
+  return entryMetadataFromBare(bareMetadata);
+}
+function serializeWorkflowState(state) {
+  const encoder = new TextEncoder();
+  return encoder.encode(state);
+}
+function deserializeWorkflowState(bytes) {
+  const decoder = new TextDecoder();
+  const state = decoder.decode(bytes);
+  const validStates = [
+    "pending",
+    "running",
+    "sleeping",
+    "failed",
+    "completed",
+    "cancelled",
+    "rolling_back"
+  ];
+  if (!validStates.includes(state)) {
+    throw new Error(`Invalid workflow state: ${state}`);
+  }
+  return state;
+}
+function serializeWorkflowOutput(output) {
+  return cbor.encode(output);
+}
+function deserializeWorkflowOutput(bytes) {
+  try {
+    return cbor.decode(bytes);
+  } catch (error) {
+    throw new Error(
+      `Failed to deserialize workflow output: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function serializeWorkflowError(error) {
+  return cbor.encode(error);
+}
+function deserializeWorkflowError(bytes) {
+  const decoded = cbor.decode(bytes);
+  assertObject(decoded, "WorkflowError");
+  const obj = decoded;
+  assertString(obj.name, "WorkflowError.name");
+  assertString(obj.message, "WorkflowError.message");
+  return {
+    name: obj.name,
+    message: obj.message,
+    stack: typeof obj.stack === "string" ? obj.stack : void 0,
+    metadata: typeof obj.metadata === "object" && obj.metadata !== null ? obj.metadata : void 0
+  };
+}
+function serializeWorkflowInput(input) {
+  return cbor.encode(input);
+}
+function deserializeWorkflowInput(bytes) {
+  try {
+    return cbor.decode(bytes);
+  } catch (error) {
+    throw new Error(
+      `Failed to deserialize workflow input: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function serializeName(name) {
+  const encoder = new TextEncoder();
+  return encoder.encode(name);
+}
+function deserializeName(bytes) {
+  const decoder = new TextDecoder();
+  return decoder.decode(bytes);
+}
+
+// src/storage.ts
+function createStorage() {
+  return {
+    nameRegistry: [],
+    flushedNameCount: 0,
+    history: { entries: /* @__PURE__ */ new Map() },
+    entryMetadata: /* @__PURE__ */ new Map(),
+    output: void 0,
+    state: "pending",
+    flushedState: void 0,
+    error: void 0,
+    flushedError: void 0,
+    flushedOutput: void 0
+  };
+}
+function createHistorySnapshot(storage) {
+  const entryMetadata = /* @__PURE__ */ new Map();
+  for (const [id, metadata] of storage.entryMetadata) {
+    const { dirty, ...rest } = metadata;
+    entryMetadata.set(id, rest);
+  }
+  const entries = [];
+  const entryKeys = Array.from(storage.history.entries.keys()).sort();
+  for (const key of entryKeys) {
+    const entry = storage.history.entries.get(key);
+    if (!entry) continue;
+    const { dirty, ...rest } = entry;
+    entries.push(rest);
+  }
+  return {
+    nameRegistry: [...storage.nameRegistry],
+    entries,
+    entryMetadata
+  };
+}
+function generateId() {
+  return crypto.randomUUID();
+}
+function createEntry(location, kind) {
+  return {
+    id: generateId(),
+    location,
+    kind,
+    dirty: true
+  };
+}
+function getOrCreateMetadata(storage, entryId) {
+  let metadata = storage.entryMetadata.get(entryId);
+  if (!metadata) {
+    metadata = {
+      status: "pending",
+      attempts: 0,
+      lastAttemptAt: 0,
+      createdAt: Date.now(),
+      rollbackCompletedAt: void 0,
+      rollbackError: void 0,
+      dirty: true
+    };
+    storage.entryMetadata.set(entryId, metadata);
+  }
+  return metadata;
+}
+async function loadStorage(driver) {
+  const storage = createStorage();
+  const nameEntries = await driver.list(buildNamePrefix());
+  nameEntries.sort((a, b) => compareKeys(a.key, b.key));
+  for (const entry of nameEntries) {
+    const index = parseNameKey(entry.key);
+    storage.nameRegistry[index] = deserializeName(entry.value);
+  }
+  storage.flushedNameCount = storage.nameRegistry.length;
+  const historyEntries = await driver.list(buildHistoryPrefixAll());
+  for (const entry of historyEntries) {
+    const parsed = deserializeEntry(entry.value);
+    parsed.dirty = false;
+    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);
+    storage.flushedState = storage.state;
+  }
+  const outputValue = await driver.get(buildWorkflowOutputKey());
+  if (outputValue) {
+    storage.output = deserializeWorkflowOutput(outputValue);
+    storage.flushedOutput = storage.output;
+  }
+  const errorValue = await driver.get(buildWorkflowErrorKey());
+  if (errorValue) {
+    storage.error = deserializeWorkflowError(errorValue);
+    storage.flushedError = storage.error;
+  }
+  return storage;
+}
+async function loadMetadata(storage, driver, entryId) {
+  const existing = storage.entryMetadata.get(entryId);
+  if (existing) {
+    return existing;
+  }
+  const value = await driver.get(buildEntryMetadataKey(entryId));
+  if (value) {
+    const metadata = deserializeEntryMetadata(value);
+    metadata.dirty = false;
+    storage.entryMetadata.set(entryId, metadata);
+    return metadata;
+  }
+  return getOrCreateMetadata(storage, entryId);
+}
+async function flush(storage, driver, onHistoryUpdated, pendingDeletions) {
+  const writes = [];
+  let historyUpdated = false;
+  for (let i = storage.flushedNameCount; i < storage.nameRegistry.length; i++) {
+    const name = storage.nameRegistry[i];
+    if (name !== void 0) {
+      writes.push({
+        key: buildNameKey(i),
+        value: serializeName(name)
+      });
+      historyUpdated = true;
+    }
+  }
+  for (const [, entry] of storage.history.entries) {
+    if (entry.dirty) {
+      writes.push({
+        key: buildHistoryKey(entry.location),
+        value: serializeEntry(entry)
+      });
+      entry.dirty = false;
+      historyUpdated = true;
+    }
+  }
+  for (const [id, metadata] of storage.entryMetadata) {
+    if (metadata.dirty) {
+      writes.push({
+        key: buildEntryMetadataKey(id),
+        value: serializeEntryMetadata(metadata)
+      });
+      metadata.dirty = false;
+      historyUpdated = true;
+    }
+  }
+  if (storage.state !== storage.flushedState) {
+    writes.push({
+      key: buildWorkflowStateKey(),
+      value: serializeWorkflowState(storage.state)
+    });
+  }
+  if (storage.output !== void 0 && storage.output !== storage.flushedOutput) {
+    writes.push({
+      key: buildWorkflowOutputKey(),
+      value: serializeWorkflowOutput(storage.output)
+    });
+  }
+  const errorChanged = storage.error !== void 0 && (storage.flushedError === void 0 || storage.error.name !== storage.flushedError.name || storage.error.message !== storage.flushedError.message);
+  if (errorChanged) {
+    writes.push({
+      key: buildWorkflowErrorKey(),
+      value: serializeWorkflowError(storage.error)
+    });
+  }
+  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;
+  storage.flushedError = storage.error;
+  if (historyUpdated && onHistoryUpdated) {
+    onHistoryUpdated();
+  }
+}
+async function deleteEntriesWithPrefix(storage, driver, prefixLocation, onHistoryUpdated) {
+  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)) {
+      pending.keys.push(buildEntryMetadataKey(entry.id));
+      storage.entryMetadata.delete(entry.id);
+      storage.history.entries.delete(key);
+    }
+  }
+  return pending;
+}
+function getEntry(storage, location) {
+  const key = locationToKey(storage, location);
+  return storage.history.entries.get(key);
+}
+function setEntry(storage, location, entry) {
+  const key = locationToKey(storage, location);
+  storage.history.entries.set(key, entry);
+}
+
+// src/utils.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var TIMEOUT_MAX = 2147483647;
+function setLongTimeout(listener, after) {
+  let timeout;
+  function start(remaining) {
+    if (remaining <= TIMEOUT_MAX) {
+      timeout = setTimeout(listener, remaining);
+    } else {
+      timeout = setTimeout(() => {
+        start(remaining - TIMEOUT_MAX);
+      }, TIMEOUT_MAX);
+    }
+  }
+  start(after);
+  return {
+    abort: () => {
+      if (timeout !== void 0) clearTimeout(timeout);
+    }
+  };
+}
+
+// src/context.ts
+var DEFAULT_MAX_RETRIES = 3;
+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);
+}
+var StepTimeoutError = class extends Error {
+  constructor(stepName, timeoutMs) {
+    super(`Step "${stepName}" timed out after ${timeoutMs}ms`);
+    this.stepName = stepName;
+    this.timeoutMs = timeoutMs;
+    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 = _nullishCoalesce(catchKinds, () => ( DEFAULT_TRY_STEP_CATCH));
+  return effectiveCatch.includes(failure.kind);
+}
+function shouldCatchTryBlockFailure(failure, catchKinds) {
+  var _a;
+  const effectiveCatch = _nullishCoalesce(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 = _nullishCoalesce(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 _nullishCoalesce(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 = class _WorkflowContextImpl {
+  constructor(workflowId, storage, driver, messageDriver, location = emptyLocation(), abortController, mode = "forward", rollbackActions, rollbackCheckpointSet = false, historyNotifier, onError, logger, visitedKeys) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);
+    this.workflowId = workflowId;
+    this.storage = storage;
+    this.driver = driver;
+    this.messageDriver = messageDriver;
+    this.currentLocation = location;
+    this.abortController = _nullishCoalesce(abortController, () => ( new AbortController()));
+    this.mode = mode;
+    this.rollbackActions = rollbackActions;
+    this.rollbackCheckpointSet = rollbackCheckpointSet;
+    this.historyNotifier = historyNotifier;
+    this.onError = onError;
+    this.logger = logger;
+    this.visitedKeys = _nullishCoalesce(visitedKeys, () => ( /* @__PURE__ */ new Set()));
+  }
+  __init() {this.entryInProgress = false}
+  
+  
+  
+  
+  
+  
+  /** Track names used in current execution to detect duplicates */
+  __init2() {this.usedNamesInExecution = /* @__PURE__ */ new Set()}
+  __init3() {this.pendingCompletableMessageIds = /* @__PURE__ */ new Set()}
+  
+  
+  
+  get abortSignal() {
+    return this.abortController.signal;
+  }
+  get queue() {
+    return {
+      next: async (name, opts) => await this.queueNext(name, opts),
+      nextBatch: async (name, opts) => await this.queueNextBatch(name, opts),
+      send: async (name, body) => await this.queueSend(name, body)
+    };
+  }
+  isEvicted() {
+    return this.abortSignal.aborted;
+  }
+  assertNotInProgress() {
+    if (this.entryInProgress) {
+      throw new EntryInProgressError();
+    }
+  }
+  checkEvicted() {
+    if (this.abortSignal.aborted) {
+      throw new EvictedError();
+    }
+  }
+  async flushStorage() {
+    await flush(this.storage, this.driver, this.historyNotifier);
+  }
+  /**
+   * Create a new branch context for parallel/nested execution.
+   */
+  createBranch(location, abortController) {
+    return new _WorkflowContextImpl(
+      this.workflowId,
+      this.storage,
+      this.driver,
+      this.messageDriver,
+      location,
+      _nullishCoalesce(abortController, () => ( this.abortController)),
+      this.mode,
+      this.rollbackActions,
+      this.rollbackCheckpointSet,
+      this.historyNotifier,
+      this.onError,
+      this.logger,
+      this.visitedKeys
+    );
+  }
+  /**
+   * Log a debug message using the configured logger.
+   */
+  log(level, data) {
+    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 = _nullishCoalesce(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.
+   */
+  markVisited(key) {
+    this.visitedKeys.add(key);
+  }
+  /**
+   * Check if a name has already been used at the current location in this execution.
+   * Throws HistoryDivergedError if duplicate detected.
+   */
+  checkDuplicateName(name) {
+    const fullKey = locationToKey(this.storage, this.currentLocation) + "/" + name;
+    if (this.usedNamesInExecution.has(fullKey)) {
+      throw new HistoryDivergedError(
+        `Duplicate entry name "${name}" at location "${locationToKey(this.storage, this.currentLocation)}". Each step/loop/sleep/queue.next/join/race must have a unique name within its scope.`
+      );
+    }
+    this.usedNamesInExecution.add(fullKey);
+  }
+  stopRollback() {
+    throw new RollbackStopError();
+  }
+  stopRollbackIfMissing(entry) {
+    if (this.mode === "rollback" && !entry) {
+      this.stopRollback();
+    }
+  }
+  stopRollbackIfIncomplete(condition) {
+    if (this.mode === "rollback" && condition) {
+      this.stopRollback();
+    }
+  }
+  registerRollbackAction(config2, entryId, output, metadata) {
+    var _a;
+    if (!config2.rollback) {
+      return;
+    }
+    if (metadata.rollbackCompletedAt !== void 0) {
+      return;
+    }
+    (_a = this.rollbackActions) == null ? void 0 : _a.push({
+      entryId,
+      name: config2.name,
+      output,
+      rollback: config2.rollback
+    });
+  }
+  /**
+   * Ensure a rollback checkpoint exists before registering rollback handlers.
+   */
+  ensureRollbackCheckpoint(config2) {
+    if (!config2.rollback) {
+      return;
+    }
+    if (!this.rollbackCheckpointSet) {
+      throw new RollbackCheckpointError();
+    }
+  }
+  /**
+   * Validate that all expected entries in the branch were visited.
+   * Throws HistoryDivergedError if there are unvisited entries.
+   */
+  validateComplete() {
+    const prefix = locationToKey(this.storage, this.currentLocation);
+    for (const key of this.storage.history.entries.keys()) {
+      const isUnderPrefix = prefix === "" ? true : key.startsWith(prefix + "/") || key === prefix;
+      if (isUnderPrefix) {
+        if (!this.visitedKeys.has(key)) {
+          throw new HistoryDivergedError(
+            `Entry "${key}" exists in history but was not visited. Workflow code may have changed. Use ctx.removed() to handle migrations.`
+          );
+        }
+      }
+    }
+  }
+  /**
+   * Evict the workflow.
+   */
+  evict() {
+    this.abortController.abort(new EvictedError());
+  }
+  /**
+   * Wait for eviction message.
+   *
+   * The event listener uses { once: true } to auto-remove after firing,
+   * preventing memory leaks if this method is called multiple times.
+   */
+  waitForEviction() {
+    return new Promise((_, reject) => {
+      if (this.abortSignal.aborted) {
+        reject(new EvictedError());
+        return;
+      }
+      this.abortSignal.addEventListener(
+        "abort",
+        () => {
+          reject(new EvictedError());
+        },
+        { once: true }
+      );
+    });
+  }
+  // === Step ===
+  async step(nameOrConfig, run) {
+    this.assertNotInProgress();
+    this.checkEvicted();
+    const config2 = typeof nameOrConfig === "string" ? { name: nameOrConfig, run } : nameOrConfig;
+    this.entryInProgress = true;
+    try {
+      return await this.executeStep(config2);
+    } finally {
+      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") {
+      return await this.executeStepRollback(config2);
+    }
+    this.checkDuplicateName(config2.name);
+    const location = appendName(
+      this.storage,
+      this.currentLocation,
+      config2.name
+    );
+    const key = locationToKey(this.storage, location);
+    const existing = this.storage.history.entries.get(key);
+    this.markVisited(key);
+    if (existing) {
+      if (existing.kind.type !== "step") {
+        throw new HistoryDivergedError(
+          `Expected step "${config2.name}" at ${key}, found ${existing.kind.type}`
+        );
+      }
+      const stepData = existing.kind.data;
+      const metadata2 = await loadMetadata(
+        this.storage,
+        this.driver,
+        existing.id
+      );
+      if (metadata2.status === "completed" || stepData.output !== void 0) {
+        return stepData.output;
+      }
+      const maxRetries2 = _nullishCoalesce(config2.maxRetries, () => ( DEFAULT_MAX_RETRIES));
+      if (metadata2.attempts > maxRetries2) {
+        const lastError = _nullishCoalesce(stepData.error, () => ( metadata2.error));
+        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;
+          await this.flushStorage();
+          await this.notifyStepError(
+            config2,
+            metadata2.attempts,
+            exhaustedError,
+            { willRetry: false }
+          );
+        }
+        throw exhaustedError;
+      }
+      const backoffDelay = calculateBackoff(
+        metadata2.attempts,
+        _nullishCoalesce(config2.retryBackoffBase, () => ( DEFAULT_RETRY_BACKOFF_BASE)),
+        _nullishCoalesce(config2.retryBackoffMax, () => ( DEFAULT_RETRY_BACKOFF_MAX))
+      );
+      const retryAt = metadata2.lastAttemptAt + backoffDelay;
+      const now = Date.now();
+      if (now < retryAt) {
+        throw new SleepError(retryAt);
+      }
+    }
+    const entry = _nullishCoalesce(existing, () => ( createEntry(location, { type: "step", data: {} })));
+    if (!existing) {
+      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;
+      setEntry(this.storage, location, entry);
+    } else {
+      this.log("debug", { msg: "retrying step", step: config2.name, key });
+    }
+    const metadata = getOrCreateMetadata(this.storage, entry.id);
+    const maxRetries = _nullishCoalesce(config2.maxRetries, () => ( DEFAULT_MAX_RETRIES));
+    const retryBackoffBase = _nullishCoalesce(config2.retryBackoffBase, () => ( DEFAULT_RETRY_BACKOFF_BASE));
+    const retryBackoffMax = _nullishCoalesce(config2.retryBackoffMax, () => ( DEFAULT_RETRY_BACKOFF_MAX));
+    metadata.status = "running";
+    metadata.attempts++;
+    metadata.lastAttemptAt = Date.now();
+    metadata.dirty = true;
+    const timeout = _nullishCoalesce(config2.timeout, () => ( DEFAULT_STEP_TIMEOUT));
+    try {
+      const output = await this.executeWithTimeout(
+        config2.run(),
+        timeout,
+        config2.name
+      );
+      if (entry.kind.type === "step") {
+        entry.kind.data.output = output;
+      }
+      entry.dirty = true;
+      metadata.status = "completed";
+      metadata.error = void 0;
+      metadata.completedAt = Date.now();
+      if (!config2.ephemeral) {
+        this.log("debug", {
+          msg: "flushing step",
+          step: config2.name,
+          key
+        });
+        await this.flushStorage();
+      }
+      this.log("debug", {
+        msg: "step completed",
+        step: config2.name,
+        key
+      });
+      return output;
+    } catch (error) {
+      if (error instanceof StepTimeoutError) {
+        if (entry.kind.type === "step") {
+          entry.kind.data.error = String(error);
+        }
+        entry.dirty = true;
+        metadata.status = "exhausted";
+        metadata.error = String(error);
+        await this.flushStorage();
+        await this.notifyStepError(config2, metadata.attempts, error, {
+          willRetry: false
+        });
+        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") {
+          entry.kind.data.error = String(error);
+        }
+        entry.dirty = true;
+        metadata.status = "exhausted";
+        metadata.error = String(error);
+        await this.flushStorage();
+        await this.notifyStepError(config2, metadata.attempts, error, {
+          willRetry: false
+        });
+        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);
+      }
+      entry.dirty = true;
+      const willRetry = metadata.attempts <= maxRetries;
+      metadata.status = willRetry ? "failed" : "exhausted";
+      metadata.error = String(error);
+      await this.flushStorage();
+      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(
+        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
+      });
+      throw exhaustedError;
+    }
+  }
+  /**
+  	 * Execute a promise with timeout.
+  	 *
+  	 * Note: This does NOT cancel the underlying operation. JavaScript Promises
+  	 * cannot be cancelled once started. When a timeout occurs:
+  	 * - The step is marked as failed with StepTimeoutError
+  	 * - The underlying async operation continues running in the background
+  	 * - Any side effects from the operation may still occur
+  	 *
+  	 * For cancellable operations, pass ctx.abortSignal to APIs that support AbortSignal:
+  	 *
+  	 *     return fetch(url, { signal: ctx.abortSignal });
+  
+  	 *   });
+  	 *
+  	 * Or check ctx.isEvicted() periodically in long-running loops.
+  	 */
+  async executeStepRollback(config2) {
+    this.checkDuplicateName(config2.name);
+    this.ensureRollbackCheckpoint(config2);
+    const location = appendName(
+      this.storage,
+      this.currentLocation,
+      config2.name
+    );
+    const key = locationToKey(this.storage, location);
+    const existing = this.storage.history.entries.get(key);
+    this.markVisited(key);
+    if (!existing || existing.kind.type !== "step") {
+      this.stopRollback();
+    }
+    const metadata = await loadMetadata(
+      this.storage,
+      this.driver,
+      existing.id
+    );
+    if (metadata.status !== "completed") {
+      this.stopRollback();
+    }
+    const output = existing.kind.data.output;
+    this.registerRollbackAction(config2, existing.id, output, metadata);
+    return output;
+  }
+  async executeWithTimeout(promise, timeoutMs, stepName) {
+    if (timeoutMs <= 0) {
+      return promise;
+    }
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => {
+        reject(new StepTimeoutError(stepName, timeoutMs));
+      }, timeoutMs);
+    });
+    try {
+      return await Promise.race([promise, timeoutPromise]);
+    } finally {
+      if (timeoutId !== void 0) {
+        clearTimeout(timeoutId);
+      }
+    }
+  }
+  // === Loop ===
+  async loop(nameOrConfig, run) {
+    this.assertNotInProgress();
+    this.checkEvicted();
+    const config2 = typeof nameOrConfig === "string" ? { name: nameOrConfig, run } : nameOrConfig;
+    this.entryInProgress = true;
+    try {
+      return await this.executeLoop(config2);
+    } finally {
+      this.entryInProgress = false;
+    }
+  }
+  async executeLoop(config2) {
+    this.checkDuplicateName(config2.name);
+    const location = appendName(
+      this.storage,
+      this.currentLocation,
+      config2.name
+    );
+    const key = locationToKey(this.storage, location);
+    const existing = this.storage.history.entries.get(key);
+    this.markVisited(key);
+    let entry;
+    let metadata;
+    let state;
+    let iteration;
+    let rollbackSingleIteration = false;
+    let rollbackIterationRan = false;
+    let rollbackOutput;
+    const rollbackMode = this.mode === "rollback";
+    if (existing) {
+      if (existing.kind.type !== "loop") {
+        throw new HistoryDivergedError(
+          `Expected loop "${config2.name}" at ${key}, found ${existing.kind.type}`
+        );
+      }
+      const loopData = existing.kind.data;
+      metadata = await loadMetadata(
+        this.storage,
+        this.driver,
+        existing.id
+      );
+      if (rollbackMode) {
+        if (loopData.output !== void 0) {
+          return loopData.output;
+        }
+        rollbackSingleIteration = true;
+        rollbackIterationRan = false;
+        rollbackOutput = void 0;
+      }
+      if (metadata.status === "completed") {
+        return loopData.output;
+      }
+      if (loopData.output !== void 0) {
+        return loopData.output;
+      }
+      entry = existing;
+      state = loopData.state;
+      iteration = loopData.iteration;
+      if (rollbackMode) {
+        rollbackOutput = loopData.output;
+        rollbackIterationRan = rollbackOutput !== void 0;
+      }
+    } else {
+      this.stopRollbackIfIncomplete(true);
+      state = config2.state;
+      iteration = 0;
+      entry = createEntry(location, {
+        type: "loop",
+        data: { state, iteration }
+      });
+      setEntry(this.storage, location, entry);
+      metadata = getOrCreateMetadata(this.storage, entry.id);
+    }
+    if (metadata) {
+      metadata.status = "running";
+      metadata.error = void 0;
+      metadata.dirty = true;
+    }
+    const historyPruneInterval = _nullishCoalesce(config2.historyPruneInterval, () => ( DEFAULT_LOOP_HISTORY_PRUNE_INTERVAL));
+    const historySize = _nullishCoalesce(config2.historySize, () => ( historyPruneInterval));
+    let lastPrunedUpTo = 0;
+    let deferredFlush = null;
+    while (true) {
+      if (deferredFlush) {
+        await deferredFlush;
+        deferredFlush = null;
+      }
+      if (rollbackMode && rollbackSingleIteration) {
+        if (rollbackIterationRan) {
+          return rollbackOutput;
+        }
+        this.stopRollbackIfIncomplete(true);
+      }
+      this.checkEvicted();
+      const iterationLocation = appendLoopIteration(
+        this.storage,
+        location,
+        config2.name,
+        iteration
+      );
+      const branchCtx = this.createBranch(iterationLocation);
+      const iterationResult = await config2.run(branchCtx, state);
+      if (iterationResult === void 0 && state !== void 0) {
+        throw new Error(
+          `Loop "${config2.name}" returned undefined for a stateful iteration. Return Loop.continue(state) or Loop.break(value).`
+        );
+      }
+      const result = iterationResult === void 0 ? { continue: true, state } : iterationResult;
+      branchCtx.validateComplete();
+      if ("break" in result && result.break) {
+        if (entry.kind.type === "loop") {
+          entry.kind.data.output = result.value;
+          entry.kind.data.state = state;
+          entry.kind.data.iteration = iteration;
+        }
+        entry.dirty = true;
+        if (metadata) {
+          metadata.status = "completed";
+          metadata.completedAt = Date.now();
+          metadata.dirty = true;
+        }
+        const deletions = this.collectLoopPruning(
+          location,
+          iteration + 1,
+          historySize,
+          lastPrunedUpTo
+        );
+        await this.flushStorageWithDeletions(deletions);
+        if (rollbackMode && rollbackSingleIteration) {
+          rollbackOutput = result.value;
+          rollbackIterationRan = true;
+          continue;
+        }
+        return result.value;
+      }
+      if ("continue" in result && result.continue) {
+        state = result.state;
+      }
+      iteration++;
+      if (!rollbackMode) {
+        if (entry.kind.type === "loop") {
+          entry.kind.data.state = state;
+          entry.kind.data.iteration = iteration;
+        }
+        entry.dirty = true;
+      }
+      if (iteration % historyPruneInterval === 0) {
+        const deletions = this.collectLoopPruning(
+          location,
+          iteration,
+          historySize,
+          lastPrunedUpTo
+        );
+        lastPrunedUpTo = Math.max(0, iteration - historySize);
+        deferredFlush = this.flushStorageWithDeletions(deletions);
+      }
+    }
+  }
+  /**
+   * Collect pending deletions for loop history pruning.
+   *
+   * Only deletes iterations in the range [fromIteration, keepFrom) where
+   * keepFrom = currentIteration - historySize. This avoids re-scanning
+   * already-deleted iterations.
+   */
+  collectLoopPruning(loopLocation, currentIteration, historySize, fromIteration) {
+    if (currentIteration <= historySize) {
+      return void 0;
+    }
+    const keepFrom = Math.max(0, currentIteration - historySize);
+    if (fromIteration >= keepFrom) {
+      return void 0;
+    }
+    const loopSegment = loopLocation[loopLocation.length - 1];
+    if (typeof loopSegment !== "number") {
+      throw new Error("Expected loop location to end with a name index");
+    }
+    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) {
+    const deadline = Date.now() + durationMs;
+    return this.sleepUntil(name, deadline);
+  }
+  async sleepUntil(name, timestampMs) {
+    this.assertNotInProgress();
+    this.checkEvicted();
+    this.entryInProgress = true;
+    try {
+      await this.executeSleep(name, timestampMs);
+    } finally {
+      this.entryInProgress = false;
+    }
+  }
+  async executeSleep(name, deadline) {
+    this.checkDuplicateName(name);
+    const location = appendName(this.storage, this.currentLocation, name);
+    const key = locationToKey(this.storage, location);
+    const existing = this.storage.history.entries.get(key);
+    this.markVisited(key);
+    let entry;
+    if (existing) {
+      if (existing.kind.type !== "sleep") {
+        throw new HistoryDivergedError(
+          `Expected sleep "${name}" at ${key}, found ${existing.kind.type}`
+        );
+      }
+      const sleepData = existing.kind.data;
+      if (this.mode === "rollback") {
+        this.stopRollbackIfIncomplete(sleepData.state === "pending");
+        return;
+      }
+      if (sleepData.state !== "pending") {
+        return;
+      }
+      deadline = sleepData.deadline;
+      entry = existing;
+    } else {
+      this.stopRollbackIfIncomplete(true);
+      entry = createEntry(location, {
+        type: "sleep",
+        data: { deadline, state: "pending" }
+      });
+      setEntry(this.storage, location, entry);
+      entry.dirty = true;
+      await this.flushStorage();
+    }
+    const now = Date.now();
+    const remaining = deadline - now;
+    if (remaining <= 0) {
+      if (entry.kind.type === "sleep") {
+        entry.kind.data.state = "completed";
+      }
+      entry.dirty = true;
+      await this.flushStorage();
+      return;
+    }
+    if (remaining < this.driver.workerPollInterval) {
+      await Promise.race([sleep(remaining), this.waitForEviction()]);
+      this.checkEvicted();
+      if (entry.kind.type === "sleep") {
+        entry.kind.data.state = "completed";
+      }
+      entry.dirty = true;
+      await this.flushStorage();
+      return;
+    }
+    throw new SleepError(deadline);
+  }
+  // === Rollback Checkpoint ===
+  async rollbackCheckpoint(name) {
+    this.assertNotInProgress();
+    this.checkEvicted();
+    this.entryInProgress = true;
+    try {
+      await this.executeRollbackCheckpoint(name);
+    } finally {
+      this.entryInProgress = false;
+    }
+  }
+  async executeRollbackCheckpoint(name) {
+    this.checkDuplicateName(name);
+    const location = appendName(this.storage, this.currentLocation, name);
+    const key = locationToKey(this.storage, location);
+    const existing = this.storage.history.entries.get(key);
+    this.markVisited(key);
+    if (existing) {
+      if (existing.kind.type !== "rollback_checkpoint") {
+        throw new HistoryDivergedError(
+          `Expected rollback checkpoint "${name}" at ${key}, found ${existing.kind.type}`
+        );
+      }
+      this.rollbackCheckpointSet = true;
+      return;
+    }
+    if (this.mode === "rollback") {
+      throw new HistoryDivergedError(
+        `Missing rollback checkpoint "${name}" at ${key}`
+      );
+    }
+    const entry = createEntry(location, {
+      type: "rollback_checkpoint",
+      data: { name }
+    });
+    setEntry(this.storage, location, entry);
+    entry.dirty = true;
+    await this.flushStorage();
+    this.rollbackCheckpointSet = true;
+  }
+  // === Queue ===
+  async queueSend(name, body) {
+    const message = {
+      id: crypto.randomUUID(),
+      name,
+      data: body,
+      sentAt: Date.now()
+    };
+    await this.messageDriver.addMessage(message);
+  }
+  async queueNext(name, opts) {
+    const messages = await this.queueNextBatch(name, {
+      ..._nullishCoalesce(opts, () => ( {})),
+      count: 1
+    });
+    const message = messages[0];
+    if (!message) {
+      throw new Error(
+        `queue.next("${name}") timed out before receiving a message. Use queue.nextBatch(...) for optional/time-limited reads.`
+      );
+    }
+    return message;
+  }
+  async queueNextBatch(name, opts) {
+    this.assertNotInProgress();
+    this.checkEvicted();
+    this.entryInProgress = true;
+    try {
+      return await this.executeQueueNextBatch(name, opts);
+    } finally {
+      this.entryInProgress = false;
+    }
+  }
+  async executeQueueNextBatch(name, opts) {
+    if (this.pendingCompletableMessageIds.size > 0) {
+      throw new Error(
+        "Previous completable queue message is not completed. Call `message.complete(...)` before receiving the next message."
+      );
+    }
+    const resolvedOpts = _nullishCoalesce(opts, () => ( {}));
+    const messageNames = this.normalizeQueueNames(resolvedOpts.names);
+    const messageNameLabel = this.messageNamesLabel(messageNames);
+    const count = Math.max(1, _nullishCoalesce(resolvedOpts.count, () => ( 1)));
+    const completable = resolvedOpts.completable === true;
+    this.checkDuplicateName(name);
+    const countLocation = appendName(
+      this.storage,
+      this.currentLocation,
+      `${name}:count`
+    );
+    const countKey = locationToKey(this.storage, countLocation);
+    const existingCount = this.storage.history.entries.get(countKey);
+    this.markVisited(countKey);
+    this.stopRollbackIfMissing(existingCount);
+    let deadline;
+    let deadlineEntry;
+    if (resolvedOpts.timeout !== void 0) {
+      const deadlineLocation = appendName(
+        this.storage,
+        this.currentLocation,
+        `${name}:deadline`
+      );
+      const deadlineKey = locationToKey(this.storage, deadlineLocation);
+      deadlineEntry = this.storage.history.entries.get(deadlineKey);
+      this.markVisited(deadlineKey);
+      this.stopRollbackIfMissing(deadlineEntry);
+      if (deadlineEntry && deadlineEntry.kind.type === "sleep") {
+        deadline = deadlineEntry.kind.data.deadline;
+      } else {
+        deadline = Date.now() + resolvedOpts.timeout;
+        const created = createEntry(deadlineLocation, {
+          type: "sleep",
+          data: { deadline, state: "pending" }
+        });
+        setEntry(this.storage, deadlineLocation, created);
+        created.dirty = true;
+        await this.flushStorage();
+        deadlineEntry = created;
+      }
+    }
+    if (existingCount && existingCount.kind.type === "message") {
+      const replayCount = existingCount.kind.data.data;
+      return await this.readReplayQueueMessages(
+        name,
+        replayCount,
+        completable
+      );
+    }
+    const now = Date.now();
+    if (deadline !== void 0 && now >= deadline) {
+      if (deadlineEntry && deadlineEntry.kind.type === "sleep") {
+        deadlineEntry.kind.data.state = "completed";
+        deadlineEntry.dirty = true;
+      }
+      await this.recordQueueCountEntry(
+        countLocation,
+        `${messageNameLabel}:count`,
+        0
+      );
+      return [];
+    }
+    const received = await this.receiveMessagesNow(
+      messageNames,
+      count,
+      completable
+    );
+    if (received.length > 0) {
+      const historyMessages = received.map(
+        (message) => this.toWorkflowQueueMessage(message)
+      );
+      if (deadlineEntry && deadlineEntry.kind.type === "sleep") {
+        deadlineEntry.kind.data.state = "interrupted";
+        deadlineEntry.dirty = true;
+      }
+      await this.recordQueueMessages(
+        name,
+        countLocation,
+        messageNames,
+        historyMessages
+      );
+      const queueMessages = received.map(
+        (message, index) => this.createQueueMessage(message, completable, {
+          historyLocation: appendName(
+            this.storage,
+            this.currentLocation,
+            `${name}:${index}`
+          )
+        })
+      );
+      return queueMessages;
+    }
+    if (deadline === void 0) {
+      throw new MessageWaitError(messageNames);
+    }
+    throw new SleepError(deadline, messageNames);
+  }
+  normalizeQueueNames(names) {
+    if (!names || names.length === 0) {
+      return [];
+    }
+    const deduped = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const name of names) {
+      if (seen.has(name)) {
+        continue;
+      }
+      seen.add(name);
+      deduped.push(name);
+    }
+    return deduped;
+  }
+  messageNamesLabel(messageNames) {
+    if (messageNames.length === 0) {
+      return "*";
+    }
+    return messageNames.length === 1 ? messageNames[0] : messageNames.join("|");
+  }
+  async receiveMessagesNow(messageNames, count, completable) {
+    return await this.messageDriver.receiveMessages({
+      names: messageNames.length > 0 ? messageNames : void 0,
+      count,
+      completable
+    });
+  }
+  async recordQueueMessages(name, countLocation, messageNames, messages) {
+    for (let i = 0; i < messages.length; i++) {
+      const messageLocation = appendName(
+        this.storage,
+        this.currentLocation,
+        `${name}:${i}`
+      );
+      const messageEntry = createEntry(messageLocation, {
+        type: "message",
+        data: {
+          name: messages[i].name,
+          data: this.toHistoryQueueMessage(messages[i])
+        }
+      });
+      setEntry(this.storage, messageLocation, messageEntry);
+      this.markVisited(locationToKey(this.storage, messageLocation));
+    }
+    await this.recordQueueCountEntry(
+      countLocation,
+      `${this.messageNamesLabel(messageNames)}:count`,
+      messages.length
+    );
+  }
+  async recordQueueCountEntry(countLocation, countLabel, count) {
+    const countEntry = createEntry(countLocation, {
+      type: "message",
+      data: {
+        name: countLabel,
+        data: count
+      }
+    });
+    setEntry(this.storage, countLocation, countEntry);
+    await this.flushStorage();
+  }
+  async readReplayQueueMessages(name, count, completable) {
+    const results = [];
+    for (let i = 0; i < count; i++) {
+      const messageLocation = appendName(
+        this.storage,
+        this.currentLocation,
+        `${name}:${i}`
+      );
+      const messageKey = locationToKey(this.storage, messageLocation);
+      this.markVisited(messageKey);
+      const existingMessage = this.storage.history.entries.get(messageKey);
+      if (!existingMessage || existingMessage.kind.type !== "message") {
+        throw new HistoryDivergedError(
+          `Expected queue message "${name}:${i}" in history`
+        );
+      }
+      const parsed = this.fromHistoryQueueMessage(
+        existingMessage.kind.data.name,
+        existingMessage.kind.data.data
+      );
+      results.push(
+        this.createQueueMessage(parsed.message, completable, {
+          historyLocation: messageLocation,
+          completed: parsed.completed,
+          replay: true
+        })
+      );
+    }
+    return results;
+  }
+  toWorkflowQueueMessage(message) {
+    return {
+      id: message.id,
+      name: message.name,
+      body: message.data,
+      createdAt: message.sentAt
+    };
+  }
+  createQueueMessage(message, completable, opts) {
+    const queueMessage = this.toWorkflowQueueMessage(message);
+    if (!completable) {
+      return queueMessage;
+    }
+    if ((opts == null ? void 0 : opts.replay) && opts.completed) {
+      return {
+        ...queueMessage,
+        complete: async () => {
+        }
+      };
+    }
+    const messageId = message.id;
+    this.pendingCompletableMessageIds.add(messageId);
+    let completed = false;
+    return {
+      ...queueMessage,
+      complete: async (response) => {
+        if (completed) {
+          throw new Error("Queue message already completed");
+        }
+        completed = true;
+        try {
+          await this.completeMessage(message, response);
+          await this.markQueueMessageCompleted(opts == null ? void 0 : opts.historyLocation);
+          this.pendingCompletableMessageIds.delete(messageId);
+        } catch (error) {
+          completed = false;
+          throw error;
+        }
+      }
+    };
+  }
+  async markQueueMessageCompleted(historyLocation) {
+    if (!historyLocation) {
+      return;
+    }
+    const key = locationToKey(this.storage, historyLocation);
+    const entry = this.storage.history.entries.get(key);
+    if (!entry || entry.kind.type !== "message") {
+      return;
+    }
+    const parsed = this.fromHistoryQueueMessage(
+      entry.kind.data.name,
+      entry.kind.data.data
+    );
+    entry.kind.data.data = this.toHistoryQueueMessage(
+      this.toWorkflowQueueMessage(parsed.message),
+      true
+    );
+    entry.dirty = true;
+    await this.flushStorage();
+  }
+  async completeMessage(message, response) {
+    if (message.complete) {
+      await message.complete(response);
+      return;
+    }
+    await this.messageDriver.completeMessage(message.id, response);
+  }
+  toHistoryQueueMessage(message, completed = false) {
+    return {
+      [QUEUE_HISTORY_MESSAGE_MARKER]: 1,
+      id: message.id,
+      name: message.name,
+      body: message.body,
+      createdAt: message.createdAt,
+      completed
+    };
+  }
+  fromHistoryQueueMessage(name, value) {
+    if (typeof value === "object" && value !== null && value[QUEUE_HISTORY_MESSAGE_MARKER] === 1) {
+      const serialized = value;
+      const id = typeof serialized.id === "string" ? serialized.id : "";
+      const serializedName = typeof serialized.name === "string" ? serialized.name : name;
+      const createdAt = typeof serialized.createdAt === "number" ? serialized.createdAt : 0;
+      const completed = typeof serialized.completed === "boolean" ? serialized.completed : false;
+      return {
+        message: {
+          id,
+          name: serializedName,
+          data: serialized.body,
+          sentAt: createdAt
+        },
+        completed
+      };
+    }
+    return {
+      message: {
+        id: "",
+        name,
+        data: value,
+        sentAt: 0
+      },
+      completed: false
+    };
+  }
+  // === Join ===
+  async join(name, branches) {
+    this.assertNotInProgress();
+    this.checkEvicted();
+    this.entryInProgress = true;
+    try {
+      return await this.executeJoin(name, branches);
+    } finally {
+      this.entryInProgress = false;
+    }
+  }
+  async executeJoin(name, branches) {
+    this.checkDuplicateName(name);
+    const location = appendName(this.storage, this.currentLocation, name);
+    const key = locationToKey(this.storage, location);
+    const existing = this.storage.history.entries.get(key);
+    this.markVisited(key);
+    this.stopRollbackIfMissing(existing);
+    let entry;
+    if (existing) {
+      if (existing.kind.type !== "join") {
+        throw new HistoryDivergedError(
+          `Expected join "${name}" at ${key}, found ${existing.kind.type}`
+        );
+      }
+      entry = existing;
+    } else {
+      entry = createEntry(location, {
+        type: "join",
+        data: {
+          branches: Object.fromEntries(
+            Object.keys(branches).map((k) => [
+              k,
+              { status: "pending" }
+            ])
+          )
+        }
+      });
+      setEntry(this.storage, location, entry);
+      entry.dirty = true;
+      await this.flushStorage();
+    }
+    if (entry.kind.type !== "join") {
+      throw new HistoryDivergedError("Entry type mismatch");
+    }
+    this.stopRollbackIfIncomplete(
+      Object.values(entry.kind.data.branches).some(
+        (branch) => branch.status !== "completed"
+      )
+    );
+    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(
+          _nullishCoalesce(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;
+        }
+        if (branchStatus.status === "failed") {
+          errors[branchName] = new Error(branchStatus.error);
+          return;
+        }
+        const branchLocation = appendName(
+          this.storage,
+          location,
+          branchName
+        );
+        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;
+        }
+        entry.dirty = true;
+      }
+    );
+    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 attachTryBlockFailure(new JoinError(errors), {
+        source: "join",
+        name
+      });
+    }
+    return results;
+  }
+  // === Race ===
+  async race(name, branches) {
+    this.assertNotInProgress();
+    this.checkEvicted();
+    this.entryInProgress = true;
+    try {
+      return await this.executeRace(name, branches);
+    } finally {
+      this.entryInProgress = false;
+    }
+  }
+  async executeRace(name, branches) {
+    this.checkDuplicateName(name);
+    const location = appendName(this.storage, this.currentLocation, name);
+    const key = locationToKey(this.storage, location);
+    const existing = this.storage.history.entries.get(key);
+    this.markVisited(key);
+    this.stopRollbackIfMissing(existing);
+    let entry;
+    if (existing) {
+      if (existing.kind.type !== "race") {
+        throw new HistoryDivergedError(
+          `Expected race "${name}" at ${key}, found ${existing.kind.type}`
+        );
+      }
+      entry = existing;
+      const raceKind = existing.kind;
+      if (raceKind.data.winner !== null) {
+        const winnerStatus = raceKind.data.branches[raceKind.data.winner];
+        return {
+          winner: raceKind.data.winner,
+          value: winnerStatus.output
+        };
+      }
+      this.stopRollbackIfIncomplete(true);
+    } else {
+      entry = createEntry(location, {
+        type: "race",
+        data: {
+          winner: null,
+          branches: Object.fromEntries(
+            branches.map((b) => [
+              b.name,
+              { status: "pending" }
+            ])
+          )
+        }
+      });
+      setEntry(this.storage, location, entry);
+      entry.dirty = true;
+      await this.flushStorage();
+    }
+    if (entry.kind.type !== "race") {
+      throw new HistoryDivergedError("Entry type mismatch");
+    }
+    const raceData = entry.kind.data;
+    const raceAbortController = new AbortController();
+    const branchPromises = [];
+    let winnerName = null;
+    let winnerValue;
+    let hasWinner = false;
+    const errors = {};
+    const lateErrors = [];
+    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") {
+        if (branchStatus.status === "failed") {
+          errors[branch.name] = new Error(
+            _nullishCoalesce(branchStatus.error, () => ( "branch failed"))
+          );
+        }
+        if (branchStatus.status === "completed" && !hasWinner) {
+          hasWinner = true;
+          winnerName = branch.name;
+          winnerValue = branchStatus.output;
+        }
+      }
+    }
+    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;
+      }
+      const branchLocation = appendName(
+        this.storage,
+        location,
+        branch.name
+      );
+      const branchCtx = this.createBranch(
+        branchLocation,
+        raceAbortController
+      );
+      branchStatus.status = "running";
+      branchStatus.error = void 0;
+      entry.dirty = true;
+      const branchPromise = branch.run(branchCtx).then(
+        async (output) => {
+          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;
+          }
+          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) => {
+          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 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) {
+            branchStatus.status = "cancelled";
+          } else {
+            branchStatus.status = "failed";
+            branchStatus.output = void 0;
+            branchStatus.error = String(error);
+            errors[branch.name] = error;
+          }
+          entry.dirty = true;
+        }
+      );
+      branchPromises.push(branchPromise);
+    }
+    await Promise.allSettled(branchPromises);
+    if (propagatedError) {
+      await this.flushStorage();
+      throw propagatedError;
+    }
+    if (!hasWinner && Object.values(raceData.branches).some(
+      (branch) => branch.status === "pending" || branch.status === "running"
+    )) {
+      await this.flushStorage();
+      if (!schedulerYieldState) {
+        throw new Error(
+          `Race "${name}" has pending branches without a scheduler yield`
+        );
+      }
+      throw buildSchedulerYieldError(schedulerYieldState);
+    }
+    if (hasWinner && winnerName !== null) {
+      for (const branch of branches) {
+        if (branch.name !== winnerName) {
+          const branchLocation = appendName(
+            this.storage,
+            location,
+            branch.name
+          );
+          await deleteEntriesWithPrefix(
+            this.storage,
+            this.driver,
+            branchLocation,
+            this.historyNotifier
+          );
+        }
+      }
+    }
+    await this.flushStorage();
+    if (lateErrors.length > 0) {
+      console.warn(
+        `Race "${name}" had ${lateErrors.length} branch(es) fail after winner was determined:`,
+        lateErrors
+      );
+    }
+    if (hasWinner && winnerName !== null) {
+      return { winner: winnerName, value: winnerValue };
+    }
+    throw attachTryBlockFailure(
+      new RaceError(
+        "All branches failed",
+        Object.entries(errors).map(([branchName, error]) => ({
+          name: branchName,
+          error: String(error)
+        }))
+      ),
+      {
+        source: "race",
+        name
+      }
+    );
+  }
+  // === Removed ===
+  async removed(name, originalType) {
+    this.assertNotInProgress();
+    this.checkEvicted();
+    this.entryInProgress = true;
+    try {
+      await this.executeRemoved(name, originalType);
+    } finally {
+      this.entryInProgress = false;
+    }
+  }
+  async executeRemoved(name, originalType) {
+    this.checkDuplicateName(name);
+    const location = appendName(this.storage, this.currentLocation, name);
+    const key = locationToKey(this.storage, location);
+    const existing = this.storage.history.entries.get(key);
+    this.markVisited(key);
+    this.stopRollbackIfMissing(existing);
+    if (existing) {
+      if (existing.kind.type !== "removed" && existing.kind.type !== originalType) {
+        throw new HistoryDivergedError(
+          `Expected ${originalType} or removed at ${key}, found ${existing.kind.type}`
+        );
+      }
+      return;
+    }
+    const entry = createEntry(location, {
+      type: "removed",
+      data: { originalType, originalName: name }
+    });
+    setEntry(this.storage, location, entry);
+    await this.flushStorage();
+  }
+}, _class);
+
+// src/index.ts
+var Loop = {
+  continue: (state) => ({
+    continue: true,
+    state
+  }),
+  break: (value) => ({
+    break: true,
+    value
+  })
+};
+function createLiveRuntime() {
+  return {
+    isSleeping: false
+  };
+}
+function createEvictionWait(signal) {
+  if (signal.aborted) {
+    return {
+      promise: Promise.reject(new EvictedError()),
+      cleanup: () => {
+      }
+    };
+  }
+  let onAbort;
+  const promise = new Promise((_, reject) => {
+    onAbort = () => {
+      reject(new EvictedError());
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+  return {
+    promise,
+    cleanup: () => {
+      if (onAbort) {
+        signal.removeEventListener("abort", onAbort);
+      }
+    }
+  };
+}
+function createRollbackContext(workflowId, abortController) {
+  return {
+    workflowId,
+    abortSignal: abortController.signal,
+    isEvicted: () => abortController.signal.aborted
+  };
+}
+async function awaitWithEviction(promise, abortSignal) {
+  const { promise: evictionPromise, cleanup } = createEvictionWait(abortSignal);
+  try {
+    return await Promise.race([promise, evictionPromise]);
+  } finally {
+    cleanup();
+  }
+}
+async function executeRollback(workflowId, workflowFn, input, driver, messageDriver, abortController, storage, historyNotifier, onError, logger) {
+  const rollbackActions = [];
+  const ctx = new WorkflowContextImpl(
+    workflowId,
+    storage,
+    driver,
+    messageDriver,
+    void 0,
+    abortController,
+    "rollback",
+    rollbackActions,
+    false,
+    historyNotifier,
+    onError,
+    logger
+  );
+  try {
+    await workflowFn(ctx, input);
+  } catch (error) {
+    if (error instanceof EvictedError) {
+      throw error;
+    }
+    if (error instanceof RollbackStopError) {
+    } else {
+    }
+  }
+  if (rollbackActions.length === 0) {
+    return;
+  }
+  const rollbackContext = createRollbackContext(workflowId, abortController);
+  for (let i = rollbackActions.length - 1; i >= 0; i--) {
+    if (abortController.signal.aborted) {
+      throw new EvictedError();
+    }
+    const action = rollbackActions[i];
+    const metadata = await loadMetadata(storage, driver, action.entryId);
+    if (metadata.rollbackCompletedAt !== void 0) {
+      continue;
+    }
+    let rollbackEvent;
+    try {
+      await awaitWithEviction(
+        action.rollback(rollbackContext, action.output),
+        abortController.signal
+      );
+      metadata.rollbackCompletedAt = Date.now();
+      metadata.rollbackError = void 0;
+    } catch (error) {
+      if (error instanceof EvictedError) {
+        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);
+  await driver.setAlarm(workflowId, deadline);
+  return {
+    state: "sleeping",
+    sleepUntil: deadline,
+    waitingForMessages: messageNames
+  };
+}
+async function setMessageWaitState(storage, driver, messageNames, historyNotifier) {
+  storage.state = "sleeping";
+  await flush(storage, driver, historyNotifier);
+  return { state: "sleeping", waitingForMessages: messageNames };
+}
+async function setEvictedState(storage, driver, historyNotifier) {
+  await flush(storage, driver, historyNotifier);
+  return { state: storage.state };
+}
+async function setRetryState(storage, driver, workflowId, retryAt, historyNotifier) {
+  storage.state = "sleeping";
+  await flush(storage, driver, historyNotifier);
+  await driver.setAlarm(workflowId, retryAt);
+  return { state: "sleeping", sleepUntil: retryAt };
+}
+async function setFailedState(storage, driver, error, historyNotifier) {
+  storage.state = "failed";
+  storage.error = extractErrorInfo(error);
+  await flush(storage, driver, historyNotifier);
+}
+async function waitForSleep(runtime, deadline, abortSignal) {
+  while (true) {
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) {
+      return;
+    }
+    let timeoutHandle;
+    const timeoutPromise = new Promise((resolve) => {
+      timeoutHandle = setLongTimeout(resolve, remaining);
+    });
+    const wakePromise = new Promise((resolve) => {
+      runtime.sleepWaiter = resolve;
+    });
+    runtime.isSleeping = true;
+    try {
+      await awaitWithEviction(
+        Promise.race([timeoutPromise, wakePromise]),
+        abortSignal
+      );
+    } finally {
+      runtime.isSleeping = false;
+      runtime.sleepWaiter = void 0;
+      timeoutHandle == null ? void 0 : timeoutHandle.abort();
+    }
+    if (abortSignal.aborted) {
+      throw new EvictedError();
+    }
+    if (Date.now() >= deadline) {
+      return;
+    }
+  }
+}
+async function executeLiveWorkflow(workflowId, workflowFn, input, driver, messageDriver, abortController, runtime, onHistoryUpdated, onError, logger) {
+  let lastResult;
+  while (true) {
+    const result = await executeWorkflow(
+      workflowId,
+      workflowFn,
+      input,
+      driver,
+      messageDriver,
+      abortController,
+      onHistoryUpdated,
+      onError,
+      logger
+    );
+    lastResult = result;
+    if (result.state !== "sleeping") {
+      return result;
+    }
+    const hasMessages = result.waitingForMessages !== void 0;
+    const hasDeadline = result.sleepUntil !== void 0;
+    if (hasMessages && hasDeadline) {
+      try {
+        const messagePromise = awaitWithEviction(
+          driver.waitForMessages(
+            result.waitingForMessages,
+            abortController.signal
+          ),
+          abortController.signal
+        );
+        const sleepPromise = waitForSleep(
+          runtime,
+          result.sleepUntil,
+          abortController.signal
+        );
+        await Promise.race([messagePromise, sleepPromise]);
+      } catch (error) {
+        if (error instanceof EvictedError) {
+          return lastResult;
+        }
+        throw error;
+      }
+      continue;
+    }
+    if (hasMessages) {
+      try {
+        await awaitWithEviction(
+          driver.waitForMessages(
+            result.waitingForMessages,
+            abortController.signal
+          ),
+          abortController.signal
+        );
+      } catch (error) {
+        if (error instanceof EvictedError) {
+          return lastResult;
+        }
+        throw error;
+      }
+      continue;
+    }
+    if (hasDeadline) {
+      try {
+        await waitForSleep(
+          runtime,
+          result.sleepUntil,
+          abortController.signal
+        );
+      } catch (error) {
+        if (error instanceof EvictedError) {
+          return lastResult;
+        }
+        throw error;
+      }
+      continue;
+    }
+    return result;
+  }
+}
+function runWorkflow(workflowId, workflowFn, input, driver, options = {}) {
+  const messageDriver = driver.messageDriver;
+  const abortController = new AbortController();
+  const mode = _nullishCoalesce(options.mode, () => ( "yield"));
+  const liveRuntime = mode === "live" ? createLiveRuntime() : void 0;
+  const logger = options.logger;
+  const resultPromise = mode === "live" && liveRuntime ? executeLiveWorkflow(
+    workflowId,
+    workflowFn,
+    input,
+    driver,
+    messageDriver,
+    abortController,
+    liveRuntime,
+    options.onHistoryUpdated,
+    options.onError,
+    logger
+  ) : executeWorkflow(
+    workflowId,
+    workflowFn,
+    input,
+    driver,
+    messageDriver,
+    abortController,
+    options.onHistoryUpdated,
+    options.onError,
+    logger
+  );
+  return {
+    workflowId,
+    result: resultPromise,
+    async message(name, data) {
+      const messageId = generateId();
+      await messageDriver.addMessage({
+        id: messageId,
+        name,
+        data,
+        sentAt: Date.now()
+      });
+    },
+    async wake() {
+      if (liveRuntime) {
+        if (liveRuntime.isSleeping && liveRuntime.sleepWaiter) {
+          liveRuntime.sleepWaiter();
+        }
+        return;
+      }
+      await driver.setAlarm(workflowId, Date.now());
+    },
+    async recover() {
+      const stateValue = await driver.get(buildWorkflowStateKey());
+      const state = stateValue ? deserializeWorkflowState(stateValue) : "pending";
+      if (state !== "failed") {
+        return;
+      }
+      const metadataEntries = await driver.list(
+        buildEntryMetadataPrefix()
+      );
+      const writes = [];
+      for (const entry of metadataEntries) {
+        const metadata = deserializeEntryMetadata(entry.value);
+        if (metadata.status !== "failed" && metadata.status !== "exhausted") {
+          continue;
+        }
+        metadata.status = "pending";
+        metadata.attempts = 0;
+        metadata.lastAttemptAt = 0;
+        metadata.error = void 0;
+        metadata.dirty = false;
+        writes.push({
+          key: entry.key,
+          value: serializeEntryMetadata(metadata)
+        });
+      }
+      if (writes.length > 0) {
+        await driver.batch(writes);
+      }
+      await driver.delete(buildWorkflowErrorKey());
+      await driver.set(
+        buildWorkflowStateKey(),
+        serializeWorkflowState("sleeping")
+      );
+      if (liveRuntime) {
+        if (liveRuntime.isSleeping && liveRuntime.sleepWaiter) {
+          liveRuntime.sleepWaiter();
+        }
+        return;
+      }
+      await driver.setAlarm(workflowId, Date.now());
+    },
+    evict() {
+      abortController.abort(new EvictedError());
+    },
+    async cancel() {
+      abortController.abort(new EvictedError());
+      await driver.set(
+        buildWorkflowStateKey(),
+        serializeWorkflowState("cancelled")
+      );
+      await driver.clearAlarm(workflowId);
+    },
+    async getOutput() {
+      const value = await driver.get(buildWorkflowOutputKey());
+      if (!value) {
+        return void 0;
+      }
+      return deserializeWorkflowOutput(value);
+    },
+    async getState() {
+      const value = await driver.get(buildWorkflowStateKey());
+      if (!value) {
+        return "pending";
+      }
+      return deserializeWorkflowState(value);
+    }
+  };
+}
+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 (_nullishCoalesce((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;
+  if (historyNotifier) {
+    historyNotifier();
+  }
+  if (logger) {
+    const entryKeys = Array.from(storage.history.entries.keys());
+    logger.debug({
+      msg: "loaded workflow storage",
+      state: storage.state,
+      entryCount: entryKeys.length,
+      entries: entryKeys.slice(0, 10),
+      nameRegistry: storage.nameRegistry
+    });
+  }
+  if (storage.state === "cancelled") {
+    throw new EvictedError();
+  }
+  const storedInputBytes = await driver.get(buildWorkflowInputKey());
+  let effectiveInput;
+  if (storedInputBytes) {
+    effectiveInput = deserializeWorkflowInput(storedInputBytes);
+  } else {
+    effectiveInput = input;
+    await driver.set(
+      buildWorkflowInputKey(),
+      serializeWorkflowInput(input)
+    );
+  }
+  if (storage.state === "rolling_back") {
+    try {
+      await executeRollback(
+        workflowId,
+        workflowFn,
+        effectiveInput,
+        driver,
+        messageDriver,
+        abortController,
+        storage,
+        historyNotifier,
+        onError,
+        logger
+      );
+    } catch (error) {
+      if (error instanceof EvictedError) {
+        return { state: storage.state };
+      }
+      throw error;
+    }
+    storage.state = "failed";
+    await flush(storage, driver, historyNotifier);
+    const storedError = storage.error ? new Error(storage.error.message) : new Error("Workflow failed");
+    if ((_a = storage.error) == null ? void 0 : _a.name) {
+      storedError.name = storage.error.name;
+    }
+    throw storedError;
+  }
+  const ctx = new WorkflowContextImpl(
+    workflowId,
+    storage,
+    driver,
+    messageDriver,
+    void 0,
+    abortController,
+    "forward",
+    void 0,
+    false,
+    historyNotifier,
+    onError,
+    logger
+  );
+  storage.state = "running";
+  try {
+    const output = await workflowFn(ctx, effectiveInput);
+    storage.state = "completed";
+    storage.output = output;
+    await flush(storage, driver, historyNotifier);
+    await driver.clearAlarm(workflowId);
+    return { state: "completed", output };
+  } catch (error) {
+    if (error instanceof SleepError) {
+      return await setSleepState(
+        storage,
+        driver,
+        workflowId,
+        error.deadline,
+        error.messageNames,
+        historyNotifier
+      );
+    }
+    if (error instanceof MessageWaitError) {
+      return await setMessageWaitState(
+        storage,
+        driver,
+        error.messageNames,
+        historyNotifier
+      );
+    }
+    if (error instanceof EvictedError) {
+      return await setEvictedState(storage, driver, historyNotifier);
+    }
+    if (error instanceof StepFailedError) {
+      return await setRetryState(
+        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);
+    storage.state = "rolling_back";
+    await flush(storage, driver, historyNotifier);
+    try {
+      await executeRollback(
+        workflowId,
+        workflowFn,
+        effectiveInput,
+        driver,
+        messageDriver,
+        abortController,
+        storage,
+        historyNotifier,
+        onError,
+        logger
+      );
+    } catch (rollbackError) {
+      if (rollbackError instanceof EvictedError) {
+        return { state: storage.state };
+      }
+      throw rollbackError;
+    }
+    storage.state = "failed";
+    await flush(storage, driver, historyNotifier);
+    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);
+      }
+    }
+    throw error;
+  }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.extractErrorInfo = extractErrorInfo; exports.CriticalError = CriticalError; exports.RollbackError = RollbackError; exports.RollbackCheckpointError = RollbackCheckpointError; exports.SleepError = SleepError; exports.MessageWaitError = MessageWaitError; exports.EvictedError = EvictedError; exports.HistoryDivergedError = HistoryDivergedError; exports.StepExhaustedError = StepExhaustedError; exports.StepFailedError = StepFailedError; exports.JoinError = JoinError; exports.RaceError = RaceError; exports.CancelledError = CancelledError; exports.EntryInProgressError = EntryInProgressError; exports.keyStartsWith = keyStartsWith; exports.compareKeys = compareKeys; exports.keyToHex = keyToHex; exports.isLoopIterationMarker = isLoopIterationMarker; exports.registerName = registerName; exports.resolveName = resolveName; exports.locationToKey = locationToKey; exports.appendName = appendName; exports.appendLoopIteration = appendLoopIteration; exports.emptyLocation = emptyLocation; exports.parentLocation = parentLocation; exports.isLocationPrefix = isLocationPrefix; exports.locationsEqual = locationsEqual; exports.createStorage = createStorage; exports.createHistorySnapshot = createHistorySnapshot; exports.generateId = generateId; exports.createEntry = createEntry; exports.getOrCreateMetadata = getOrCreateMetadata; exports.loadStorage = loadStorage; exports.loadMetadata = loadMetadata; exports.flush = flush; exports.deleteEntriesWithPrefix = deleteEntriesWithPrefix; exports.getEntry = getEntry; exports.setEntry = setEntry; exports.sleep = sleep; exports.DEFAULT_MAX_RETRIES = DEFAULT_MAX_RETRIES; exports.DEFAULT_RETRY_BACKOFF_BASE = DEFAULT_RETRY_BACKOFF_BASE; exports.DEFAULT_RETRY_BACKOFF_MAX = DEFAULT_RETRY_BACKOFF_MAX; exports.DEFAULT_LOOP_HISTORY_PRUNE_INTERVAL = DEFAULT_LOOP_HISTORY_PRUNE_INTERVAL; exports.DEFAULT_STEP_TIMEOUT = DEFAULT_STEP_TIMEOUT; exports.WorkflowContextImpl = WorkflowContextImpl; exports.Loop = Loop; exports.runWorkflow = runWorkflow; exports.replayWorkflowFromStep = replayWorkflowFromStep;
+//# sourceMappingURL=chunk-4SWXLWKL.cjs.map