awaitly 2.0.0 → 3.0.0

package/dist/workflow.js

@@ -385,7 +385,6 @@ function err(error, options) {
   const cause = options?.cause;
   return { ok: false, error, ...cause !== void 0 ? { cause } : {} };
 }
-var isOk = (r) => r.ok;
 var isUnexpectedError = (e) => e instanceof UnexpectedError || typeof e === "object" && e !== null && "_tag" in e && e._tag === "UnexpectedError";
 function extractErrorTag(error) {
   if (error == null) return "unknown";
@@ -2504,69 +2503,6 @@ function deserializeCauseNew(serialized) {
   }
   return serialized.value !== void 0 ? serialized.value : serialized.stringRepresentation;
 }
-function createMemoryCache(options = {}) {
-  const { maxSize, ttl } = options;
-  const cache = /* @__PURE__ */ new Map();
-  const isExpired = (entry) => {
-    const effectiveTtl = entry.entryTtl ?? ttl;
-    if (!effectiveTtl) return false;
-    return Date.now() - entry.timestamp > effectiveTtl;
-  };
-  const evictExpired = () => {
-    for (const [key, entry] of cache) {
-      if (isExpired(entry)) {
-        cache.delete(key);
-      }
-    }
-  };
-  const evictOldest = () => {
-    if (!maxSize || cache.size < maxSize) return;
-    let oldestKey;
-    let oldestTime = Infinity;
-    for (const [key, entry] of cache) {
-      if (entry.timestamp < oldestTime) {
-        oldestTime = entry.timestamp;
-        oldestKey = key;
-      }
-    }
-    if (oldestKey) {
-      cache.delete(oldestKey);
-    }
-  };
-  return {
-    get(key) {
-      evictExpired();
-      const entry = cache.get(key);
-      if (!entry) return void 0;
-      if (isExpired(entry)) {
-        cache.delete(key);
-        return void 0;
-      }
-      return entry.result;
-    },
-    set(key, result, options2) {
-      evictExpired();
-      evictOldest();
-      cache.set(key, { result, timestamp: Date.now(), entryTtl: options2?.ttl });
-    },
-    has(key) {
-      evictExpired();
-      const entry = cache.get(key);
-      if (!entry) return false;
-      if (isExpired(entry)) {
-        cache.delete(key);
-        return false;
-      }
-      return true;
-    },
-    delete(key) {
-      return cache.delete(key);
-    },
-    clear() {
-      cache.clear();
-    }
-  };
-}
 
 // src/workflow/cache-encoding.ts
 function isCachedErrorCause(cause) {
@@ -2815,24 +2751,7 @@ function createHook() {
 var STREAM_WRITE_ERROR = "STREAM_WRITE_ERROR";
 var STREAM_READ_ERROR = "STREAM_READ_ERROR";
 var STREAM_CLOSE_ERROR = "STREAM_CLOSE_ERROR";
-var STREAM_STORE_ERROR = "STREAM_STORE_ERROR";
 var STREAM_ENDED = "STREAM_ENDED";
-var STREAM_BACKPRESSURE_ERROR = "STREAM_BACKPRESSURE_ERROR";
-function isStreamEnded(error) {
-  return typeof error === "object" && error !== null && error.type === STREAM_ENDED;
-}
-function isStreamWriteError(error) {
-  return typeof error === "object" && error !== null && error.type === STREAM_WRITE_ERROR;
-}
-function isStreamReadError(error) {
-  return typeof error === "object" && error !== null && error.type === STREAM_READ_ERROR;
-}
-function isStreamStoreError(error) {
-  return typeof error === "object" && error !== null && error.type === STREAM_STORE_ERROR;
-}
-function isStreamBackpressureError(error) {
-  return typeof error === "object" && error !== null && error.type === STREAM_BACKPRESSURE_ERROR;
-}
 function streamWriteError(reason, message, cause) {
   return {
     type: STREAM_WRITE_ERROR,
@@ -2857,27 +2776,12 @@ function streamCloseError(reason, message, cause) {
     ...cause !== void 0 ? { cause } : {}
   };
 }
-function streamStoreError(reason, message, cause) {
-  return {
-    type: STREAM_STORE_ERROR,
-    reason,
-    message,
-    ...cause !== void 0 ? { cause } : {}
-  };
-}
 function streamEnded(finalPosition) {
   return {
     type: STREAM_ENDED,
     finalPosition
   };
 }
-function streamBackpressureError(bufferedCount, highWaterMark) {
-  return {
-    type: STREAM_BACKPRESSURE_ERROR,
-    bufferedCount,
-    highWaterMark
-  };
-}
 
 // src/streaming/backpressure.ts
 function createBackpressureController(options = {}) {
@@ -2949,9 +2853,6 @@ function createBackpressureController(options = {}) {
     }
   };
 }
-function shouldApplyBackpressure(controller) {
-  return controller.state === "paused";
-}
 
 // src/workflow/validation.ts
 function isInputValidationError(e) {
@@ -3831,7 +3732,7 @@ Use serializeResumeState() and deserializeResumeState() from 'awaitly/workflow'
         const results = [];
         let processedCount = 0;
         let lastPosition = -1;
-        const isStreamReader2 = (s) => {
+        const isStreamReader = (s) => {
           return typeof s === "object" && s !== null && "read" in s && typeof s.read === "function";
         };
         const processItem = async (item, itemIndex, itemPosition, namespace) => {
@@ -3845,7 +3746,7 @@ Use serializeResumeState() and deserializeResumeState() from 'awaitly/workflow'
           );
           return { index: itemIndex, position: itemPosition, result: stepResult };
         };
-        if (isStreamReader2(source)) {
+        if (isStreamReader(source)) {
           if (concurrency <= 1) {
             let itemPosition = source.position;
             let readResult = await source.read();
@@ -4146,2361 +4047,6 @@ Use serializeResumeState() and deserializeResumeState() from 'awaitly/workflow'
   return workflow;
 }
 
-// src/durable/index.ts
-var defaultStore;
-function createMemorySnapshotStore() {
-  const store = /* @__PURE__ */ new Map();
-  return {
-    async save(id, snapshot) {
-      store.set(id, { snapshot, updatedAt: /* @__PURE__ */ new Date() });
-    },
-    async load(id) {
-      const entry = store.get(id);
-      return entry?.snapshot ?? null;
-    },
-    async delete(id) {
-      store.delete(id);
-    },
-    async list(options) {
-      const prefix = options?.prefix ?? "";
-      const limit = options?.limit ?? 100;
-      const results = [];
-      for (const [id, entry] of store.entries()) {
-        if (prefix && !id.startsWith(prefix)) continue;
-        results.push({ id, updatedAt: entry.updatedAt.toISOString() });
-        if (results.length >= limit) break;
-      }
-      results.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
-      return results;
-    },
-    async close() {
-    }
-  };
-}
-function getDefaultStore() {
-  if (defaultStore === void 0) {
-    defaultStore = createMemorySnapshotStore();
-  }
-  return defaultStore;
-}
-function isVersionMismatch(error) {
-  return typeof error === "object" && error !== null && error.type === "VERSION_MISMATCH";
-}
-function isConcurrentExecution(error) {
-  return typeof error === "object" && error !== null && error.type === "CONCURRENT_EXECUTION";
-}
-function isPersistenceError(error) {
-  return typeof error === "object" && error !== null && error.type === "PERSISTENCE_ERROR";
-}
-function isLeaseExpired(error) {
-  return typeof error === "object" && error !== null && error.type === "LEASE_EXPIRED";
-}
-function isIdempotencyConflict(error) {
-  return typeof error === "object" && error !== null && error.type === "IDEMPOTENCY_CONFLICT";
-}
-function hasWorkflowLock(store) {
-  return typeof store.tryAcquire === "function" && typeof store.release === "function";
-}
-var activeWorkflows = /* @__PURE__ */ new Set();
-var pendingIdempotencyRuns = /* @__PURE__ */ new Map();
-var durable = {
-  /**
-   * Execute a workflow with automatic state persistence.
-   *
-   * Features:
-   * - **Automatic checkpointing**: State is saved after each keyed step
-   * - **Crash recovery**: Resume from the last completed step on restart
-   * - **Version checking**: Reject resume if workflow logic version changed
-   * - **Concurrency control**: Prevent duplicate executions of the same workflow ID
-   * - **Cancellation support**: Integrates with AbortSignal for graceful shutdown
-   *
-   * ## How It Works
-   *
-   * 1. On start: Load existing state from store (if any)
-   * 2. Check version compatibility (reject if mismatch)
-   * 3. Pre-populate cache from loaded state (skip completed steps)
-   * 4. Execute workflow, persisting state after each keyed step
-   * 5. On completion: Delete stored state (clean up)
-   * 6. On error/cancellation: State remains for future resume
-   *
-   * ## Important Notes
-   *
-   * - **Only keyed steps are durable**: Use `{ key: 'step-name' }` option
-   * - **Steps should be idempotent**: They may be retried on resume
-   * - **Serialization**: State is JSON-serialized; complex objects may lose fidelity
-   *
-   * @param deps - Workflow dependencies (Result-returning functions)
-   * @param fn - Workflow function receiving ({ step, deps, ctx })
-   * @param options - Durable execution options
-   * @returns AsyncResult with workflow result or error
-   *
-   * @example
-   * ```typescript
-   * import { durable } from 'awaitly/workflow';
-   *
-   * // Zero-config: uses in-memory store (per process)
-   * const result = await durable.run(
-   *   { fetchUser, createOrder, sendEmail },
-   *   async ({ step, deps: { fetchUser, createOrder, sendEmail } }) => {
-   *     const user = await step(() => fetchUser('123'), { key: 'fetch-user' });
-   *     const order = await step(() => createOrder(user), { key: 'create-order' });
-   *     await step(() => sendEmail(order), { key: 'send-email' });
-   *     return order;
-   *   },
-   *   { id: 'checkout-123' }
-   * );
-   *
-   * // Persistence across restarts: pass a store adapter
-   * import { postgres } from 'awaitly-postgres'; // or awaitly-mongo, awaitly-libsql
-   * const store = postgres(process.env.DATABASE_URL);
-   * await durable.run(deps, fn, { id: 'checkout-123', store });
-   *
-   * if (result.ok) {
-   *   console.log('Order completed:', result.value);
-   * } else if (isWorkflowCancelled(result.error)) {
-   *   console.log('Workflow cancelled at:', result.error.lastStepKey);
-   * }
-   * ```
-   */
-  async run(deps, fn, options) {
-    const {
-      id,
-      store: storeOption,
-      version = 1,
-      allowConcurrent = false,
-      lockTtlMs = 6e4,
-      heartbeatIntervalMs,
-      abortOnLeaseLoss,
-      metadata,
-      signal,
-      createContext,
-      onEvent,
-      onError,
-      onVersionMismatch,
-      idempotencyKey,
-      input
-    } = options;
-    const effectiveStore = storeOption ?? getDefaultStore();
-    let resolveIdempotencyRun;
-    if (idempotencyKey) {
-      const idemId = `idem:${idempotencyKey}`;
-      const pending = pendingIdempotencyRuns.get(idemId);
-      if (pending) {
-        return await pending;
-      }
-      pendingIdempotencyRuns.set(idemId, new Promise((r) => {
-        resolveIdempotencyRun = r;
-      }));
-      try {
-        const idemSnapshot = await effectiveStore.load(idemId);
-        if (idemSnapshot) {
-          if (input !== void 0 && idemSnapshot.metadata?.input !== void 0) {
-            const storedInput = JSON.stringify(idemSnapshot.metadata.input);
-            const currentInput = JSON.stringify(input);
-            if (storedInput !== currentInput) {
-              const result = err({
-                type: "IDEMPOTENCY_CONFLICT",
-                idempotencyKey,
-                workflowId: id,
-                message: `Idempotency key '${idempotencyKey}' already used with different input for workflow '${id}'.`
-              });
-              resolveIdempotencyRun(result);
-              pendingIdempotencyRuns.delete(idemId);
-              resolveIdempotencyRun = void 0;
-              return result;
-            }
-          }
-          if (idemSnapshot.execution.status === "completed" && idemSnapshot.metadata?.finalResult !== void 0) {
-            const result = idemSnapshot.metadata.finalResult;
-            resolveIdempotencyRun(result);
-            pendingIdempotencyRuns.delete(idemId);
-            resolveIdempotencyRun = void 0;
-            return result;
-          }
-          if (idemSnapshot.execution.status === "running") {
-            const result = err({
-              type: "CONCURRENT_EXECUTION",
-              workflowId: id,
-              message: `Workflow '${id}' with idempotency key '${idempotencyKey}' is already running.`,
-              reason: "cross-process"
-            });
-            resolveIdempotencyRun(result);
-            pendingIdempotencyRuns.delete(idemId);
-            resolveIdempotencyRun = void 0;
-            return result;
-          }
-        }
-      } catch {
-      }
-      try {
-        await effectiveStore.save(idemId, {
-          formatVersion: 1,
-          steps: {},
-          execution: {
-            status: "running",
-            lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
-          },
-          metadata: {
-            workflowId: id,
-            idempotencyKey,
-            input
-          }
-        });
-      } catch {
-      }
-    }
-    if (!allowConcurrent && activeWorkflows.has(id)) {
-      const error = {
-        type: "CONCURRENT_EXECUTION",
-        workflowId: id,
-        message: `Workflow '${id}' is already running. Set allowConcurrent: true to allow parallel executions.`,
-        reason: "in-process"
-      };
-      return err(error);
-    }
-    let leaseOwnerToken = null;
-    if (!allowConcurrent && hasWorkflowLock(effectiveStore)) {
-      let lease;
-      try {
-        lease = await effectiveStore.tryAcquire(id, { ttlMs: lockTtlMs });
-      } catch (lockError) {
-        const error = {
-          type: "PERSISTENCE_ERROR",
-          operation: "load",
-          workflowId: id,
-          cause: lockError,
-          message: `Failed to acquire lock for workflow '${id}': ${lockError instanceof Error ? lockError.message : String(lockError)}`
-        };
-        return err(error);
-      }
-      if (lease === null) {
-        const error = {
-          type: "CONCURRENT_EXECUTION",
-          workflowId: id,
-          message: `Workflow '${id}' is already running (lease held by another process). Set allowConcurrent: true to allow parallel executions.`,
-          reason: "cross-process"
-        };
-        return err(error);
-      }
-      leaseOwnerToken = lease.ownerToken;
-    }
-    let heartbeatTimer;
-    let leaseAbortController;
-    const lockStore = effectiveStore;
-    if (leaseOwnerToken && typeof lockStore.renew === "function") {
-      const heartbeatMs = heartbeatIntervalMs ?? Math.floor(lockTtlMs / 3);
-      leaseAbortController = new AbortController();
-      heartbeatTimer = setInterval(async () => {
-        try {
-          const renewed = await lockStore.renew(id, leaseOwnerToken, { ttlMs: lockTtlMs });
-          if (!renewed) {
-            leaseAbortController.abort(new Error("Lease expired"));
-          }
-        } catch {
-          leaseAbortController.abort(new Error("Lease renewal failed"));
-        }
-      }, heartbeatMs);
-    }
-    activeWorkflows.add(id);
-    let durableResult;
-    try {
-      let existingSnapshot = null;
-      try {
-        existingSnapshot = await effectiveStore.load(id);
-      } catch (loadError) {
-        const error = {
-          type: "PERSISTENCE_ERROR",
-          operation: "load",
-          workflowId: id,
-          cause: loadError,
-          message: `Failed to load state for workflow '${id}': ${loadError instanceof Error ? loadError.message : String(loadError)}`
-        };
-        durableResult = err(error);
-        return err(error);
-      }
-      if (existingSnapshot) {
-        try {
-          assertValidSnapshot(existingSnapshot);
-        } catch (validationError2) {
-          if (validationError2 instanceof SnapshotFormatError) {
-            const error = {
-              type: "PERSISTENCE_ERROR",
-              operation: "load",
-              workflowId: id,
-              cause: validationError2,
-              message: `Invalid snapshot format for workflow '${id}': ${validationError2.message}`
-            };
-            durableResult = err(error);
-            return err(error);
-          }
-          throw validationError2;
-        }
-      }
-      if (existingSnapshot) {
-        const storedVersion = typeof existingSnapshot.metadata?.version === "number" ? existingSnapshot.metadata.version : 1;
-        if (storedVersion !== version) {
-          const error = {
-            type: "VERSION_MISMATCH",
-            workflowId: id,
-            storedVersion,
-            requestedVersion: version,
-            currentVersion: version,
-            message: `Workflow '${id}' has stored state at version ${storedVersion} but this run requested version ${version}. Migrate the stored state to the new version, or clear state for this id (e.g. durable.deleteState(store, '${id}')) and re-run.`
-          };
-          if (!onVersionMismatch) {
-            durableResult = err(error);
-            return err(error);
-          }
-          const resolution = await Promise.resolve(
-            onVersionMismatch({ id, storedVersion, requestedVersion: version })
-          );
-          if (resolution === "throw") {
-            durableResult = err(error);
-            return err(error);
-          }
-          if (resolution === "clear") {
-            try {
-              await effectiveStore.delete(id);
-            } catch {
-            }
-            existingSnapshot = null;
-          } else {
-            existingSnapshot = resolution.migratedSnapshot;
-          }
-        }
-      }
-      const emitDurableEvent = (event, ctx) => {
-        if (onEvent) {
-          onEvent(event, ctx);
-        }
-      };
-      const resumeCollector = createResumeStateCollector();
-      const workflowOptions = {
-        // Restore from existing snapshot
-        snapshot: existingSnapshot,
-        // Persist after each keyed step
-        onAfterStep: async (stepKey, result2, wfId, ctx) => {
-          try {
-            const collectedState = resumeCollector.getResumeState();
-            const steps = {};
-            for (const [key, entry] of collectedState.steps) {
-              if (entry.result.ok) {
-                steps[key] = { ok: true, value: entry.result.value };
-              } else {
-                const cause = entry.result.cause;
-                const serializedCause = cause instanceof Error ? serializeError(cause) : serializeThrown(cause);
-                const origin = entry.meta?.origin === "throw" ? "throw" : "result";
-                steps[key] = {
-                  ok: false,
-                  error: entry.result.error,
-                  cause: serializedCause,
-                  meta: { origin }
-                };
-              }
-            }
-            const currentSnapshot = {
-              formatVersion: 1,
-              workflowName: id,
-              steps,
-              execution: {
-                status: "running",
-                lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-                currentStepId: stepKey
-              },
-              metadata: {
-                ...existingSnapshot?.metadata ?? {},
-                ...metadata,
-                version,
-                lastStepKey: stepKey
-              }
-            };
-            let snapshotToSave = existingSnapshot ? mergeSnapshots(existingSnapshot, currentSnapshot) : currentSnapshot;
-            if (snapshotToSave.warnings && snapshotToSave.warnings.length > 0) {
-              const currentStepKeys = new Set(Object.keys(currentSnapshot.steps));
-              const filtered = snapshotToSave.warnings.filter(
-                (w) => !currentStepKeys.has(w.stepId)
-              );
-              snapshotToSave = {
-                ...snapshotToSave,
-                warnings: filtered.length > 0 ? filtered : void 0
-              };
-            }
-            await effectiveStore.save(id, snapshotToSave);
-            emitDurableEvent(
-              {
-                type: "persist_success",
-                workflowId: wfId,
-                stepKey,
-                ts: Date.now(),
-                context: ctx
-              },
-              ctx
-            );
-          } catch (persistError) {
-            emitDurableEvent(
-              {
-                type: "persist_error",
-                workflowId: wfId,
-                stepKey,
-                error: persistError,
-                ts: Date.now(),
-                context: ctx
-              },
-              ctx
-            );
-          }
-        },
-        // Forward events and collect step results for snapshot building
-        onEvent: (event, ctx) => {
-          resumeCollector.handleEvent(event);
-          emitDurableEvent(event, ctx);
-        },
-        onError,
-        signal: leaseAbortController && signal ? AbortSignal.any([signal, leaseAbortController.signal]) : leaseAbortController?.signal ?? signal,
-        createContext
-      };
-      let workflowInstance;
-      try {
-        workflowInstance = createWorkflow(id, deps, workflowOptions);
-      } catch (createError) {
-        if (createError instanceof SnapshotFormatError) {
-          const error = {
-            type: "PERSISTENCE_ERROR",
-            operation: "load",
-            workflowId: id,
-            cause: createError,
-            message: `Invalid snapshot format for workflow '${id}': ${createError.message}`
-          };
-          durableResult = err(error);
-          return err(error);
-        }
-        throw createError;
-      }
-      let result;
-      try {
-        result = await workflowInstance.run(fn);
-      } catch (runError) {
-        if (runError instanceof SnapshotFormatError || runError instanceof SnapshotDecodeError) {
-          const error = {
-            type: "PERSISTENCE_ERROR",
-            operation: "load",
-            workflowId: id,
-            cause: runError,
-            message: `Invalid snapshot format for workflow '${id}': ${runError.message}`
-          };
-          durableResult = err(error);
-          return err(error);
-        }
-        throw runError;
-      }
-      if (abortOnLeaseLoss !== false && leaseAbortController?.signal.aborted) {
-        const leaseErr = err({
-          type: "LEASE_EXPIRED",
-          workflowId: id,
-          message: `Lease expired for workflow '${id}' during execution. The workflow may have been reclaimed by another process.`
-        });
-        durableResult = leaseErr;
-        return leaseErr;
-      }
-      if (result.ok) {
-        try {
-          await effectiveStore.delete(id);
-        } catch (deleteError) {
-          const error = {
-            type: "PERSISTENCE_ERROR",
-            operation: "delete",
-            workflowId: id,
-            cause: deleteError,
-            message: `Failed to delete state for workflow '${id}': ${deleteError instanceof Error ? deleteError.message : String(deleteError)}`
-          };
-          durableResult = err(error);
-          return err(error);
-        }
-        if (idempotencyKey) {
-          const idemId = `idem:${idempotencyKey}`;
-          try {
-            await effectiveStore.save(idemId, {
-              formatVersion: 1,
-              steps: {},
-              execution: {
-                status: "completed",
-                lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-                completedAt: (/* @__PURE__ */ new Date()).toISOString()
-              },
-              metadata: {
-                workflowId: id,
-                idempotencyKey,
-                input,
-                finalResult: result
-              }
-            });
-          } catch {
-          }
-        }
-      }
-      durableResult = result;
-      return result;
-    } finally {
-      activeWorkflows.delete(id);
-      if (resolveIdempotencyRun) {
-        resolveIdempotencyRun(durableResult);
-        pendingIdempotencyRuns.delete(`idem:${idempotencyKey}`);
-      }
-      if (heartbeatTimer) {
-        clearInterval(heartbeatTimer);
-      }
-      if (leaseOwnerToken !== null && hasWorkflowLock(effectiveStore)) {
-        try {
-          await effectiveStore.release(id, leaseOwnerToken);
-        } catch {
-        }
-      }
-    }
-  },
-  /**
-   * Clear all persisted workflow state from the store.
-   * Use for admin/testing. If the store implements `clear()`, that is used;
-   * otherwise clears by listing and deleting in pages.
-   *
-   * @param store - Snapshot store
-   */
-  async clearState(store) {
-    const storeWithClear = store;
-    if (typeof storeWithClear.clear === "function") {
-      await storeWithClear.clear();
-      return;
-    }
-    const limit = 100;
-    for (; ; ) {
-      const entries = await store.list({ limit });
-      if (entries.length === 0) break;
-      const ids = entries.map((e) => e.id);
-      await this.deleteStates(store, ids, { continueOnError: true });
-      if (entries.length < limit) break;
-    }
-  },
-  /**
-   * Check if a workflow ID has persisted state (can be resumed).
-   *
-   * @param store - Snapshot store
-   * @param id - Workflow execution ID
-   * @returns `true` if state exists, `false` otherwise (including on store errors)
-   */
-  async hasState(store, id) {
-    try {
-      const snapshot = await store.load(id);
-      return snapshot !== null;
-    } catch {
-      return false;
-    }
-  },
-  /**
-   * Delete persisted state for a workflow (cancel resume capability).
-   * Deleting is effectively an ack/reset: the workflow can no longer resume from that state.
-   * If you delete while a run is in flight, the run continues; on success it may delete again (no-op) or save (recreating state).
-   * For multi-worker safety, prefer deleting only when the workflow is not running or when you hold the lock.
-   *
-   * @param store - Snapshot store
-   * @param id - Workflow execution ID
-   * @returns `true` on success, `false` on store errors
-   */
-  async deleteState(store, id) {
-    try {
-      await store.delete(id);
-      return true;
-    } catch {
-      return false;
-    }
-  },
-  /**
-   * Bulk delete persisted state for multiple workflow IDs (best-effort).
-   * Use for admin/cleanup. Deletes in a loop with optional concurrency.
-   *
-   * @param store - Snapshot store
-   * @param ids - Workflow execution IDs to delete
-   * @param options - Optional concurrency and error handling
-   * @returns Count of deleted entries and any errors when continueOnError is true
-   */
-  async deleteStates(store, ids, options = {}) {
-    const { concurrency = 10, continueOnError = true } = options;
-    if (ids.length === 0) {
-      return { deleted: 0 };
-    }
-    const errors = [];
-    let deleted = 0;
-    const run2 = async (id) => {
-      try {
-        await store.delete(id);
-        deleted++;
-      } catch (error) {
-        if (continueOnError) errors.push({ id, error });
-        else throw error;
-      }
-    };
-    const limit = Math.max(1, concurrency);
-    for (let i = 0; i < ids.length; i += limit) {
-      const batch = ids.slice(i, i + limit);
-      await Promise.all(batch.map((id) => run2(id)));
-    }
-    return errors.length > 0 ? { deleted, errors } : { deleted };
-  },
-  /**
-   * List workflow IDs with persisted state.
-   *
-   * @param store - Snapshot store
-   * @param options - Optional prefix and limit
-   * @returns Array of { id, updatedAt } entries
-   */
-  async listPending(store, options) {
-    try {
-      return await store.list(options);
-    } catch {
-      return [];
-    }
-  }
-};
-
-// src/versioning.ts
-function isMigrationError(error) {
-  return typeof error === "object" && error !== null && error.type === "MIGRATION_ERROR";
-}
-function isVersionIncompatibleError(error) {
-  return typeof error === "object" && error !== null && error.type === "VERSION_INCOMPATIBLE";
-}
-async function migrateState(state, targetVersion, migrations) {
-  let currentState = state.state;
-  let currentVersion = state.version;
-  if (currentVersion > targetVersion) {
-    return err({
-      type: "VERSION_INCOMPATIBLE",
-      stateVersion: currentVersion,
-      currentVersion: targetVersion,
-      reason: "State version is higher than current workflow version. Cannot downgrade."
-    });
-  }
-  if (currentVersion === targetVersion) {
-    return ok2({ version: currentVersion, state: currentState });
-  }
-  while (currentVersion < targetVersion) {
-    const migration = migrations[currentVersion];
-    if (!migration) {
-      return err({
-        type: "VERSION_INCOMPATIBLE",
-        stateVersion: state.version,
-        currentVersion: targetVersion,
-        reason: `No migration found for version ${currentVersion} to ${currentVersion + 1}`
-      });
-    }
-    try {
-      currentState = await migration(currentState);
-      currentVersion++;
-    } catch (cause) {
-      return err({
-        type: "MIGRATION_ERROR",
-        fromVersion: currentVersion,
-        toVersion: currentVersion + 1,
-        cause
-      });
-    }
-  }
-  return ok2({ version: currentVersion, state: currentState });
-}
-function createVersionedStateLoader(config) {
-  const { version, migrations = {}, strictVersioning = true } = config;
-  return async (versionedState) => {
-    if (!versionedState) {
-      return ok2(void 0);
-    }
-    if (strictVersioning && versionedState.version > version) {
-      return err({
-        type: "VERSION_INCOMPATIBLE",
-        stateVersion: versionedState.version,
-        currentVersion: version,
-        reason: "Saved state is from a newer workflow version"
-      });
-    }
-    if (versionedState.version === version) {
-      return ok2(versionedState.state);
-    }
-    const result = await migrateState(versionedState, version, migrations);
-    if (!result.ok) {
-      return result;
-    }
-    return ok2(result.value.state);
-  };
-}
-function createVersionedState(state, version) {
-  return { version, state };
-}
-function parseVersionedState(json) {
-  if (!json) return null;
-  try {
-    const parsed = typeof json === "string" ? JSON.parse(json) : json;
-    if (typeof parsed !== "object" || parsed === null || !("version" in parsed) || typeof parsed.version !== "number" || !("state" in parsed) || !parsed.state || !Array.isArray(parsed.state.steps)) {
-      return null;
-    }
-    const typedParsed = parsed;
-    const steps = new Map(typedParsed.state.steps);
-    return {
-      version: typedParsed.version,
-      state: { steps }
-    };
-  } catch {
-    return null;
-  }
-}
-function stringifyVersionedState(state) {
-  return JSON.stringify({
-    version: state.version,
-    state: {
-      steps: Array.from(state.state.steps.entries())
-    }
-  });
-}
-function createKeyRenameMigration(renames) {
-  return (state) => {
-    const newSteps = /* @__PURE__ */ new Map();
-    for (const [key, entry] of state.steps) {
-      const newKey = renames[key] ?? key;
-      newSteps.set(newKey, entry);
-    }
-    return { steps: newSteps };
-  };
-}
-function createKeyRemoveMigration(keysToRemove) {
-  const keysSet = new Set(keysToRemove);
-  return (state) => {
-    const newSteps = /* @__PURE__ */ new Map();
-    for (const [key, entry] of state.steps) {
-      if (!keysSet.has(key)) {
-        newSteps.set(key, entry);
-      }
-    }
-    return { steps: newSteps };
-  };
-}
-function createValueTransformMigration(transforms) {
-  return (state) => {
-    const newSteps = /* @__PURE__ */ new Map();
-    for (const [key, entry] of state.steps) {
-      const transform = transforms[key];
-      newSteps.set(key, transform ? transform(entry) : entry);
-    }
-    return { steps: newSteps };
-  };
-}
-function composeMigrations(migrations) {
-  return async (state) => {
-    let currentState = state;
-    for (const migration of migrations) {
-      currentState = await migration(currentState);
-    }
-    return currentState;
-  };
-}
-
-// src/hitl/index.ts
-function createMemoryApprovalStore() {
-  const approvals = /* @__PURE__ */ new Map();
-  return {
-    async getApproval(key) {
-      const approval = approvals.get(key);
-      if (!approval) {
-        return { status: "pending" };
-      }
-      if (approval.expiresAt && Date.now() > approval.expiresAt) {
-        return { status: "expired", expiredAt: approval.expiresAt };
-      }
-      return approval;
-    },
-    async createApproval(key, options) {
-      approvals.set(key, {
-        status: "pending",
-        metadata: options?.metadata,
-        expiresAt: options?.expiresAt
-      });
-    },
-    async grantApproval(key, value, options) {
-      approvals.set(key, {
-        status: "approved",
-        value,
-        approvedBy: options?.approvedBy,
-        approvedAt: Date.now()
-      });
-    },
-    async rejectApproval(key, reason, options) {
-      approvals.set(key, {
-        status: "rejected",
-        reason,
-        rejectedBy: options?.rejectedBy,
-        rejectedAt: Date.now()
-      });
-    },
-    async editApproval(key, originalValue, editedValue, options) {
-      approvals.set(key, {
-        status: "edited",
-        originalValue,
-        editedValue,
-        editedBy: options?.editedBy,
-        editedAt: Date.now()
-      });
-    },
-    async cancelApproval(key) {
-      approvals.delete(key);
-    },
-    async listPending(options) {
-      const pending = [];
-      for (const [key, approval] of approvals) {
-        if (approval.status === "pending") {
-          if (!options?.prefix || key.startsWith(options.prefix)) {
-            pending.push(key);
-          }
-        }
-      }
-      return pending;
-    }
-  };
-}
-function createMemoryWorkflowStateStore() {
-  const states = /* @__PURE__ */ new Map();
-  return {
-    async save(state) {
-      states.set(state.runId, { ...state, updatedAt: Date.now() });
-    },
-    async load(runId) {
-      return states.get(runId);
-    },
-    async delete(runId) {
-      states.delete(runId);
-    },
-    async list(options) {
-      const results = [];
-      for (const [runId, state] of states) {
-        if (options?.workflowName && state.workflowName !== options.workflowName) {
-          continue;
-        }
-        if (options?.hasPendingApprovals !== void 0) {
-          const hasPending = state.pendingApprovals.length > 0;
-          if (options.hasPendingApprovals !== hasPending) {
-            continue;
-          }
-        }
-        results.push(runId);
-      }
-      return results;
-    },
-    async findByPendingApproval(approvalKey) {
-      const results = [];
-      for (const [runId, state] of states) {
-        if (state.pendingApprovals.includes(approvalKey)) {
-          results.push(runId);
-        }
-      }
-      return results;
-    }
-  };
-}
-function createHITLOrchestrator(options) {
-  const {
-    approvalStore,
-    workflowStateStore,
-    defaultExpirationMs = 7 * 24 * 60 * 60 * 1e3,
-    // 7 days
-    logger = () => {
-    },
-    notificationChannel
-  } = options;
-  async function execute(workflowName, workflowFactory, workflowFn, input, opts) {
-    const runId = opts?.runId ?? crypto.randomUUID();
-    const collector = createApprovalStateCollector();
-    const workflow = workflowFactory({
-      onEvent: collector.handleEvent
-    });
-    const args = input;
-    const result = await workflow.run(
-      async (context) => workflowFn({ ...context, args })
-    );
-    const pendingApprovals = collector.getPendingApprovals().map((p) => p.stepKey);
-    if (pendingApprovals.length > 0) {
-      const state = {
-        runId,
-        workflowName,
-        resumeState: collector.getResumeState(),
-        pendingApprovals,
-        input,
-        metadata: opts?.metadata,
-        startedAt: Date.now(),
-        updatedAt: Date.now()
-      };
-      await workflowStateStore.save(state);
-      let reason;
-      let pendingMetadata;
-      if (!result.ok && isPendingApproval(result.error)) {
-        reason = result.error.reason;
-        pendingMetadata = result.error.metadata;
-      }
-      const expiresAt = Date.now() + defaultExpirationMs;
-      for (const key of pendingApprovals) {
-        await approvalStore.createApproval(key, {
-          metadata: { ...pendingMetadata, runId, workflowName },
-          expiresAt
-        });
-      }
-      if (notificationChannel) {
-        for (const key of pendingApprovals) {
-          try {
-            const pendingInfo = collector.getPendingApprovals().find((p) => p.stepKey === key);
-            await notificationChannel.onApprovalNeeded({
-              approvalKey: key,
-              runId,
-              workflowName,
-              reason,
-              metadata: { ...opts?.metadata, ...pendingMetadata },
-              expiresAt,
-              summary: reason ?? `Approval needed for ${key}`,
-              pendingArgs: pendingInfo?.error.metadata
-            });
-          } catch (notifyError) {
-            logger(`Failed to notify for approval ${key}: ${notifyError}`);
-          }
-        }
-      }
-      logger(`Workflow ${runId} paused, waiting for: ${pendingApprovals.join(", ")}`);
-      return {
-        status: "paused",
-        runId,
-        pendingApprovals,
-        reason
-      };
-    }
-    logger(`Workflow ${runId} completed`);
-    return { status: "completed", result };
-  }
-  async function resume(runId, workflowFactory, workflowFn) {
-    const savedState = await workflowStateStore.load(runId);
-    if (!savedState) {
-      throw new Error(`Workflow run not found: ${runId}`);
-    }
-    for (const key of savedState.pendingApprovals) {
-      const status = await approvalStore.getApproval(key);
-      if (status.status === "pending") {
-        return {
-          status: "paused",
-          runId,
-          pendingApprovals: savedState.pendingApprovals
-        };
-      }
-      if (status.status === "rejected") {
-      }
-      if (status.status === "expired") {
-        throw new Error(`Approval ${key} has expired`);
-      }
-    }
-    let resumeState = savedState.resumeState;
-    for (const key of savedState.pendingApprovals) {
-      const status = await approvalStore.getApproval(key);
-      if (status.status === "approved") {
-        resumeState = injectApproval(resumeState, {
-          stepKey: key,
-          value: status.value
-        });
-      } else if (status.status === "edited") {
-        resumeState = injectApproval(resumeState, {
-          stepKey: key,
-          value: status.editedValue
-        });
-      }
-    }
-    const collector = createApprovalStateCollector();
-    const workflow = workflowFactory({
-      resumeState,
-      onEvent: collector.handleEvent
-    });
-    const args = savedState.input;
-    const result = await workflow.run(
-      async (context) => workflowFn({ ...context, args })
-    );
-    const newPendingApprovals = collector.getPendingApprovals().map((p) => p.stepKey);
-    if (newPendingApprovals.length > 0) {
-      const updatedState = {
-        ...savedState,
-        resumeState: collector.getResumeState(),
-        pendingApprovals: newPendingApprovals,
-        updatedAt: Date.now()
-      };
-      await workflowStateStore.save(updatedState);
-      for (const key of newPendingApprovals) {
-        await approvalStore.createApproval(key, {
-          metadata: { runId, workflowName: savedState.workflowName },
-          expiresAt: Date.now() + defaultExpirationMs
-        });
-      }
-      logger(`Workflow ${runId} paused again, waiting for: ${newPendingApprovals.join(", ")}`);
-      let reason;
-      if (!result.ok && isPendingApproval(result.error)) {
-        reason = result.error.reason;
-      }
-      return {
-        status: "paused",
-        runId,
-        pendingApprovals: newPendingApprovals,
-        reason
-      };
-    }
-    await workflowStateStore.delete(runId);
-    logger(`Workflow ${runId} resumed and completed`);
-    return { status: "resumed", runId, result };
-  }
-  async function grantApprovalFn(approvalKey, value, opts) {
-    await approvalStore.grantApproval(approvalKey, value, {
-      approvedBy: opts?.approvedBy
-    });
-    const grantedAt = Date.now();
-    const resumedWorkflows = [];
-    if (opts?.autoResume !== false) {
-      const waitingWorkflows = await workflowStateStore.findByPendingApproval(approvalKey);
-      for (const runId of waitingWorkflows) {
-        resumedWorkflows.push(runId);
-      }
-    }
-    if (notificationChannel?.onApprovalResolved) {
-      await notificationChannel.onApprovalResolved({
-        approvalKey,
-        action: "approved",
-        actorId: opts?.approvedBy,
-        resolvedAt: grantedAt,
-        value
-      });
-    }
-    logger(`Approval ${approvalKey} granted by ${opts?.approvedBy ?? "unknown"}`);
-    return { grantedAt, resumedWorkflows };
-  }
-  async function rejectApprovalFn(approvalKey, reason, opts) {
-    await approvalStore.rejectApproval(approvalKey, reason, {
-      rejectedBy: opts?.rejectedBy
-    });
-    if (notificationChannel?.onApprovalResolved) {
-      await notificationChannel.onApprovalResolved({
-        approvalKey,
-        action: "rejected",
-        actorId: opts?.rejectedBy,
-        resolvedAt: Date.now(),
-        reason
-      });
-    }
-    logger(`Approval ${approvalKey} rejected: ${reason}`);
-  }
-  async function editApprovalFn(approvalKey, originalValue, editedValue, opts) {
-    await approvalStore.editApproval(approvalKey, originalValue, editedValue, {
-      editedBy: opts?.editedBy
-    });
-    const editedAt = Date.now();
-    if (notificationChannel?.onApprovalResolved) {
-      await notificationChannel.onApprovalResolved({
-        approvalKey,
-        action: "edited",
-        actorId: opts?.editedBy,
-        resolvedAt: editedAt,
-        value: editedValue,
-        originalValue
-      });
-    }
-    logger(`Approval ${approvalKey} edited by ${opts?.editedBy ?? "unknown"}`);
-    return { editedAt };
-  }
-  async function pollApproval(approvalKey, opts) {
-    const {
-      intervalMs = 1e3,
-      maxPolls,
-      timeoutMs,
-      onPollStart,
-      onPollComplete
-    } = opts ?? {};
-    const startTime = Date.now();
-    let pollCount = 0;
-    while (true) {
-      onPollStart?.();
-      const status = await approvalStore.getApproval(approvalKey);
-      onPollComplete?.(status);
-      if (status.status !== "pending") {
-        return status;
-      }
-      pollCount++;
-      if (maxPolls !== void 0 && pollCount >= maxPolls) {
-        return { status: "pending" };
-      }
-      if (timeoutMs !== void 0 && Date.now() - startTime >= timeoutMs) {
-        return { status: "pending" };
-      }
-      await new Promise((resolve) => setTimeout(resolve, intervalMs));
-    }
-  }
-  async function getWorkflowStatus(runId) {
-    return workflowStateStore.load(runId);
-  }
-  async function listPendingWorkflows(workflowName) {
-    return workflowStateStore.list({
-      workflowName,
-      hasPendingApprovals: true
-    });
-  }
-  async function cleanup(maxAgeMs) {
-    const allWorkflows = await workflowStateStore.list();
-    let cleaned = 0;
-    const cutoff = Date.now() - maxAgeMs;
-    for (const runId of allWorkflows) {
-      const state = await workflowStateStore.load(runId);
-      if (state && state.updatedAt < cutoff && state.pendingApprovals.length === 0) {
-        await workflowStateStore.delete(runId);
-        cleaned++;
-      }
-    }
-    logger(`Cleaned up ${cleaned} old workflow states`);
-    return cleaned;
-  }
-  return {
-    execute,
-    resume,
-    grantApproval: grantApprovalFn,
-    rejectApproval: rejectApprovalFn,
-    editApproval: editApprovalFn,
-    pollApproval,
-    getWorkflowStatus,
-    listPendingWorkflows,
-    cleanup
-  };
-}
-function createApprovalWebhookHandler(store) {
-  return async (request) => {
-    const { key, action, value, originalValue, editedValue, reason, actorId } = request;
-    try {
-      switch (action) {
-        case "approve":
-          await store.grantApproval(key, value, { approvedBy: actorId });
-          return {
-            success: true,
-            message: `Approval ${key} granted`,
-            data: { key, action, timestamp: Date.now() }
-          };
-        case "reject":
-          if (!reason) {
-            return { success: false, message: "Reason is required for rejection" };
-          }
-          await store.rejectApproval(key, reason, { rejectedBy: actorId });
-          return {
-            success: true,
-            message: `Approval ${key} rejected`,
-            data: { key, action, timestamp: Date.now() }
-          };
-        case "edit":
-          if (originalValue === void 0 || editedValue === void 0) {
-            return { success: false, message: "Both originalValue and editedValue are required for edit" };
-          }
-          await store.editApproval(key, originalValue, editedValue, { editedBy: actorId });
-          return {
-            success: true,
-            message: `Approval ${key} edited`,
-            data: { key, action, timestamp: Date.now() }
-          };
-        case "cancel":
-          await store.cancelApproval(key);
-          return {
-            success: true,
-            message: `Approval ${key} cancelled`,
-            data: { key, action, timestamp: Date.now() }
-          };
-        default:
-          return { success: false, message: `Unknown action: ${action}` };
-      }
-    } catch (error) {
-      return {
-        success: false,
-        message: error instanceof Error ? error.message : String(error)
-      };
-    }
-  };
-}
-function createApprovalChecker(store) {
-  return (key) => async () => {
-    const status = await store.getApproval(key);
-    switch (status.status) {
-      case "pending":
-        return { status: "pending" };
-      case "approved":
-        return { status: "approved", value: status.value };
-      case "edited":
-        return { status: "approved", value: status.editedValue };
-      case "rejected":
-        return { status: "rejected", reason: status.reason };
-      case "expired":
-        return { status: "rejected", reason: "Approval request expired" };
-      default:
-        return { status: "pending" };
-    }
-  };
-}
-
-// src/saga.ts
-function isSagaCompensationError(error) {
-  return typeof error === "object" && error !== null && error.type === "SAGA_COMPENSATION_ERROR";
-}
-function createSagaWorkflow(workflowName, deps, options) {
-  return createWorkflow(workflowName, deps, options);
-}
-async function runSaga(fn, options) {
-  const sagaId = crypto.randomUUID();
-  const startTime = performance.now();
-  const compensations = [];
-  const emit = (e) => options?.onEvent?.(e);
-  emit({ type: "saga_start", sagaId, ts: Date.now() });
-  const stepFn = async (name, operation, stepOptions) => {
-    if (typeof name !== "string" || name.length === 0) {
-      throw new TypeError(
-        "step(name, operation, options?): first argument must be a string."
-      );
-    }
-    const result = await operation();
-    if (result.ok) {
-      if (stepOptions?.compensate) {
-        compensations.push({
-          name,
-          value: result.value,
-          compensate: stepOptions.compensate
-        });
-      }
-      return result.value;
-    }
-    throw createEarlyExit(result.error, {
-      origin: "result",
-      resultCause: result.cause
-    });
-  };
-  const stepTry = async (name, operation, opts) => {
-    if (typeof name !== "string" || name.length === 0) {
-      throw new TypeError(
-        "step.try(name, operation, options): first argument must be a string."
-      );
-    }
-    const mapToError = "error" in opts ? () => opts.error : opts.onError;
-    try {
-      const value = await operation();
-      if (opts.compensate) {
-        compensations.push({
-          name,
-          value,
-          compensate: opts.compensate
-        });
-      }
-      return value;
-    } catch (thrown) {
-      const mapped = mapToError(thrown);
-      throw createEarlyExit(mapped, { origin: "throw", thrown });
-    }
-  };
-  const step = Object.assign(stepFn, { try: stepTry });
-  try {
-    const value = await fn({ step });
-    emit({
-      type: "saga_success",
-      sagaId,
-      ts: Date.now(),
-      durationMs: performance.now() - startTime
-    });
-    return ok2(value);
-  } catch (thrown) {
-    const durationMs = performance.now() - startTime;
-    const originalError = isEarlyExit(thrown) ? thrown.error : thrown;
-    emit({ type: "saga_error", sagaId, ts: Date.now(), durationMs, error: originalError });
-    emit({
-      type: "saga_compensation_start",
-      sagaId,
-      ts: Date.now(),
-      stepCount: compensations.length
-    });
-    const compensationStart = performance.now();
-    const compensationErrors = [];
-    for (let i = compensations.length - 1; i >= 0; i--) {
-      const comp = compensations[i];
-      try {
-        await comp.compensate(comp.value);
-        emit({
-          type: "saga_compensation_step",
-          sagaId,
-          stepName: comp.name,
-          ts: Date.now(),
-          success: true
-        });
-      } catch (error) {
-        compensationErrors.push({ stepName: comp.name, error });
-        emit({
-          type: "saga_compensation_step",
-          sagaId,
-          stepName: comp.name,
-          ts: Date.now(),
-          success: false,
-          error
-        });
-      }
-    }
-    emit({
-      type: "saga_compensation_end",
-      sagaId,
-      ts: Date.now(),
-      durationMs: performance.now() - compensationStart,
-      success: compensationErrors.length === 0,
-      failedCount: compensationErrors.length
-    });
-    if (compensationErrors.length > 0) {
-      const sagaError = {
-        type: "SAGA_COMPENSATION_ERROR",
-        originalError,
-        compensationErrors
-      };
-      options?.onError?.(sagaError);
-      if (options?.throwOnCompensationFailure) throw sagaError;
-      return err(sagaError);
-    }
-    options?.onError?.(originalError);
-    if (!isEarlyExit(thrown)) {
-      return err(new UnexpectedError({ cause: thrown }));
-    }
-    return err(originalError);
-  }
-}
-
-// src/streaming/stores/memory.ts
-function createMemoryStreamStore(options = {}) {
-  const maxItemsPerStream = options.maxItemsPerStream ?? Infinity;
-  const streams = /* @__PURE__ */ new Map();
-  function getStreamKey(workflowId, namespace) {
-    return `${workflowId}:${namespace}`;
-  }
-  function getOrCreateStream(workflowId, namespace) {
-    const key = getStreamKey(workflowId, namespace);
-    let data = streams.get(key);
-    if (!data) {
-      data = {
-        metadata: {
-          id: key,
-          namespace,
-          workflowId,
-          length: 0,
-          closed: false,
-          createdAt: Date.now()
-        },
-        items: [],
-        subscribers: /* @__PURE__ */ new Set()
-      };
-      streams.set(key, data);
-    }
-    return data;
-  }
-  return {
-    async append(workflowId, namespace, item) {
-      try {
-        const data = getOrCreateStream(workflowId, namespace);
-        if (data.metadata.closed) {
-          return err(
-            streamStoreError("write_error", "Cannot write to closed stream")
-          );
-        }
-        if (data.items.length >= maxItemsPerStream) {
-          return err(
-            streamStoreError(
-              "write_error",
-              `Stream exceeded max items limit (${maxItemsPerStream})`
-            )
-          );
-        }
-        data.items.push(item);
-        data.metadata.length = data.items.length;
-        data.metadata.lastWriteAt = Date.now();
-        for (const callback of data.subscribers) {
-          try {
-            callback(item);
-          } catch {
-          }
-        }
-        return ok2(void 0);
-      } catch (cause) {
-        return err(
-          streamStoreError("write_error", "Failed to append item", cause)
-        );
-      }
-    },
-    async read(workflowId, namespace, startIndex, limit) {
-      try {
-        const key = getStreamKey(workflowId, namespace);
-        const data = streams.get(key);
-        if (!data) {
-          return ok2([]);
-        }
-        const endIndex = limit !== void 0 ? Math.min(startIndex + limit, data.items.length) : data.items.length;
-        const items = data.items.slice(startIndex, endIndex);
-        return ok2(items);
-      } catch (cause) {
-        return err(streamStoreError("read_error", "Failed to read items", cause));
-      }
-    },
-    async getMetadata(workflowId, namespace) {
-      try {
-        const key = getStreamKey(workflowId, namespace);
-        const data = streams.get(key);
-        return ok2(data?.metadata);
-      } catch (cause) {
-        return err(
-          streamStoreError("metadata_error", "Failed to get metadata", cause)
-        );
-      }
-    },
-    async closeStream(workflowId, namespace) {
-      try {
-        const key = getStreamKey(workflowId, namespace);
-        const data = streams.get(key);
-        if (data) {
-          data.metadata.closed = true;
-          data.metadata.closedAt = Date.now();
-        }
-        return ok2(void 0);
-      } catch (cause) {
-        return err(
-          streamStoreError("close_error", "Failed to close stream", cause)
-        );
-      }
-    },
-    subscribe(workflowId, namespace, callback) {
-      const data = getOrCreateStream(workflowId, namespace);
-      const typedCallback = callback;
-      data.subscribers.add(typedCallback);
-      return () => {
-        data.subscribers.delete(typedCallback);
-      };
-    }
-  };
-}
-function createTestableMemoryStreamStore(options = {}) {
-  const streams = /* @__PURE__ */ new Map();
-  const maxItemsPerStream = options.maxItemsPerStream ?? Infinity;
-  function getStreamKey(workflowId, namespace) {
-    return `${workflowId}:${namespace}`;
-  }
-  function getOrCreateStream(workflowId, namespace) {
-    const key = getStreamKey(workflowId, namespace);
-    let data = streams.get(key);
-    if (!data) {
-      data = {
-        metadata: {
-          id: key,
-          namespace,
-          workflowId,
-          length: 0,
-          closed: false,
-          createdAt: Date.now()
-        },
-        items: [],
-        subscribers: /* @__PURE__ */ new Set()
-      };
-      streams.set(key, data);
-    }
-    return data;
-  }
-  const store = createMemoryStreamStore(options);
-  return {
-    ...store,
-    // Override to use our local streams map
-    async append(workflowId, namespace, item) {
-      try {
-        const data = getOrCreateStream(workflowId, namespace);
-        if (data.metadata.closed) {
-          return err(
-            streamStoreError("write_error", "Cannot write to closed stream")
-          );
-        }
-        if (data.items.length >= maxItemsPerStream) {
-          return err(
-            streamStoreError(
-              "write_error",
-              `Stream exceeded max items limit (${maxItemsPerStream})`
-            )
-          );
-        }
-        data.items.push(item);
-        data.metadata.length = data.items.length;
-        data.metadata.lastWriteAt = Date.now();
-        for (const callback of data.subscribers) {
-          try {
-            callback(item);
-          } catch {
-          }
-        }
-        return ok2(void 0);
-      } catch (cause) {
-        return err(
-          streamStoreError("write_error", "Failed to append item", cause)
-        );
-      }
-    },
-    async read(workflowId, namespace, startIndex, limit) {
-      try {
-        const key = getStreamKey(workflowId, namespace);
-        const data = streams.get(key);
-        if (!data) {
-          return ok2([]);
-        }
-        const endIndex = limit !== void 0 ? Math.min(startIndex + limit, data.items.length) : data.items.length;
-        const items = data.items.slice(startIndex, endIndex);
-        return ok2(items);
-      } catch (cause) {
-        return err(streamStoreError("read_error", "Failed to read items", cause));
-      }
-    },
-    async getMetadata(workflowId, namespace) {
-      try {
-        const key = getStreamKey(workflowId, namespace);
-        const data = streams.get(key);
-        return ok2(data?.metadata);
-      } catch (cause) {
-        return err(
-          streamStoreError("metadata_error", "Failed to get metadata", cause)
-        );
-      }
-    },
-    async closeStream(workflowId, namespace) {
-      try {
-        const key = getStreamKey(workflowId, namespace);
-        const data = streams.get(key);
-        if (data) {
-          data.metadata.closed = true;
-          data.metadata.closedAt = Date.now();
-        }
-        return ok2(void 0);
-      } catch (cause) {
-        return err(
-          streamStoreError("close_error", "Failed to close stream", cause)
-        );
-      }
-    },
-    subscribe(workflowId, namespace, callback) {
-      const data = getOrCreateStream(workflowId, namespace);
-      const typedCallback = callback;
-      data.subscribers.add(typedCallback);
-      return () => {
-        data.subscribers.delete(typedCallback);
-      };
-    },
-    clear() {
-      streams.clear();
-    },
-    keys() {
-      return Array.from(streams.keys());
-    },
-    has(workflowId, namespace) {
-      return streams.has(getStreamKey(workflowId, namespace));
-    },
-    delete(workflowId, namespace) {
-      return streams.delete(getStreamKey(workflowId, namespace));
-    }
-  };
-}
-
-// src/streaming/stores/file.ts
-function createFileStreamStore(options) {
-  const { directory, fs } = options;
-  const subscribers = /* @__PURE__ */ new Map();
-  function getStreamDir(workflowId, namespace) {
-    return `${directory}/${workflowId}/${namespace}`;
-  }
-  function getMetadataPath(workflowId, namespace) {
-    return `${getStreamDir(workflowId, namespace)}/metadata.json`;
-  }
-  function getItemsPath(workflowId, namespace) {
-    return `${getStreamDir(workflowId, namespace)}/items.jsonl`;
-  }
-  function getSubscriberKey(workflowId, namespace) {
-    return `${workflowId}:${namespace}`;
-  }
-  async function ensureDir(workflowId, namespace) {
-    const dir = getStreamDir(workflowId, namespace);
-    await fs.mkdir(dir, { recursive: true });
-  }
-  async function readMetadata(workflowId, namespace) {
-    const metaPath = getMetadataPath(workflowId, namespace);
-    if (!await fs.exists(metaPath)) {
-      return void 0;
-    }
-    const content = await fs.readFile(metaPath);
-    return JSON.parse(content);
-  }
-  async function writeMetadata(workflowId, namespace, metadata) {
-    await ensureDir(workflowId, namespace);
-    const metaPath = getMetadataPath(workflowId, namespace);
-    await fs.writeFile(metaPath, JSON.stringify(metadata, null, 2));
-  }
-  async function appendItem(workflowId, namespace, item) {
-    await ensureDir(workflowId, namespace);
-    const itemsPath = getItemsPath(workflowId, namespace);
-    const line = JSON.stringify(item) + "\n";
-    let content = "";
-    if (await fs.exists(itemsPath)) {
-      content = await fs.readFile(itemsPath);
-    }
-    await fs.writeFile(itemsPath, content + line);
-  }
-  async function readItems(workflowId, namespace, startIndex, limit) {
-    const itemsPath = getItemsPath(workflowId, namespace);
-    if (!await fs.exists(itemsPath)) {
-      return [];
-    }
-    const content = await fs.readFile(itemsPath);
-    const lines = content.trim().split("\n").filter(Boolean);
-    const items = [];
-    for (const line of lines) {
-      const item = JSON.parse(line);
-      if (item.position >= startIndex) {
-        items.push(item);
-        if (limit !== void 0 && items.length >= limit) {
-          break;
-        }
-      }
-    }
-    return items;
-  }
-  return {
-    async append(workflowId, namespace, item) {
-      try {
-        let metadata = await readMetadata(workflowId, namespace);
-        if (!metadata) {
-          metadata = {
-            id: `${workflowId}:${namespace}`,
-            namespace,
-            workflowId,
-            length: 0,
-            closed: false,
-            createdAt: Date.now()
-          };
-        }
-        if (metadata.closed) {
-          return err(
-            streamStoreError("write_error", "Cannot write to closed stream")
-          );
-        }
-        const serializedItem = {
-          value: item.value,
-          position: item.position,
-          ts: item.ts
-        };
-        await appendItem(workflowId, namespace, serializedItem);
-        metadata.length++;
-        metadata.lastWriteAt = Date.now();
-        await writeMetadata(workflowId, namespace, metadata);
-        const key = getSubscriberKey(workflowId, namespace);
-        const subs = subscribers.get(key);
-        if (subs) {
-          for (const callback of subs) {
-            try {
-              callback(item);
-            } catch {
-            }
-          }
-        }
-        return ok2(void 0);
-      } catch (cause) {
-        return err(
-          streamStoreError("write_error", "Failed to append item", cause)
-        );
-      }
-    },
-    async read(workflowId, namespace, startIndex, limit) {
-      try {
-        const serializedItems = await readItems(
-          workflowId,
-          namespace,
-          startIndex,
-          limit
-        );
-        const items = serializedItems.map((si) => ({
-          value: si.value,
-          position: si.position,
-          ts: si.ts
-        }));
-        return ok2(items);
-      } catch (cause) {
-        return err(streamStoreError("read_error", "Failed to read items", cause));
-      }
-    },
-    async getMetadata(workflowId, namespace) {
-      try {
-        const meta = await readMetadata(workflowId, namespace);
-        if (!meta) {
-          return ok2(void 0);
-        }
-        return ok2({
-          id: meta.id,
-          namespace: meta.namespace,
-          workflowId: meta.workflowId,
-          length: meta.length,
-          closed: meta.closed,
-          createdAt: meta.createdAt,
-          lastWriteAt: meta.lastWriteAt,
-          closedAt: meta.closedAt
-        });
-      } catch (cause) {
-        return err(
-          streamStoreError("metadata_error", "Failed to get metadata", cause)
-        );
-      }
-    },
-    async closeStream(workflowId, namespace) {
-      try {
-        const metadata = await readMetadata(workflowId, namespace);
-        if (metadata) {
-          metadata.closed = true;
-          metadata.closedAt = Date.now();
-          await writeMetadata(workflowId, namespace, metadata);
-        }
-        return ok2(void 0);
-      } catch (cause) {
-        return err(
-          streamStoreError("close_error", "Failed to close stream", cause)
-        );
-      }
-    },
-    subscribe(workflowId, namespace, callback) {
-      const key = getSubscriberKey(workflowId, namespace);
-      let subs = subscribers.get(key);
-      if (!subs) {
-        subs = /* @__PURE__ */ new Set();
-        subscribers.set(key, subs);
-      }
-      const typedCallback = callback;
-      subs.add(typedCallback);
-      return () => {
-        subs?.delete(typedCallback);
-        if (subs?.size === 0) {
-          subscribers.delete(key);
-        }
-      };
-    }
-  };
-}
-
-// src/streaming/transformers.ts
-async function* toAsyncIterable(reader) {
-  while (reader.readable) {
-    const result = await reader.read();
-    if (!result.ok) {
-      if (isStreamEnded(result.error)) {
-        break;
-      }
-      throw result.error;
-    }
-    yield result.value;
-  }
-}
-async function* map(source, fn) {
-  const iterable = isStreamReader(source) ? toAsyncIterable(source) : source;
-  let index = 0;
-  for await (const item of iterable) {
-    yield await fn(item, index++);
-  }
-}
-async function* filter(source, predicate) {
-  const iterable = isStreamReader(source) ? toAsyncIterable(source) : source;
-  let index = 0;
-  for await (const item of iterable) {
-    if (await predicate(item, index++)) {
-      yield item;
-    }
-  }
-}
-async function* chunk(source, size) {
-  if (size < 1) {
-    throw new Error("Chunk size must be at least 1");
-  }
-  const iterable = isStreamReader(source) ? toAsyncIterable(source) : source;
-  let currentChunk = [];
-  for await (const item of iterable) {
-    currentChunk.push(item);
-    if (currentChunk.length >= size) {
-      yield currentChunk;
-      currentChunk = [];
-    }
-  }
-  if (currentChunk.length > 0) {
-    yield currentChunk;
-  }
-}
-async function* flatMap(source, fn) {
-  const iterable = isStreamReader(source) ? toAsyncIterable(source) : source;
-  let index = 0;
-  for await (const item of iterable) {
-    const mapped = fn(item, index++);
-    if (Symbol.asyncIterator in mapped) {
-      for await (const subItem of mapped) {
-        yield subItem;
-      }
-    } else {
-      for (const subItem of mapped) {
-        yield subItem;
-      }
-    }
-  }
-}
-async function* flatMapAsync(source, fn) {
-  const iterable = isStreamReader(source) ? toAsyncIterable(source) : source;
-  let index = 0;
-  for await (const item of iterable) {
-    const result = await fn(item, index++);
-    if (!result.ok) {
-      yield err(result.error);
-      return;
-    }
-    const mapped = result.value;
-    if (Symbol.asyncIterator in mapped) {
-      for await (const subItem of mapped) {
-        yield ok2(subItem);
-      }
-    } else {
-      for (const subItem of mapped) {
-        yield ok2(subItem);
-      }
-    }
-  }
-}
-async function* mapAsync(source, fn) {
-  const iterable = isStreamReader(source) ? toAsyncIterable(source) : source;
-  let index = 0;
-  for await (const item of iterable) {
-    yield await fn(item, index++);
-  }
-}
-async function* take(source, count) {
-  if (count <= 0) return;
-  const iterable = isStreamReader(source) ? toAsyncIterable(source) : source;
-  let taken = 0;
-  for await (const item of iterable) {
-    yield item;
-    taken++;
-    if (taken >= count) break;
-  }
-}
-async function* skip(source, count) {
-  const iterable = isStreamReader(source) ? toAsyncIterable(source) : source;
-  let skipped = 0;
-  for await (const item of iterable) {
-    if (skipped < count) {
-      skipped++;
-      continue;
-    }
-    yield item;
-  }
-}
-async function* takeWhile(source, predicate) {
-  const iterable = isStreamReader(source) ? toAsyncIterable(source) : source;
-  let index = 0;
-  for await (const item of iterable) {
-    if (!await predicate(item, index++)) break;
-    yield item;
-  }
-}
-async function* skipWhile(source, predicate) {
-  const iterable = isStreamReader(source) ? toAsyncIterable(source) : source;
-  let skipping = true;
-  let index = 0;
-  for await (const item of iterable) {
-    if (skipping && await predicate(item, index++)) {
-      continue;
-    }
-    skipping = false;
-    yield item;
-  }
-}
-async function collect(source) {
-  const items = [];
-  const iterable = isStreamReader(source) ? toAsyncIterable(source) : source;
-  for await (const item of iterable) {
-    items.push(item);
-  }
-  return items;
-}
-async function reduce(source, reducer, initial) {
-  let accumulator = initial;
-  const iterable = isStreamReader(source) ? toAsyncIterable(source) : source;
-  let index = 0;
-  for await (const item of iterable) {
-    accumulator = await reducer(accumulator, item, index++);
-  }
-  return accumulator;
-}
-function isStreamReader(value) {
-  return typeof value === "object" && value !== null && "read" in value && typeof value.read === "function" && "readable" in value;
-}
-function pipe(source, ...transformers) {
-  let result = isStreamReader(source) ? toAsyncIterable(source) : source;
-  for (const transformer of transformers) {
-    result = transformer(result);
-  }
-  return result;
-}
-
-// src/streaming/index.ts
-function getStreamReader(options) {
-  const {
-    store,
-    workflowId,
-    namespace = "default",
-    startIndex = 0,
-    pollInterval = 100,
-    pollTimeout = 3e4
-  } = options;
-  let position = startIndex;
-  let readable = true;
-  let closed = false;
-  let bufferedItems = [];
-  let bufferIndex = 0;
-  const reader = {
-    async read() {
-      if (closed) {
-        return err(streamReadError("closed", "Reader is closed"));
-      }
-      if (bufferIndex < bufferedItems.length) {
-        const item = bufferedItems[bufferIndex++];
-        position = item.position + 1;
-        return ok2(item.value);
-      }
-      const pollStart = Date.now();
-      while (Date.now() - pollStart < pollTimeout) {
-        const result = await store.read(workflowId, namespace, position, 100);
-        if (!result.ok) {
-          return err(streamReadError("store_error", result.error.message, result.error));
-        }
-        const items = result.value;
-        if (items.length > 0) {
-          bufferedItems = items;
-          bufferIndex = 1;
-          const item = items[0];
-          position = item.position + 1;
-          return ok2(item.value);
-        }
-        const metaResult = await store.getMetadata(workflowId, namespace);
-        if (metaResult.ok && metaResult.value?.closed) {
-          readable = false;
-          return err(streamEnded(position));
-        }
-        await new Promise((resolve) => setTimeout(resolve, pollInterval));
-      }
-      readable = false;
-      return err(streamEnded(position));
-    },
-    close() {
-      closed = true;
-      readable = false;
-      bufferedItems = [];
-    },
-    get readable() {
-      return readable;
-    },
-    get position() {
-      return position;
-    },
-    get namespace() {
-      return namespace;
-    }
-  };
-  return reader;
-}
-
-// src/webhook/index.ts
-function isValidationError(e) {
-  return typeof e === "object" && e !== null && e.type === "VALIDATION_ERROR";
-}
-function defaultValidationErrorMapper(error) {
-  return {
-    status: 400,
-    body: {
-      error: {
-        type: error.type,
-        message: error.message,
-        details: error.field ? { field: error.field } : error.details
-      }
-    }
-  };
-}
-function defaultUnexpectedErrorMapper(error) {
-  return {
-    status: 500,
-    body: {
-      error: {
-        type: "INTERNAL_ERROR",
-        message: error instanceof Error ? error.message : "An unexpected error occurred"
-      }
-    }
-  };
-}
-function createWebhookHandler(workflow, workflowFn, config) {
-  const {
-    validateInput: validateInput2,
-    mapResult,
-    mapValidationError = defaultValidationErrorMapper,
-    mapUnexpectedError = defaultUnexpectedErrorMapper,
-    beforeValidation,
-    afterResponse
-  } = config;
-  return async (req) => {
-    try {
-      const processedReq = beforeValidation ? await beforeValidation(req) : req;
-      const validationResult = await validateInput2(processedReq);
-      if (!isOk(validationResult)) {
-        const response2 = mapValidationError(validationResult.error, processedReq);
-        return afterResponse ? await afterResponse(response2, processedReq) : response2;
-      }
-      const args = validationResult.value;
-      const workflowResult = await workflow.run(
-        async ({ step, deps }) => workflowFn({ step, deps, args })
-      );
-      const response = mapResult(workflowResult, processedReq);
-      return afterResponse ? await afterResponse(response, processedReq) : response;
-    } catch (error) {
-      const response = mapUnexpectedError(error, req);
-      return afterResponse ? await afterResponse(response, req) : response;
-    }
-  };
-}
-function createSimpleHandler(config) {
-  const {
-    validateInput: validateInput2,
-    handler,
-    mapResult,
-    mapValidationError = defaultValidationErrorMapper,
-    mapUnexpectedError = defaultUnexpectedErrorMapper
-  } = config;
-  return async (req) => {
-    try {
-      const validationResult = await validateInput2(req);
-      if (!isOk(validationResult)) {
-        return mapValidationError(validationResult.error, req);
-      }
-      const result = await handler(validationResult.value, req);
-      return mapResult(result, req);
-    } catch (error) {
-      return mapUnexpectedError(error, req);
-    }
-  };
-}
-function createResultMapper(mappings, options = {}) {
-  const { defaultStatus = 500, successStatus = 200 } = options;
-  const errorMap = /* @__PURE__ */ new Map();
-  for (const mapping of mappings) {
-    errorMap.set(mapping.error, mapping);
-  }
-  return (result) => {
-    if (result.ok) {
-      return {
-        status: successStatus,
-        body: result.value
-      };
-    }
-    if (isUnexpectedError(result.error)) {
-      return {
-        status: 500,
-        body: {
-          error: {
-            type: "INTERNAL_ERROR",
-            message: result.error instanceof Error ? result.error.message : "An unexpected error occurred"
-          }
-        }
-      };
-    }
-    const mapping = errorMap.get(result.error);
-    if (mapping) {
-      return {
-        status: mapping.status,
-        body: {
-          error: {
-            type: String(mapping.error),
-            message: mapping.message
-          }
-        }
-      };
-    }
-    return {
-      status: defaultStatus,
-      body: {
-        error: {
-          type: String(result.error)
-        }
-      }
-    };
-  };
-}
-function toWebhookRequest(req) {
-  return {
-    method: req.method,
-    path: req.path,
-    headers: req.headers,
-    body: req.body,
-    query: req.query,
-    params: req.params,
-    raw: req
-  };
-}
-function sendWebhookResponse(res, response) {
-  if (response.headers) {
-    res.set(response.headers);
-  }
-  res.status(response.status).json(response.body);
-}
-function createExpressHandler(handler) {
-  return async (req, res) => {
-    const webhookReq = toWebhookRequest(req);
-    const response = await handler(webhookReq);
-    sendWebhookResponse(res, response);
-  };
-}
-function validationError(message, field, details) {
-  return {
-    type: "VALIDATION_ERROR",
-    message,
-    field,
-    details
-  };
-}
-function requireFields(fields) {
-  return (body) => {
-    for (const field of fields) {
-      if (body[field] === void 0 || body[field] === null || body[field] === "") {
-        return err(validationError(`Missing required field: ${field}`, field));
-      }
-    }
-    return ok2(void 0);
-  };
-}
-function composeValidators(...validators) {
-  return (input) => {
-    for (const validator of validators) {
-      const result = validator(input);
-      if (!result.ok) return result;
-    }
-    return ok2(void 0);
-  };
-}
-function createEventHandler(workflow, workflowFn, config) {
-  const { validatePayload, mapResult } = config;
-  return async (event) => {
-    try {
-      const validationResult = validatePayload(event);
-      if (!isOk(validationResult)) {
-        return {
-          success: false,
-          ack: true,
-          // Don't retry validation errors
-          error: {
-            type: validationResult.error.type,
-            message: validationResult.error.message,
-            retryable: false
-          }
-        };
-      }
-      const args = validationResult.value;
-      const workflowResult = await workflow.run(
-        async ({ step, deps }) => workflowFn({ step, deps, args })
-      );
-      return mapResult(workflowResult, event);
-    } catch (error) {
-      return {
-        success: false,
-        ack: false,
-        // Retry unexpected errors
-        error: {
-          type: "UnexpectedError",
-          message: error instanceof Error ? error.message : String(error),
-          retryable: true
-        }
-      };
-    }
-  };
-}
-
-// src/engine/index.ts
-import { randomUUID } from "crypto";
-function createEngine(options) {
-  const {
-    store,
-    workflows,
-    concurrency = 5,
-    onEvent,
-    onError
-  } = options;
-  const schedules = /* @__PURE__ */ new Map();
-  let pollTimer;
-  let running = false;
-  let tickInFlight = false;
-  function emit(event) {
-    try {
-      onEvent?.(event);
-    } catch {
-    }
-  }
-  async function enqueue(name, opts) {
-    const wf = workflows[name];
-    if (!wf) {
-      throw new Error(`Unknown workflow: '${name}'. Registered: ${Object.keys(workflows).join(", ")}`);
-    }
-    const id = opts?.id ?? `${name}:${randomUUID()}`;
-    const snapshot = {
-      formatVersion: 1,
-      workflowName: name,
-      steps: {},
-      execution: {
-        status: "running",
-        // "running" so durable.run can resume it
-        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
-      },
-      metadata: {
-        engineState: "queued",
-        workflowName: name,
-        input: opts?.input ?? null,
-        idempotencyKey: opts?.idempotencyKey,
-        enqueuedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        ...opts?.metadata
-      }
-    };
-    await store.save(id, snapshot);
-    emit({ type: "workflow_enqueued", workflowName: name, id, ts: Date.now() });
-    return id;
-  }
-  async function tick() {
-    if (tickInFlight) return 0;
-    tickInFlight = true;
-    try {
-      const entries = await store.list({ limit: concurrency * 2 });
-      let processed = 0;
-      const queued = [];
-      for (const entry of entries) {
-        if (queued.length >= concurrency) break;
-        const snapshot = await store.load(entry.id);
-        if (snapshot && snapshot.metadata?.engineState === "queued" && typeof snapshot.metadata?.workflowName === "string") {
-          queued.push({ id: entry.id, workflowName: snapshot.metadata.workflowName, snapshot });
-        }
-      }
-      const results = await Promise.allSettled(
-        queued.map(async ({ id, workflowName, snapshot }) => {
-          const wf = workflows[workflowName];
-          if (!wf) return;
-          const processingSnapshot = {
-            ...snapshot,
-            metadata: {
-              ...snapshot.metadata,
-              engineState: "processing"
-            }
-          };
-          await store.save(id, processingSnapshot);
-          emit({ type: "workflow_started", workflowName, id, ts: Date.now() });
-          const result = await durable.run(wf.deps, wf.fn, {
-            id,
-            store,
-            idempotencyKey: snapshot.metadata?.idempotencyKey,
-            input: snapshot.metadata?.input,
-            ...wf.durableDefaults
-          });
-          if (result.ok) {
-            emit({ type: "workflow_completed", workflowName, id, ts: Date.now() });
-          } else {
-            emit({ type: "workflow_failed", workflowName, id, error: result.error, ts: Date.now() });
-          }
-          processed++;
-        })
-      );
-      for (const r of results) {
-        if (r.status === "rejected") {
-          try {
-            onError?.(r.reason);
-          } catch {
-          }
-        }
-      }
-      emit({ type: "engine_tick", ts: Date.now(), processed });
-      return processed;
-    } finally {
-      tickInFlight = false;
-    }
-  }
-  function schedule(name, opts) {
-    const scheduleId = opts?.id ? `schedule:${opts.id}` : `schedule:${randomUUID()}`;
-    if (opts.immediate) {
-      void enqueue(name, opts).catch((e) => {
-        try {
-          onError?.(e);
-        } catch {
-        }
-      });
-    }
-    const interval = setInterval(() => {
-      void enqueue(name, opts).catch((e) => {
-        try {
-          onError?.(e);
-        } catch {
-        }
-      });
-    }, opts.intervalMs);
-    schedules.set(scheduleId, interval);
-    emit({ type: "schedule_created", workflowName: name, scheduleId, intervalMs: opts.intervalMs, ts: Date.now() });
-    return scheduleId;
-  }
-  function unschedule(scheduleId) {
-    const interval = schedules.get(scheduleId);
-    if (!interval) return false;
-    clearInterval(interval);
-    schedules.delete(scheduleId);
-    emit({ type: "schedule_removed", scheduleId, ts: Date.now() });
-    return true;
-  }
-  function start(pollIntervalMs = 1e3) {
-    if (running) return;
-    running = true;
-    emit({ type: "engine_start", ts: Date.now() });
-    void tick().catch((e) => {
-      try {
-        onError?.(e);
-      } catch {
-      }
-    });
-    pollTimer = setInterval(() => {
-      void tick().catch((e) => {
-        try {
-          onError?.(e);
-        } catch {
-        }
-      });
-    }, pollIntervalMs);
-  }
-  async function stop() {
-    if (!running) return;
-    running = false;
-    if (pollTimer) {
-      clearInterval(pollTimer);
-      pollTimer = void 0;
-    }
-    for (const [id, interval] of schedules) {
-      clearInterval(interval);
-      schedules.delete(id);
-    }
-    while (tickInFlight) {
-      await new Promise((resolve) => setTimeout(resolve, 50));
-    }
-    emit({ type: "engine_stop", ts: Date.now() });
-  }
-  return {
-    enqueue,
-    schedule,
-    unschedule,
-    start,
-    stop,
-    tick,
-    status: () => ({ running, pendingSchedules: schedules.size })
-  };
-}
-
 // src/resource.ts
 function isResourceCleanupError(error) {
   return typeof error === "object" && error !== null && error.type === "RESOURCE_CLEANUP_ERROR";
@@ -6792,66 +4338,26 @@ export {
   Duration,
   HOOK_STEP_KEY_PREFIX2 as HOOK_STEP_KEY_PREFIX,
   STEP_TIMEOUT_MARKER,
-  STREAM_BACKPRESSURE_ERROR,
-  STREAM_CLOSE_ERROR,
-  STREAM_ENDED,
-  STREAM_READ_ERROR,
-  STREAM_STORE_ERROR,
-  STREAM_WRITE_ERROR,
   SnapshotDecodeError,
   SnapshotFormatError,
   SnapshotMismatchError,
   UnexpectedError,
   assertValidSnapshot,
   batchPresets,
-  chunk,
   clearStep,
-  collect,
-  composeMigrations,
-  composeValidators,
-  createApprovalChecker,
   createApprovalStateCollector,
   createApprovalStep,
-  createApprovalWebhookHandler,
-  createBackpressureController,
-  createEngine,
-  createEventHandler,
-  createExpressHandler,
-  createFileStreamStore,
-  createHITLOrchestrator,
   createHook,
-  createKeyRemoveMigration,
-  createKeyRenameMigration,
-  createMemoryApprovalStore,
-  createMemoryCache,
-  createMemoryStreamStore,
-  createMemoryWorkflowStateStore,
   createResource,
   createResourceScope,
-  createResultMapper,
   createResumeStateCollector,
-  createSagaWorkflow,
-  createSimpleHandler,
-  createTestableMemoryStreamStore,
-  createValueTransformMigration,
-  createVersionedState,
-  createVersionedStateLoader,
-  createWebhookHandler,
   createWorkflow,
   days,
-  defaultUnexpectedErrorMapper,
-  defaultValidationErrorMapper,
-  deserializeCauseNew,
   deserializeResumeState,
-  durable,
-  filter,
-  flatMap,
-  flatMapAsync,
   gatedStep,
   getPendingApprovals,
   getPendingHooks,
   getStepTimeoutMeta,
-  getStreamReader,
   hasPendingApproval,
   hasPendingHook,
   hours,
@@ -6859,75 +4365,36 @@ export {
   injectHook,
   isApprovalRejected,
   isBatchProcessingError,
-  isConcurrentExecution,
   isDuration,
-  isIdempotencyConflict,
   isInputValidationError,
   isInvalidBatchConfigError,
-  isLeaseExpired,
-  isMigrationError,
   isPendingApproval,
   isPendingHook,
-  isPersistenceError,
   isResourceCleanupError,
   isResumeState,
-  isSagaCompensationError,
   isSerializedResumeState,
   isStepComplete,
   isStepTimeoutError,
-  isStreamBackpressureError,
-  isStreamEnded,
-  isStreamReadError,
-  isStreamStoreError,
-  isStreamWriteError,
-  isValidationError,
-  isVersionIncompatibleError,
-  isVersionMismatch,
   isWorkflowCancelled,
   isWorkflowSnapshot,
   looksLikeWorkflowSnapshot,
-  map,
-  mapAsync,
   mergeSnapshots,
   millis,
   minutes,
-  parseVersionedState,
   pendingApproval,
   pendingHook,
-  pipe,
   processInBatches,
-  reduce,
-  requireFields,
   run,
-  runSaga,
   seconds,
-  sendWebhookResponse,
-  serializeError,
   serializeResumeState,
-  serializeThrown,
-  shouldApplyBackpressure,
-  skip,
-  skipWhile,
-  streamBackpressureError,
-  streamCloseError,
-  streamEnded,
-  streamReadError,
-  streamStoreError,
-  streamWriteError,
-  stringifyVersionedState,
-  take,
-  takeWhile,
-  toAsyncIterable,
   toDays,
   toHours,
   toMillis,
   toMinutes,
   toResumeState,
   toSeconds,
-  toWebhookRequest,
   validateInput,
   validateSnapshot,
-  validationError,
   withDeps,
   withScope
 };