awaitly 2.0.0 → 3.0.0

package/dist/workflow.d.ts

@@ -1,603 +1,15 @@
-import { v as ApprovalRejected, P as PendingApproval, w as PendingHook, x as ResumeState, W as WorkflowEvent, y as WorkflowCancelledError, z as StepResult, C as WorkflowSnapshot, F as ApprovalStepOptions, A as AsyncResult, G as GatedStepOptions, u as Err, H as Workflow, q as AnyResultFn, I as WorkflowOptions, s as ErrorsOfDeps, R as Result, J as SnapshotStore, g as RunStep, t as WorkflowContext, K as ResumeStateEntry, L as StreamStore, M as StreamReader } from './types-B8NfNRGX.js';
-export { B as BackoffStrategy, N as CausesOfDeps, Q as ExecutionOptions, U as JSONValue, V as MemoryCacheOptions, a as RetryOptions, X as RunConfig, d as RunOptions, e as RunOptionsWithCatch, f as RunOptionsWithoutCatch, Y as RunWithStateResult, h as STEP_TIMEOUT_MARKER, Z as STREAM_BACKPRESSURE_ERROR, _ as STREAM_CLOSE_ERROR, $ as STREAM_ENDED, a0 as STREAM_READ_ERROR, a1 as STREAM_STORE_ERROR, a2 as STREAM_WRITE_ERROR, i as ScopeType, a3 as SerializedCause, a4 as SnapshotDecodeError, a5 as SnapshotFormatError, a6 as SnapshotMismatchError, a7 as SnapshotWarning, a8 as StepCache, a9 as StepErrorDiagnostics, aa as StepMetadata, S as StepOptions, k as StepTimeoutError, l as StepTimeoutMarkerMeta, ab as StreamBackpressureError, ac as StreamCloseError, ad as StreamEndedMarker, ae as StreamError, af as StreamForEachOptions, ag as StreamForEachResult, ah as StreamItem, ai as StreamMetadata, aj as StreamOptions, ak as StreamReadError, al as StreamReadOptions, am as StreamStoreError, an as StreamWriteError, ao as StreamWriter, T as TimeoutOptions, ap as Unsubscribe, aq as WorkflowFn, ar as WorkflowSteps, as as assertValidSnapshot, at as createMemoryCache, au as deserializeCauseNew, n as getStepTimeoutMeta, p as isStepTimeoutError, av as isStreamBackpressureError, aw as isStreamEnded, ax as isStreamReadError, ay as isStreamStoreError, az as isStreamWriteError, aA as isWorkflowSnapshot, aB as looksLikeWorkflowSnapshot, aC as mergeSnapshots, r as run, aD as serializeError, aE as serializeThrown, aF as streamBackpressureError, aG as streamCloseError, aH as streamEnded, aI as streamReadError, aJ as streamStoreError, aK as streamWriteError, aL as validateSnapshot } from './types-B8NfNRGX.js';
-import { U as UnexpectedError } from './errors-DtXvrCiO.js';
-export { D as Duration, D as DurationType, d as days, i as hours, k as isDuration, r as millis, t as minutes, w as seconds, y as toDays, z as toHours, A as toMillis, B as toMinutes, C as toSeconds, E as withDeps } from './di-BbFFfO8y.js';
+import { q as Err, R as Result, A as AsyncResult } from './index-Cv4K_3sZ.js';
+export { B as BackoffStrategy, d as RetryOptions, e as RunOptions, f as RunOptionsWithCatch, g as RunOptionsWithoutCatch, a as RunStep, S as STEP_TIMEOUT_MARKER, h as ScopeType, t as StepErrorDiagnostics, u as StepMetadata, j as StepOptions, k as StepTimeoutError, l as StepTimeoutMarkerMeta, T as TimeoutOptions, W as WorkflowEvent, n as getStepTimeoutMeta, p as isStepTimeoutError, r as run } from './index-Cv4K_3sZ.js';
+import { g as PendingHook, W as Workflow, c as AnyResultFn, f as WorkflowOptions, E as ErrorsOfDeps } from './types-BDTxgKKc.js';
+export { C as CausesOfDeps, i as ExecutionOptions, J as JSONValue, R as ResumeState, j as ResumeStateEntry, k as RunConfig, l as RunWithStateResult, m as SerializedCause, n as SnapshotDecodeError, o as SnapshotFormatError, p as SnapshotMismatchError, q as SnapshotWarning, r as StepCache, h as StepResult, e as WorkflowCancelledError, d as WorkflowContext, s as WorkflowFn, b as WorkflowSnapshot, t as WorkflowSteps, u as assertValidSnapshot, v as isWorkflowSnapshot, w as looksLikeWorkflowSnapshot, x as mergeSnapshots, y as validateSnapshot } from './types-BDTxgKKc.js';
+export { i as isApprovalRejected, a as isPendingApproval, b as isPendingHook, c as isResumeState, d as isStepComplete, e as isWorkflowCancelled } from './guards-CwQZro1F.js';
+export { P as PersistedWorkflowState, S as SerializedResumeState, a as StoreLoadResult, b as StoreSaveInput, d as deserializeResumeState, i as isSerializedResumeState, s as serializeResumeState, t as toResumeState } from './store-contract-BI98VYmX.js';
+export { c as clearStep, a as createApprovalStateCollector, b as createApprovalStep, e as createResumeStateCollector, g as gatedStep, d as getPendingApprovals, f as getPendingHooks, h as hasPendingApproval, j as hasPendingHook, i as injectApproval, k as injectHook, p as pendingApproval } from './hitl-pYfkQMv_.js';
+import { U as UnexpectedError } from './errors-sDSeaZBO.js';
+export { w as withDeps } from './di-DxyH2N3i.js';
 import { StandardSchemaV1 } from '@standard-schema/spec';
-
-/**
- * Type guards for workflow events and errors.
- */
-
-/**
- * Type guard to check if an event is a step_complete event.
- * Use this to filter events for state persistence.
- *
- * @param event - The workflow event to check
- * @returns `true` if the event is a step_complete event, `false` otherwise
- *
- * @example
- * ```typescript
- * const savedSteps = new Map<string, Result<unknown, unknown>>();
- *
- * const workflow = createWorkflow({ fetchUser }, {
- *   onEvent: (event) => {
- *     if (isStepComplete(event)) {
- *       savedSteps.set(event.stepKey, event.result);
- *     }
- *   }
- * });
- * ```
- */
-/**
- * Type guard for runtime ResumeState (steps is a Map). Use to discriminate from WorkflowSnapshot when loading.
- */
-declare function isResumeState(x: unknown): x is ResumeState;
-declare function isStepComplete(event: WorkflowEvent<unknown>): event is Extract<WorkflowEvent<unknown>, {
-    type: "step_complete";
-}>;
-/**
- * Type guard to check if an error is a WorkflowCancelledError.
- *
- * @param error - The error to check
- * @returns `true` if the error is a WorkflowCancelledError, `false` otherwise
- */
-declare function isWorkflowCancelled(error: unknown): error is WorkflowCancelledError;
-/**
- * Type guard to check if an error is a PendingApproval.
- *
- * @param error - The error to check
- * @returns `true` if the error is a PendingApproval, `false` otherwise
- *
- * @example
- * ```typescript
- * const result = await workflow(...);
- * if (!result.ok && isPendingApproval(result.error)) {
- *   console.log(`Waiting for approval: ${result.error.stepKey}`);
- * }
- * ```
- */
-declare function isPendingApproval(error: unknown): error is PendingApproval;
-/**
- * Type guard to check if an error is an ApprovalRejected.
- *
- * @param error - The error to check
- * @returns `true` if the error is an ApprovalRejected, `false` otherwise
- */
-declare function isApprovalRejected(error: unknown): error is ApprovalRejected;
-/**
- * Type guard to check if an error is a PendingHook.
- *
- * @param error - The error to check
- * @returns `true` if the error is a PendingHook, `false` otherwise
- */
-declare function isPendingHook(error: unknown): error is PendingHook;
-
-/**
- * Serialization for ResumeState to/from JSON-safe format.
- * Centralizes Map serialization so adapters don't re-implement it.
- */
-
-/**
- * JSON-serializable resume state. Use this shape when persisting to storage.
- * Discriminator `kind: "ResumeState"` enables adapters and migrations to detect format.
- */
-type SerializedResumeState = {
-    kind: "ResumeState";
-    steps: [string, StepResult][];
-};
-/**
- * Serialize resume state to a JSON-safe object. Preserves step order (array).
- * Use with JSON.stringify for storage; adapters can rely on this shape.
- *
- * @example
- * const serialized = serializeResumeState(collector.getResumeState());
- * await store.save(id, JSON.stringify(serialized));
- */
-declare function serializeResumeState(state: ResumeState): SerializedResumeState;
-/**
- * Type guard for SerializedResumeState. Use when loading from storage to discriminate from WorkflowSnapshot.
- */
-declare function isSerializedResumeState(x: unknown): x is SerializedResumeState;
-/**
- * Deserialize from JSON-parsed object back to ResumeState (runtime Map).
- *
- * @example
- * const parsed = JSON.parse(await store.load(id));
- * if (isSerializedResumeState(parsed)) {
- *   const state = deserializeResumeState(parsed);
- *   await workflow.run(fn, { resumeState: state });
- * }
- */
-declare function deserializeResumeState(raw: SerializedResumeState): ResumeState;
-
-/**
- * Extended persistence contract: save/load accept both WorkflowSnapshot and ResumeState.
- * Use type guards (isWorkflowSnapshot, isResumeState, isSerializedResumeState) in adapters.
- * Core persistence.SnapshotStore stays narrow; this module defines the broad contract and helpers.
- */
-
-/** What stores persist (JSON/database shape). Use for type discrimination in adapters. */
-type PersistedWorkflowState = WorkflowSnapshot | SerializedResumeState;
-/** What save() can accept: snapshot or runtime resume state. Adapters branch with type guards. */
-type StoreSaveInput = WorkflowSnapshot | ResumeState;
-/** What load() can return. Use toResumeState() or loadResumeState for type-safe restore. */
-type StoreLoadResult = WorkflowSnapshot | ResumeState | null;
-/**
- * Convert a loaded value to ResumeState for workflow.run(fn, { resumeState }).
- * - If loaded is already ResumeState, returns it.
- * - If loaded is null or WorkflowSnapshot, returns undefined (use run(fn, { snapshot }) for snapshots).
- * Two explicit flows: resume from ResumeState vs resume from snapshot; don't pass snapshot to resumeState.
- *
- * @example
- * const loaded = await store.load('wf-123');
- * const resumeState = toResumeState(loaded);
- * if (resumeState) await workflow.run(fn, { resumeState });
- */
-declare function toResumeState(loaded: StoreLoadResult): ResumeState | undefined;
-
-/**
- * Resume state helpers: collectors and state manipulation for workflow replay.
- */
-
-/**
- * Create a collector for step results to build resume state.
- *
- * ## When to Use
- *
- * Use `createResumeStateCollector` when you need to:
- * - **Save workflow state** for later replay/resume
- * - **Persist step results** to a database or file system
- * - **Build resume state** from workflow execution
- * - **Enable workflow replay** after application restarts
- *
- * ## Why Use This Instead of Manual Collection
- *
- * - **Automatic filtering**: Only collects `step_complete` events (ignores other events)
- * - **Metadata preservation**: Captures both result and meta for proper error replay
- * - **Type-safe**: Returns properly typed `ResumeState`
- * - **Convenient API**: Simple `handleEvent` → `getResumeState` pattern
- *
- * ## How It Works
- *
- * 1. Create collector and pass `handleEvent` to workflow's `onEvent` option
- * 2. Workflow emits `step_complete` events for keyed steps
- * 3. Collector automatically captures these events
- * 4. Call `getResumeState()` to get the collected `ResumeState`
- * 5. Persist state (e.g., to database) for later resume
- *
- * ## When step_complete Events Are Emitted
- *
- * Events are emitted for ANY step that has a `key` option, regardless of calling pattern:
- *
- * ```typescript
- * // Function-wrapped pattern - emits step_complete
- * await step(() => fetchUser("1"), { key: "user:1" });
- *
- * // Direct AsyncResult pattern - also emits step_complete
- * await step(fetchUser("1"), { key: "user:1" });
- * ```
- *
- * Both patterns above will emit `step_complete` events and be captured by the collector.
- *
- * ## Important Notes
- *
- * - Only steps with a `key` option are collected (unkeyed steps are not saved)
- * - The collector preserves error metadata for proper replay behavior
- * - State can be serialized to JSON (but complex cause types may need custom handling)
- *
- * @returns An object with:
- *   - `handleEvent`: Function to pass to workflow's `onEvent` option
- *   - `getResumeState`: Get collected resume state (call after workflow execution)
- *   - `clear`: Clears the collector's internal recorded entries (does not mutate workflow state)
- *
- * @example
- * ```typescript
- * // Collect state during workflow execution
- * const collector = createResumeStateCollector();
- *
- * const workflow = createWorkflow({ fetchUser, fetchPosts }, {
- *   onEvent: collector.handleEvent, // Pass collector's handler
- * });
- *
- * await workflow(async ({ step }) => {
- *   // Only keyed steps are collected
- *   const user = await step(() => fetchUser("1"), { key: "user:1" });
- *   const posts = await step(() => fetchPosts(user.id), { key: `posts:${user.id}` });
- *   return { user, posts };
- * });
- *
- * // Get collected state for persistence
- * const state = collector.getResumeState();
- * // state.steps contains: 'user:1' and 'posts:1' entries
- *
- * // Save to database
- * await db.saveWorkflowState(workflowId, state);
- * ```
- *
- * @example
- * ```typescript
- * // Resume workflow from saved state
- * const savedState = await db.loadWorkflowState(workflowId);
- * const workflow = createWorkflow({ fetchUser, fetchPosts }, {
- *   resumeState: savedState // Pre-populate cache from saved state
- * });
- *
- * // Cached steps skip execution, new steps run normally
- * await workflow(async ({ step }) => {
- *   const user = await step(() => fetchUser("1"), { key: "user:1" }); // Cache hit
- *   const posts = await step(() => fetchPosts(user.id), { key: `posts:${user.id}` }); // Cache hit
- *   return { user, posts };
- * });
- * ```
- */
-declare function createResumeStateCollector(): {
-    /** Handle workflow events. Pass this to workflow's `onEvent` option. */
-    handleEvent: (event: WorkflowEvent<unknown>) => void;
-    /** Get the collected resume state. Call after workflow execution. */
-    getResumeState: () => ResumeState;
-    /** Clears the collector's internal recorded entries (does not mutate workflow state). */
-    clear: () => void;
-};
-/**
- * Inject an approved value into resume state.
- * Use this when an external approval is granted and you want to resume the workflow.
- *
- * @param state - The resume state to update
- * @param options - Object with stepKey and the approved value
- * @returns A new ResumeState with the approval injected
- *
- * @example
- * ```typescript
- * // When approval is granted externally:
- * const updatedState = injectApproval(savedState, {
- *   stepKey: 'deploy:prod',
- *   value: { approvedBy: 'admin', approvedAt: Date.now() }
- * });
- *
- * // Resume workflow with the approval injected
- * const workflow = createWorkflow({ ... }, { resumeState: updatedState });
- * ```
- */
-declare function injectApproval<T>(state: ResumeState, options: {
-    stepKey: string;
-    value: T;
-}): ResumeState;
-/**
- * Remove a step from resume state (e.g., to force re-execution).
- * This is an immutable operation - returns a new ResumeState without modifying the original.
- *
- * @param state - The resume state to update
- * @param stepKey - The key of the step to remove
- * @returns A new ResumeState with the step removed (original is unchanged)
- *
- * @example
- * ```typescript
- * // Force a step to re-execute on resume
- * const updatedState = clearStep(savedState, 'approval:123');
- * ```
- */
-declare function clearStep(state: ResumeState, stepKey: string): ResumeState;
-/**
- * Check if a step in resume state has a pending approval error.
- *
- * @param state - The resume state to check
- * @param stepKey - The key of the step to check
- * @returns `true` if the step has a pending approval, `false` otherwise
- *
- * @example
- * ```typescript
- * if (hasPendingApproval(savedState, 'deploy:prod')) {
- *   // Show approval UI
- * }
- * ```
- */
-declare function hasPendingApproval(state: ResumeState, stepKey: string): boolean;
-/**
- * Get all pending approval step keys from resume state.
- *
- * @param state - The resume state to check
- * @returns Array of step keys that have pending approvals
- *
- * @example
- * ```typescript
- * const pendingKeys = getPendingApprovals(savedState);
- * // ['deploy:prod', 'deploy:staging']
- * ```
- */
-declare function getPendingApprovals(state: ResumeState): string[];
-/**
- * Inject a hook callback value into resume state.
- * Call this when the app receives the HTTP callback (e.g. POST /hook/:hookId) and pass the request body as value.
- *
- * @param state - The resume state to update
- * @param options - hookId (from the callback URL) and value (e.g. request body)
- * @returns A new ResumeState with the hook step set to ok(value)
- */
-declare function injectHook<T>(state: ResumeState, options: {
-    hookId: string;
-    value: T;
-}): ResumeState;
-/**
- * Check if a step in resume state has a pending hook error.
- *
- * @param state - The resume state to check
- * @param hookId - The hook id (from createHook() or the callback URL)
- * @returns `true` if that hook step is pending, `false` otherwise
- */
-declare function hasPendingHook(state: ResumeState, hookId: string): boolean;
-/**
- * Get all pending hook hookIds from resume state.
- *
- * @param state - The resume state to check
- * @returns Array of hookIds that have pending callbacks
- */
-declare function getPendingHooks(state: ResumeState): string[];
-/**
- * Extended resume state collector that tracks pending approvals.
- * Use this for human-in-the-loop workflows that need to track approval state.
- *
- * @returns An object with methods to handle events, get state, and manage approvals
- *
- * @example
- * ```typescript
- * const collector = createApprovalStateCollector();
- *
- * const workflow = createWorkflow({ fetchUser, requireApproval }, {
- *   onEvent: collector.handleEvent,
- * });
- *
- * const result = await workflow(async ({ step }) => {
- *   const user = await step(() => fetchUser("1"), { key: "user:1" });
- *   const approval = await step(requireApproval, { key: "approval:1" });
- *   return { user, approval };
- * });
- *
- * // Check for pending approvals
- * if (collector.hasPendingApprovals()) {
- *   const pending = collector.getPendingApprovals();
- *   // pending: [{ stepKey: 'approval:1', error: PendingApproval }]
- *   await saveToDatabase(collector.getResumeState());
- * }
- *
- * // Later, when approved:
- * const resumeState = collector.injectApproval('approval:1', { approvedBy: 'admin' });
- * ```
- */
-declare function createApprovalStateCollector(): {
-    /** Handle workflow events. Pass this to workflow's `onEvent` option. */
-    handleEvent: (event: WorkflowEvent<unknown>) => void;
-    /** Get the collected resume state. Call after workflow execution. */
-    getResumeState: () => ResumeState;
-    /** Clears the collector's internal recorded entries (does not mutate workflow state). */
-    clear: () => void;
-    /** Check if any steps have pending approvals */
-    hasPendingApprovals: () => boolean;
-    /** Get all pending approval entries with their errors */
-    getPendingApprovals: () => Array<{
-        stepKey: string;
-        error: PendingApproval;
-    }>;
-    /** Inject an approval result, updating the collector's internal state. Returns a copy for use as resumeState. */
-    injectApproval: <T>(stepKey: string, value: T) => ResumeState;
-};
-
-/**
- * Human-in-the-Loop (HITL) helpers: pendingApproval, createApprovalStep, gatedStep.
- */
-
-/**
- * Create a PendingApproval error result.
- * Convenience helper for approval-gated steps.
- *
- * @param stepKey - Stable key for this approval step (used for resume)
- * @param options - Optional reason and metadata for the pending approval
- * @returns A Result with a PendingApproval error
- *
- * @example
- * ```typescript
- * const requireApproval = async (userId: string) => {
- *   const status = await db.getApproval(userId);
- *   if (!status) return pendingApproval(`approval:${userId}`);
- *   return ok(status);
- * };
- * ```
- */
-declare function pendingApproval(stepKey: string, options?: {
-    reason?: string;
-    metadata?: Record<string, unknown>;
-}): Err<PendingApproval>;
-/**
- * Create a Result-returning function that checks external approval status.
- *
- * ## When to Use
- *
- * Use `createApprovalStep` when you need:
- * - **Human-in-the-loop workflows**: Steps that require human approval
- * - **External approval systems**: Integrate with approval databases/APIs
- * - **Workflow pausing**: Workflows that pause and resume after approval
- * - **Approval tracking**: Track who approved what and when
- *
- * ## Why Use This Instead of Manual Approval Checks
- *
- * - **Standardized pattern**: Consistent approval step interface
- * - **Type-safe**: Returns typed `PendingApproval` or `ApprovalRejected` errors
- * - **Resume-friendly**: Works seamlessly with `injectApproval()` and resume state
- * - **Metadata support**: Can include approval reason and metadata
- *
- * ## How It Works
- *
- * 1. Create approval step with `checkApproval` function
- * 2. `checkApproval` returns one of:
- *    - `{ status: 'pending' }` - Approval not yet granted (workflow pauses)
- *    - `{ status: 'approved', value: T }` - Approval granted (workflow continues)
- *    - `{ status: 'rejected', reason: string }` - Approval rejected (workflow fails)
- * 3. Use in workflow with `step()` - workflow pauses if pending
- * 4. When approval granted externally, use `injectApproval()` to resume
- *
- * ## Typical Approval Flow
- *
- * 1. Workflow executes → reaches approval step
- * 2. `checkApproval()` called → returns `{ status: 'pending' }`
- * 3. Workflow returns `PendingApproval` error
- * 4. Save workflow state → persist for later resume
- * 5. Show approval UI → user sees pending approval
- * 6. User grants/rejects → update approval system
- * 7. Inject approval → call `injectApproval()` with approved value
- * 8. Resume workflow → continue from approval step
- *
- * @param options - Configuration for the approval step:
- *   - `key`: Stable key for this approval (must match step key in workflow)
- *   - `checkApproval`: Async function that checks current approval status
- *   - `pendingReason`: Optional reason shown when approval is pending
- *   - `metadata`: Optional metadata attached to the approval request
- *
- * @returns A function that returns an AsyncResult checking approval status.
- *          The function can be used directly with `step()` in workflows.
- *
- * @example
- * ```typescript
- * // Create approval step that checks database
- * const requireManagerApproval = createApprovalStep<{ approvedBy: string }>({
- *   key: 'manager-approval',
- *   checkApproval: async () => {
- *     const approval = await db.getApproval('manager-approval');
- *     if (!approval) {
- *       return { status: 'pending' }; // Workflow pauses here
- *     }
- *     if (approval.rejected) {
- *       return { status: 'rejected', reason: approval.reason };
- *     }
- *     return {
- *       status: 'approved',
- *       value: { approvedBy: approval.approvedBy }
- *     };
- *   },
- *   pendingReason: 'Waiting for manager approval',
- * });
- *
- * // Use in workflow
- * const workflow = createWorkflow({ requireManagerApproval });
- * const result = await workflow(async ({ step }) => {
- *   const approval = await step(requireManagerApproval, { key: 'manager-approval' });
- *   // If pending, workflow exits with PendingApproval error
- *   // If approved, continues with approval value
- *   return approval;
- * });
- *
- * // Handle pending state
- * if (!result.ok && isPendingApproval(result.error)) {
- *   // Workflow paused - show approval UI
- *   showApprovalUI(result.error.stepKey);
- * }
- * ```
- *
- * @example
- * ```typescript
- * // With approval injection for resume
- * const collector = createApprovalStateCollector();
- * const workflow = createWorkflow({ requireApproval }, {
- *   onEvent: collector.handleEvent,
- * });
- *
- * const result = await workflow(async ({ step }) => {
- *   const approval = await step(requireApproval, { key: 'approval:1' });
- *   return approval;
- * });
- *
- * // When approval granted externally
- * if (collector.hasPendingApprovals()) {
- *   const resumeState = collector.injectApproval('approval:1', {
- *     approvedBy: 'admin@example.com'
- *   });
- *
- *   // Resume workflow
- *   const workflow2 = createWorkflow({ requireApproval }, { resumeState });
- *   const result2 = await workflow2(async ({ step }) => {
- *     const approval = await step(requireApproval, { key: 'approval:1' });
- *     return approval; // Now succeeds with injected value
- *   });
- * }
- * ```
- */
-declare function createApprovalStep<T>(options: ApprovalStepOptions<T>): () => AsyncResult<T, PendingApproval | ApprovalRejected>;
-/**
- * Create a gated step that requires approval before execution.
- *
- * This is the AI SDK / LangChain-style pattern where you intercept
- * tool calls *before* they execute, allowing humans to see the args
- * and approve, edit, or reject before the operation runs.
- *
- * ## When to Use
- *
- * Use `gatedStep` when you want to:
- * - **Show args before execution**: Let humans see what the operation will do
- * - **Allow editing args**: Humans can modify args before operation runs
- * - **Conditional gating**: Only require approval for certain conditions
- * - **AI safety**: Gate dangerous AI tool calls (send email, delete file, etc.)
- *
- * ## Difference from createApprovalStep
- *
- * - `createApprovalStep`: Checks external approval status, operation already defined
- * - `gatedStep`: Gates before operation, shows args, allows editing, then executes
- *
- * ## Flow
- *
- * 1. Call gatedStep with args
- * 2. Check if approval is required (based on requiresApproval condition)
- * 3. If required and not approved:
- *    - Return PendingApproval with args visible in metadata
- *    - Human sees: "Send email to external@example.com with subject X"
- *    - Human can approve (run as-is), edit (modify args), or reject
- * 4. If approved or not required:
- *    - Execute the operation with (potentially edited) args
- *
- * @param operation - The operation to gate (a function returning AsyncResult)
- * @param options - Gating configuration
- * @returns A gated function that checks approval before execution
- *
- * @example
- * ```typescript
- * // Gate external email sends
- * const sendEmail = async (to: string, subject: string, body: string) => { ... };
- *
- * const gatedSendEmail = gatedStep(
- *   sendEmail,
- *   {
- *     key: 'email',
- *     requiresApproval: (args) => !args.to.endsWith('@mycompany.com'),
- *     description: (args) => `Send email to ${args.to}: "${args.subject}"`,
- *   }
- * );
- *
- * // In workflow:
- * const result = await step(
- *   () => gatedSendEmail({ to: 'external@other.com', subject: 'Hello', body: '...' }),
- *   { key: 'send-welcome-email' }
- * );
- *
- * // If gated, returns PendingApproval with:
- * // {
- * //   stepKey: 'email',
- * //   reason: 'Send email to external@other.com: "Hello"',
- * //   metadata: { pendingArgs: { to: '...', subject: '...', body: '...' } }
- * // }
- * ```
- *
- * @example
- * ```typescript
- * // Gate file deletion with explicit approval check
- * const gatedDelete = gatedStep(
- *   (path: string) => deleteFile(path),
- *   {
- *     key: 'delete-file',
- *     requiresApproval: true, // Always require approval
- *     description: (args) => `Delete file: ${args.path}`,
- *     checkApproval: () => approvalStore.getApproval('delete-file'),
- *   }
- * );
- * ```
- */
-declare function gatedStep<TArgs extends Record<string, unknown>, T, E>(operation: (args: TArgs) => AsyncResult<T, E>, options: GatedStepOptions<TArgs, T>): (args: TArgs) => AsyncResult<T, E | PendingApproval | ApprovalRejected>;
+export { D as Duration, D as DurationType, d as days, i as hours, k as isDuration, r as millis, t as minutes, w as seconds, y as toDays, z as toHours, A as toMillis, B as toMinutes, C as toSeconds } from './duration-BjVn3QpB.js';
+import './types-sObbY4mX.js';
 
 /**
  * Hook primitive: suspend workflow until app receives HTTP callback, then resume via injectHook.
@@ -947,2429 +359,6 @@ interface WorkflowDiagramDSL {
     workflowReturnType?: string;
 }
 
-/**
- * awaitly/durable
- *
- * Durable execution with automatic state persistence.
- * Workflows automatically checkpoint after each keyed step and can resume from any point.
- */
-
-/**
- * Error returned when workflow cannot resume due to version mismatch.
- * Indicates the stored state was created with a different workflow version.
- * Fail-fast contract: bump version when you change step keys, order, or outputs.
- */
-type VersionMismatchError = {
-    type: "VERSION_MISMATCH";
-    /** Workflow execution ID */
-    workflowId: string;
-    /** Version stored in persisted state */
-    storedVersion: number;
-    /** Version requested by this run */
-    requestedVersion: number;
-    /** Guidance message with suggested actions */
-    message: string;
-    /** Use requestedVersion. */
-    currentVersion?: number;
-};
-/**
- * Error returned when workflow execution is rejected due to concurrent run.
- */
-type ConcurrentExecutionError = {
-    type: "CONCURRENT_EXECUTION";
-    /** The workflow ID that is already running */
-    workflowId: string;
-    /** Guidance message */
-    message: string;
-    /**
-     * Distinguishes in-process (activeWorkflows) from cross-process (lock held).
-     * Enables debuggability and branching without parsing the message.
-     */
-    reason?: "in-process" | "cross-process";
-};
-/**
- * Error returned when a persistence store operation fails.
- */
-type PersistenceError = {
-    type: "PERSISTENCE_ERROR";
-    /** The operation that failed */
-    operation: "load" | "save" | "delete";
-    /** The workflow ID */
-    workflowId: string;
-    /** The underlying error */
-    cause: unknown;
-    /** Guidance message */
-    message: string;
-};
-/**
- * Type guard to check if an error is a VersionMismatchError.
- */
-declare function isVersionMismatch(error: unknown): error is VersionMismatchError;
-/**
- * Type guard to check if an error is a ConcurrentExecutionError.
- */
-declare function isConcurrentExecution(error: unknown): error is ConcurrentExecutionError;
-/**
- * Type guard to check if an error is a PersistenceError.
- */
-declare function isPersistenceError(error: unknown): error is PersistenceError;
-/**
- * Error returned when a workflow's lease expires mid-execution.
- * Indicates the lock was lost and another process may have reclaimed the workflow.
- */
-type LeaseExpiredError = {
-    type: "LEASE_EXPIRED";
-    /** The workflow ID whose lease expired */
-    workflowId: string;
-    /** Guidance message */
-    message: string;
-};
-/**
- * Type guard to check if an error is a LeaseExpiredError.
- */
-declare function isLeaseExpired(error: unknown): error is LeaseExpiredError;
-/**
- * Error returned when an idempotency key is reused with different input.
- */
-type IdempotencyConflictError = {
-    type: "IDEMPOTENCY_CONFLICT";
-    idempotencyKey: string;
-    workflowId: string;
-    message: string;
-};
-declare function isIdempotencyConflict(error: unknown): error is IdempotencyConflictError;
-/**
- * Optional cross-process lock interface.
- * When a store implements this, durable.run uses it to ensure only one process
- * runs a given workflow ID at a time (when allowConcurrent is false).
- *
- * Uses a lease (TTL) + owner token so a crashed worker does not wedge a workflow
- * indefinitely. Release must verify the owner token so one process never
- * unlocks another's lease.
- *
- * Mid-run lock loss (e.g. lease expires during a long workflow) is handled
- * adapter-side; core assumes the lock is held until release in finally.
- * Adapters may implement heartbeats/renewal.
- */
-interface WorkflowLock {
-    /**
-     * Try to acquire a lease for the workflow ID.
-     * @param id - Workflow execution ID
-     * @param options - Optional TTL for the lease (adapter default if omitted)
-     * @returns Owner token if acquired, null if already held by another
-     */
-    tryAcquire(id: string, options?: {
-        ttlMs?: number;
-    }): Promise<{
-        ownerToken: string;
-    } | null>;
-    /**
-     * Release the lease. Must verify owner token; no-op or ignore if token
-     * does not match (e.g. lease already expired or taken by another).
-     */
-    release(id: string, ownerToken: string): Promise<void>;
-    /**
-     * Extend the lease for an already-held lock.
-     * Returns true if renewed, false if lost.
-     * Optional — when not implemented, no heartbeat runs.
-     */
-    renew?(id: string, ownerToken: string, options?: {
-        ttlMs?: number;
-    }): Promise<boolean>;
-}
-/**
- * Options for durable workflow execution.
- */
-interface DurableOptions<C = void> {
-    /**
-     * Unique workflow execution ID.
-     * Used as the key for state persistence.
-     *
-     * @example 'order-checkout-123', 'user-onboarding-abc'
-     */
-    id: string;
-    /**
-     * Snapshot store for persistence. Optional. When omitted, an in-memory store is used (per process).
-     * Same-process resume/retry works; state is lost on restart. Override with postgres/mongo/libsql for persistence.
-     *
-     * @example
-     * ```typescript
-     * // Zero-config: uses in-memory store (per process)
-     * await durable.run(deps, fn, { id: 'my-id' });
-     *
-     * // Override: pass a store for persistence across restarts
-     * import { postgres } from 'awaitly-postgres';
-     * const store = postgres('postgresql://localhost/mydb');
-     * await durable.run(deps, fn, { id: 'my-id', store });
-     * ```
-     */
-    store?: SnapshotStore;
-    /**
-     * Workflow logic version.
-     * If stored state has a different version, workflow will reject resume with VersionMismatchError
-     * unless onVersionMismatch is used to clear or migrate.
-     *
-     * Bump when you change step keys, reorder steps, or change step outputs in a way old checkpoints can't satisfy.
-     *
-     * @default 1
-     */
-    version?: number;
-    /**
-     * When stored state version differs from requested version, either throw (default), clear state and run from scratch, or supply migrated snapshot.
-     * Use for migration or one-off clear without wrapping durable.run.
-     *
-     * @default 'throw'
-     */
-    onVersionMismatch?: (ctx: {
-        id: string;
-        storedVersion: number;
-        requestedVersion: number;
-    }) => "throw" | "clear" | {
-        migratedSnapshot: WorkflowSnapshot;
-    } | Promise<"throw" | "clear" | {
-        migratedSnapshot: WorkflowSnapshot;
-    }>;
-    /**
-     * Allow concurrent executions with the same workflow ID.
-     * When `false` (default), a second run with the same ID will be rejected while one is active.
-     *
-     * @default false
-     */
-    allowConcurrent?: boolean;
-    /**
-     * Lease TTL in milliseconds for cross-process locking.
-     * Only used when the store implements WorkflowLock and allowConcurrent is false.
-     * A crashed worker's lease expires after this duration so the workflow can be picked up again.
-     *
-     * @default 60000 (1 minute)
-     */
-    lockTtlMs?: number;
-    /**
-     * Heartbeat interval for lease renewal (ms).
-     * Only active when store implements WorkflowLock with renew().
-     * @default lockTtlMs / 3
-     */
-    heartbeatIntervalMs?: number;
-    /**
-     * Whether to abort the workflow when lease is lost mid-execution.
-     * @default true
-     */
-    abortOnLeaseLoss?: boolean;
-    /**
-     * Metadata to store alongside workflow state.
-     * Useful for debugging, auditing, or filtering workflows.
-     *
-     * @example { userId: 'user-123', source: 'api' }
-     */
-    metadata?: Record<string, unknown>;
-    /**
-     * External AbortSignal for workflow-level cancellation.
-     * Cancellation persists state up to the last completed step.
-     */
-    signal?: AbortSignal;
-    /**
-     * Create per-run context for event correlation.
-     */
-    createContext?: () => C;
-    /**
-     * Unified event stream for workflow and step lifecycle.
-     * Includes durable-specific events: `persist_success` and `persist_error`.
-     */
-    onEvent?: (event: DurableWorkflowEvent<unknown, C>, ctx: C) => void;
-    /**
-     * Handler for expected and unexpected errors.
-     */
-    onError?: (error: unknown, stepName?: string, ctx?: C) => void;
-    /**
-     * Idempotency key for deduplication.
-     * If provided and a completed workflow with this key exists in the store,
-     * the stored result is returned without re-execution.
-     * If the stored input differs, an IdempotencyConflictError is returned.
-     */
-    idempotencyKey?: string;
-    /**
-     * Workflow input for idempotency conflict detection.
-     * When idempotencyKey is set, this is compared against stored input.
-     * Must be JSON-serializable.
-     */
-    input?: unknown;
-}
-/**
- * Extended workflow event type that includes durable-specific events.
- * E is the deps error type - the full error type includes E | UnexpectedError.
- */
-type DurableWorkflowEvent<E, C = void> = WorkflowEvent<E | UnexpectedError, C> | {
-    type: "persist_success";
-    workflowId: string;
-    stepKey: string;
-    ts: number;
-    context?: C;
-} | {
-    type: "persist_error";
-    workflowId: string;
-    stepKey: string;
-    error: unknown;
-    ts: number;
-    context?: C;
-};
-/**
- * Options for bulk delete of workflow state.
- */
-interface DeleteStatesOptions {
-    /**
-     * Max number of concurrent delete calls when store has no deleteMany.
-     * @default 10
-     */
-    concurrency?: number;
-    /**
-     * When true, collect errors and return them; when false, throw on first error.
-     * @default true
-     */
-    continueOnError?: boolean;
-}
-/**
- * Result of bulk delete of workflow state.
- */
-interface DeleteStatesResult {
-    /** Number of entries successfully deleted. */
-    deleted: number;
-    /** Per-id errors when continueOnError was true and some deletes failed. */
-    errors?: Array<{
-        id: string;
-        error: unknown;
-    }>;
-}
-/**
- * Durable workflow execution namespace.
- */
-declare const 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);
-     * }
-     * ```
-     */
-    run<const Deps extends Readonly<Record<string, AnyResultFn>>, T, C = void>(deps: Deps, fn: (context: {
-        step: RunStep<ErrorsOfDeps<Deps>>;
-        deps: Deps;
-        ctx: WorkflowContext<C>;
-    }) => T | Promise<T>, options: DurableOptions<C>): Promise<Result<T, ErrorsOfDeps<Deps> | UnexpectedError | WorkflowCancelledError | VersionMismatchError | ConcurrentExecutionError | PersistenceError | LeaseExpiredError | IdempotencyConflictError, unknown>>;
-    /**
-     * 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
-     */
-    clearState(store: SnapshotStore): Promise<void>;
-    /**
-     * 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)
-     */
-    hasState(store: SnapshotStore, id: string): Promise<boolean>;
-    /**
-     * 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
-     */
-    deleteState(store: SnapshotStore, id: string): Promise<boolean>;
-    /**
-     * 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
-     */
-    deleteStates(store: SnapshotStore, ids: string[], options?: DeleteStatesOptions): Promise<DeleteStatesResult>;
-    /**
-     * List workflow IDs with persisted state.
-     *
-     * @param store - Snapshot store
-     * @param options - Optional prefix and limit
-     * @returns Array of { id, updatedAt } entries
-     */
-    listPending(store: SnapshotStore, options?: {
-        prefix?: string;
-        limit?: number;
-    }): Promise<Array<{
-        id: string;
-        updatedAt: string;
-    }>>;
-};
-
-/**
- * Workflow Versioning and Migration
- *
- * Handle schema changes when resuming workflows that were persisted
- * with older step shapes.
- *
- * @example
- * ```typescript
- * import { createVersionedWorkflow } from 'awaitly';
- *
- * const workflow = createVersionedWorkflow(
- *   { fetchUser, chargeCard },
- *   {
- *     version: 2,
- *     migrations: {
- *       1: (state) => migrateV1ToV2(state),
- *     },
- *     resumeState: loadState(runId),
- *   }
- * );
- * ```
- */
-
-/**
- * Version number type.
- */
-type Version = number;
-/**
- * Migration function that transforms state from one version to the next.
- */
-type MigrationFn = (state: ResumeState) => ResumeState | Promise<ResumeState>;
-/**
- * Map of migrations keyed by the source version.
- * Migration at key N transforms state from version N to version N+1.
- */
-type Migrations = Record<Version, MigrationFn>;
-/**
- * Versioned state includes the version number.
- */
-interface VersionedState {
-    version: Version;
-    state: ResumeState;
-}
-/**
- * Configuration for versioned workflow.
- */
-interface VersionedWorkflowConfig {
-    /**
-     * Current workflow version.
-     */
-    version: Version;
-    /**
-     * Migrations for upgrading old states.
-     * Key is the source version, value transforms to next version.
-     */
-    migrations?: Migrations;
-    /**
-     * Strict mode - fail if state version is higher than current.
-     * @default true
-     */
-    strictVersioning?: boolean;
-}
-/**
- * Error when version migration fails.
- */
-interface MigrationError {
-    type: "MIGRATION_ERROR";
-    fromVersion: Version;
-    toVersion: Version;
-    cause: unknown;
-}
-/**
- * Error when state version is incompatible.
- */
-interface VersionIncompatibleError {
-    type: "VERSION_INCOMPATIBLE";
-    stateVersion: Version;
-    currentVersion: Version;
-    reason: string;
-}
-/**
- * Type guard for MigrationError.
- */
-declare function isMigrationError(error: unknown): error is MigrationError;
-/**
- * Type guard for VersionIncompatibleError.
- */
-declare function isVersionIncompatibleError(error: unknown): error is VersionIncompatibleError;
-/**
- * Create a versioned resume state loader.
- *
- * This wraps a state loader to automatically apply migrations
- * when loading older state versions.
- *
- * @param config - Versioning configuration
- * @returns A function that loads and migrates state
- *
- * @example
- * ```typescript
- * const loadVersionedState = createVersionedStateLoader({
- *   version: 3,
- *   migrations: {
- *     1: migrateV1ToV2,
- *     2: migrateV2ToV3,
- *   },
- * });
- *
- * // In workflow
- * const workflow = createWorkflow(deps, {
- *   resumeState: () => loadVersionedState(savedState),
- * });
- * ```
- */
-declare function createVersionedStateLoader(config: VersionedWorkflowConfig): (versionedState: VersionedState | null | undefined) => Promise<Result<ResumeState | undefined, MigrationError | VersionIncompatibleError>>;
-/**
- * Create versioned state from current resume state.
- *
- * Use this when saving state to storage.
- *
- * @param state - The current resume state
- * @param version - The current workflow version
- * @returns A versioned state object
- *
- * @example
- * ```typescript
- * const collector = createResumeStateCollector();
- * // ... run workflow ...
- *
- * const versionedState = createVersionedState(collector.getResumeState(), 2);
- * await db.saveWorkflowState(workflowId, versionedState);
- * ```
- */
-declare function createVersionedState(state: ResumeState, version: Version): VersionedState;
-/**
- * Parse versioned state from JSON.
- *
- * Handles the serialization/deserialization of ResumeState with Map.
- *
- * @param json - The JSON string or parsed object
- * @returns The versioned state or null if invalid
- *
- * @example
- * ```typescript
- * const json = await db.loadWorkflowState(workflowId);
- * const versionedState = parseVersionedState(json);
- * if (versionedState) {
- *   const loader = createVersionedStateLoader(config);
- *   const state = await loader(versionedState);
- * }
- * ```
- */
-interface SerializedVersionedState {
-    version: number;
-    state: {
-        steps: Array<[string, ResumeStateEntry]>;
-    };
-}
-declare function parseVersionedState(json: string | SerializedVersionedState | null | undefined): VersionedState | null;
-/**
- * Serialize versioned state to JSON.
- *
- * Converts the Map to an array for JSON serialization.
- *
- * @param state - The versioned state
- * @returns JSON string
- *
- * @example
- * ```typescript
- * const json = stringifyVersionedState(versionedState);
- * await db.saveWorkflowState(workflowId, json);
- * ```
- */
-declare function stringifyVersionedState(state: VersionedState): string;
-/**
- * Create a migration that renames step keys.
- *
- * @param renames - Map of old key to new key
- * @returns A migration function
- *
- * @example
- * ```typescript
- * const migrations = {
- *   1: createKeyRenameMigration({
- *     'user:fetch': 'user:load',
- *     'order:create': 'order:submit',
- *   }),
- * };
- * ```
- */
-declare function createKeyRenameMigration(renames: Record<string, string>): MigrationFn;
-/**
- * Create a migration that removes specific step keys.
- *
- * @param keysToRemove - Array of keys to remove
- * @returns A migration function
- *
- * @example
- * ```typescript
- * const migrations = {
- *   1: createKeyRemoveMigration(['deprecated:step', 'old:cache']),
- * };
- * ```
- */
-declare function createKeyRemoveMigration(keysToRemove: string[]): MigrationFn;
-/**
- * Create a migration that transforms step values.
- *
- * @param transforms - Map of key to transform function
- * @returns A migration function
- *
- * @example
- * ```typescript
- * const migrations = {
- *   1: createValueTransformMigration({
- *     'user:fetch': (entry) => ({
- *       ...entry,
- *       result: entry.result.ok
- *         ? ok({ ...entry.result.value, newField: 'default' })
- *         : entry.result,
- *     }),
- *   }),
- * };
- * ```
- */
-declare function createValueTransformMigration(transforms: Record<string, (entry: ResumeStateEntry) => ResumeStateEntry>): MigrationFn;
-/**
- * Compose multiple migrations into a single migration.
- *
- * @param migrations - Array of migration functions
- * @returns A single migration function that applies all migrations in order
- *
- * @example
- * ```typescript
- * const migrations = {
- *   1: composeMigrations([
- *     createKeyRenameMigration({ 'old': 'new' }),
- *     createKeyRemoveMigration(['deprecated']),
- *   ]),
- * };
- * ```
- */
-declare function composeMigrations(migrations: MigrationFn[]): MigrationFn;
-
-/**
- * awaitly/hitl
- *
- * Human-in-the-Loop Orchestration Helpers.
- * Provides pollers, webhook handlers, and resume injectors
- * for production-ready approval workflows.
- */
-
-/**
- * Options passed to the workflow factory by the HITL orchestrator.
- */
-interface HITLWorkflowFactoryOptions {
-    /** Resume state for replaying completed steps */
-    resumeState?: ResumeState;
-    /** Event handler for tracking workflow events (required for HITL) */
-    onEvent: (event: WorkflowEvent<unknown>) => void;
-}
-/**
- * Approval status returned from the approval store.
- */
-type ApprovalStatus<T = unknown> = {
-    status: "pending";
-} | {
-    status: "approved";
-    value: T;
-    approvedBy?: string;
-    approvedAt?: number;
-} | {
-    status: "rejected";
-    reason: string;
-    rejectedBy?: string;
-    rejectedAt?: number;
-} | {
-    status: "expired";
-    expiredAt: number;
-} | {
-    status: "edited";
-    originalValue: T;
-    editedValue: T;
-    editedBy?: string;
-    editedAt?: number;
-};
-/**
- * Context passed to notification channel when an approval is needed.
- */
-interface ApprovalNeededContext {
-    /** Unique approval key for correlation */
-    approvalKey: string;
-    /** Workflow run ID */
-    runId: string;
-    /** Workflow name/type */
-    workflowName: string;
-    /** Human-readable reason for the approval */
-    reason?: string;
-    /** Custom metadata attached to the approval */
-    metadata?: Record<string, unknown>;
-    /** When the approval expires (timestamp) */
-    expiresAt?: number;
-    /** Human-readable summary for notifications */
-    summary?: string;
-    /** For gated steps: the operation args that need approval */
-    pendingArgs?: Record<string, unknown>;
-}
-/**
- * Context passed to notification channel when an approval is resolved.
- */
-interface ApprovalResolvedContext {
-    /** Unique approval key */
-    approvalKey: string;
-    /** Resolution action */
-    action: "approved" | "rejected" | "edited" | "expired" | "cancelled";
-    /** Who performed the action (if available) */
-    actorId?: string;
-    /** Timestamp of resolution */
-    resolvedAt: number;
-    /** Reason (for rejections) */
-    reason?: string;
-    /** Value (for approvals/edits) */
-    value?: unknown;
-    /** Original value (for edits) */
-    originalValue?: unknown;
-}
-/**
- * Notification channel for external integrations (Slack, email, etc).
- * Implement this interface to receive push notifications when approvals
- * are created or resolved.
- */
-interface NotificationChannel {
-    /**
-     * Called when a new approval request is created.
-     * Use this to send Slack messages, emails, or push to a UI.
-     */
-    onApprovalNeeded(context: ApprovalNeededContext): Promise<void>;
-    /**
-     * Called when an approval is granted, rejected, edited, or expires.
-     * Use this to update Slack messages, send confirmation emails, etc.
-     */
-    onApprovalResolved?(context: ApprovalResolvedContext): Promise<void>;
-}
-/**
- * Interface for approval storage backends.
- */
-interface ApprovalStore {
-    /**
-     * Get the status of an approval.
-     */
-    getApproval(key: string): Promise<ApprovalStatus>;
-    /**
-     * Create or update a pending approval request.
-     */
-    createApproval(key: string, options?: {
-        metadata?: Record<string, unknown>;
-        expiresAt?: number;
-        requestedBy?: string;
-    }): Promise<void>;
-    /**
-     * Grant an approval.
-     */
-    grantApproval<T>(key: string, value: T, options?: {
-        approvedBy?: string;
-    }): Promise<void>;
-    /**
-     * Reject an approval.
-     */
-    rejectApproval(key: string, reason: string, options?: {
-        rejectedBy?: string;
-    }): Promise<void>;
-    /**
-     * Edit an approval (approve with modifications).
-     * Records both the original proposed value and the edited value.
-     */
-    editApproval<T>(key: string, originalValue: T, editedValue: T, options?: {
-        editedBy?: string;
-    }): Promise<void>;
-    /**
-     * Cancel a pending approval.
-     */
-    cancelApproval(key: string): Promise<void>;
-    /**
-     * List all pending approvals.
-     */
-    listPending(options?: {
-        prefix?: string;
-    }): Promise<string[]>;
-}
-/**
- * Saved workflow state for resumption.
- */
-interface SavedWorkflowState {
-    /** Unique identifier for this workflow run */
-    runId: string;
-    /** Workflow name/type */
-    workflowName: string;
-    /** Resume state with step results */
-    resumeState: ResumeState;
-    /** Pending approval keys */
-    pendingApprovals: string[];
-    /** Input that was passed to the workflow */
-    input?: unknown;
-    /** Custom metadata */
-    metadata?: Record<string, unknown>;
-    /** When the workflow was started */
-    startedAt: number;
-    /** When the state was last updated */
-    updatedAt: number;
-}
-/**
- * Interface for workflow state storage.
- */
-interface WorkflowStateStore {
-    /**
-     * Save workflow state.
-     */
-    save(state: SavedWorkflowState): Promise<void>;
-    /**
-     * Load workflow state by run ID.
-     */
-    load(runId: string): Promise<SavedWorkflowState | undefined>;
-    /**
-     * Delete workflow state.
-     */
-    delete(runId: string): Promise<void>;
-    /**
-     * List all saved workflow states.
-     */
-    list(options?: {
-        workflowName?: string;
-        hasPendingApprovals?: boolean;
-    }): Promise<string[]>;
-    /**
-     * Find workflows waiting for a specific approval.
-     */
-    findByPendingApproval(approvalKey: string): Promise<string[]>;
-}
-/**
- * Options for the HITL orchestrator.
- */
-interface HITLOrchestratorOptions {
-    /** Approval store for managing approval states */
-    approvalStore: ApprovalStore;
-    /** Workflow state store for persisting workflow state */
-    workflowStateStore: WorkflowStateStore;
-    /** Default expiration time for approvals (in milliseconds) */
-    defaultExpirationMs?: number;
-    /** Logger function */
-    logger?: (message: string) => void;
-    /**
-     * Notification channel for external integrations.
-     * When provided, the orchestrator will call onApprovalNeeded when
-     * an approval is created, and onApprovalResolved when resolved.
-     */
-    notificationChannel?: NotificationChannel;
-}
-/**
- * Result of executing a workflow that may pause for approval.
- * Uses unknown for error type since workflows add UnexpectedError to the union.
- */
-type HITLExecutionResult<T, E> = {
-    status: "completed";
-    result: Result<T, E | unknown>;
-} | {
-    status: "paused";
-    runId: string;
-    pendingApprovals: string[];
-    reason?: string;
-} | {
-    status: "resumed";
-    runId: string;
-    result: Result<T, E | unknown>;
-};
-/**
- * Poller configuration.
- */
-interface PollerOptions {
-    /** Polling interval in milliseconds */
-    intervalMs: number;
-    /** Maximum number of polls (undefined = unlimited) */
-    maxPolls?: number;
-    /** Timeout for the entire polling operation */
-    timeoutMs?: number;
-    /** Callback when polling starts */
-    onPollStart?: () => void;
-    /** Callback when a poll completes */
-    onPollComplete?: (result: ApprovalStatus) => void;
-}
-/**
- * Create an in-memory approval store for development/testing.
- */
-declare function createMemoryApprovalStore(): ApprovalStore;
-/**
- * Create an in-memory workflow state store for development/testing.
- */
-declare function createMemoryWorkflowStateStore(): WorkflowStateStore;
-/**
- * HITL orchestrator interface.
- */
-interface HITLOrchestrator {
-    /**
-     * Execute a workflow that may pause for approvals.
-     * If the workflow pauses, state is automatically saved.
-     *
-     * The workflowFactory receives options including onEvent handler which MUST be
-     * passed to createWorkflow for HITL tracking to work.
-     */
-    execute<T, E, TInput>(workflowName: string, workflowFactory: (options: HITLWorkflowFactoryOptions) => Workflow<E, unknown>, workflowFn: (context: {
-        step: unknown;
-        deps: unknown;
-        args: TInput;
-    }) => Promise<T>, input: TInput, options?: {
-        runId?: string;
-        metadata?: Record<string, unknown>;
-    }): Promise<HITLExecutionResult<T, E>>;
-    /**
-     * Resume a paused workflow after approvals have been granted.
-     */
-    resume<T, E, TInput>(runId: string, workflowFactory: (options: HITLWorkflowFactoryOptions) => Workflow<E, unknown>, workflowFn: (context: {
-        step: unknown;
-        deps: unknown;
-        args: TInput;
-    }) => Promise<T>): Promise<HITLExecutionResult<T, E>>;
-    /**
-     * Grant an approval and automatically resume any waiting workflows.
-     */
-    grantApproval<T>(approvalKey: string, value: T, options?: {
-        approvedBy?: string;
-        autoResume?: boolean;
-    }): Promise<{
-        grantedAt: number;
-        resumedWorkflows: string[];
-    }>;
-    /**
-     * Reject an approval.
-     */
-    rejectApproval(approvalKey: string, reason: string, options?: {
-        rejectedBy?: string;
-    }): Promise<void>;
-    /**
-     * Edit an approval (approve with modifications).
-     * Use this when a human wants to approve but with changes to the proposed value.
-     * Records both the original and edited values for audit trail.
-     */
-    editApproval<T>(approvalKey: string, originalValue: T, editedValue: T, options?: {
-        editedBy?: string;
-    }): Promise<{
-        editedAt: number;
-    }>;
-    /**
-     * Poll for an approval to be granted.
-     */
-    pollApproval<T>(approvalKey: string, options?: PollerOptions): Promise<ApprovalStatus<T>>;
-    /**
-     * Get the status of a workflow run.
-     */
-    getWorkflowStatus(runId: string): Promise<SavedWorkflowState | undefined>;
-    /**
-     * List all pending workflows.
-     */
-    listPendingWorkflows(workflowName?: string): Promise<string[]>;
-    /**
-     * Clean up completed workflows older than the specified age.
-     */
-    cleanup(maxAgeMs: number): Promise<number>;
-}
-/**
- * Create a HITL orchestrator for managing approval workflows.
- *
- * @example
- * ```typescript
- * const orchestrator = createHITLOrchestrator({
- *   approvalStore: createMemoryApprovalStore(),
- *   workflowStateStore: createMemoryWorkflowStateStore(),
- * });
- *
- * // Execute workflow - IMPORTANT: pass onEvent to createWorkflow!
- * const result = await orchestrator.execute(
- *   'order-approval',
- *   ({ resumeState, onEvent }) => createWorkflow('order-approval', deps, { resumeState, onEvent }),
- *   async ({ step, deps, args: input }) => {
- *     const order = await step(() => deps.createOrder(input));
- *     const approval = await step(() => deps.requireApproval(order.id), { key: `approval:${order.id}` });
- *     await step(() => deps.processOrder(order.id));
- *     return { orderId: order.id, approvedBy: approval.approvedBy };
- *   },
- *   { items: [...], total: 100 }
- * );
- *
- * if (result.status === 'paused') {
- *   console.log(`Workflow paused, waiting for: ${result.pendingApprovals}`);
- * }
- *
- * // Later, grant approval
- * await orchestrator.grantApproval(
- *   `approval:${orderId}`,
- *   { approvedBy: 'manager@example.com' },
- *   { autoResume: true }
- * );
- * ```
- */
-declare function createHITLOrchestrator(options: HITLOrchestratorOptions): HITLOrchestrator;
-/**
- * Approval webhook request body.
- */
-interface ApprovalWebhookRequest {
-    /** Approval key */
-    key: string;
-    /** Action: approve, reject, edit, or cancel */
-    action: "approve" | "reject" | "edit" | "cancel";
-    /** Value to inject (for approve) */
-    value?: unknown;
-    /** Original value (for edit - what was proposed) */
-    originalValue?: unknown;
-    /** Edited value (for edit - what human changed it to) */
-    editedValue?: unknown;
-    /** Reason (for reject) */
-    reason?: string;
-    /** Who performed this action */
-    actorId?: string;
-}
-/**
- * Approval webhook response.
- */
-interface ApprovalWebhookResponse {
-    success: boolean;
-    message: string;
-    data?: {
-        key: string;
-        action: string;
-        timestamp: number;
-    };
-}
-/**
- * Create a webhook handler for approval actions.
- *
- * @example
- * ```typescript
- * const handleApproval = createApprovalWebhookHandler(approvalStore);
- *
- * // Express
- * app.post('/api/approvals', async (req, res) => {
- *   const result = await handleApproval(req.body);
- *   res.json(result);
- * });
- * ```
- */
-declare function createApprovalWebhookHandler(store: ApprovalStore): (request: ApprovalWebhookRequest) => Promise<ApprovalWebhookResponse>;
-/**
- * Create an approval checker function for use in approval steps.
- * This wraps the approval store with the standard checkApproval interface.
- *
- * @example
- * ```typescript
- * const checkApproval = createApprovalChecker(approvalStore);
- *
- * const requireManagerApproval = createApprovalStep<{ approvedBy: string }>({
- *   key: 'manager-approval',
- *   checkApproval: checkApproval('manager-approval'),
- *   pendingReason: 'Waiting for manager approval',
- * });
- * ```
- */
-declare function createApprovalChecker<T>(store: ApprovalStore): (key: string) => () => Promise<{
-    status: "pending";
-} | {
-    status: "approved";
-    value: T;
-} | {
-    status: "rejected";
-    reason: string;
-}>;
-
-/**
- * Saga / Compensation Pattern
- *
- * Compensation is a first-class step option on every workflow. Pass `{ compensate }`
- * to any step and the workflow will run compensations in reverse order if anything
- * downstream fails.
- *
- * `createSagaWorkflow` is a thin alias for `createWorkflow` whose result error union
- * also includes `SagaCompensationError` — useful when you know you'll be using
- * compensation and want the type system to remind you.
- *
- * @example
- * ```typescript
- * import { createSagaWorkflow, isSagaCompensationError } from 'awaitly/workflow';
- *
- * const checkout = createSagaWorkflow('checkout', {
- *   reserveInventory, releaseInventory,
- *   chargeCard, refundPayment,
- *   sendEmail,
- * });
- *
- * const result = await checkout.run(async ({ step, deps }) => {
- *   const r = await step('reserve', () => deps.reserveInventory(items), {
- *     compensate: (r) => deps.releaseInventory(r.id),
- *   });
- *   const p = await step('charge', () => deps.chargeCard(amount), {
- *     compensate: (p) => deps.refundPayment(p.id),
- *   });
- *   await step('notify', () => deps.sendEmail(userId));
- *   return { r, p };
- * });
- *
- * if (!result.ok && isSagaCompensationError(result.error)) {
- *   // result.error.originalError    — what triggered the rollback
- *   // result.error.compensationErrors — which cleanups failed
- * }
- * ```
- */
-
-/** A compensation action to run on rollback. */
-type CompensationAction<T> = (value: T) => void | Promise<void>;
-/** Options for a saga step (kept for back-compat — `compensate` lives on `StepOptions`). */
-interface SagaStepOptions<T> {
-    compensate?: CompensationAction<T>;
-}
-/**
- * @deprecated Use `WorkflowOptions` from `awaitly/workflow`. Kept as an alias for back-compat.
- */
-type SagaWorkflowOptions<E> = {
-    onError?: (error: E | UnexpectedError | SagaCompensationError, stepName?: string) => void;
-    onEvent?: (event: unknown) => void;
-    throwOnCompensationFailure?: boolean;
-};
-/** Error returned when one or more compensation actions fail. */
-interface SagaCompensationError {
-    type: "SAGA_COMPENSATION_ERROR";
-    /** The original error that triggered the rollback. */
-    originalError: unknown;
-    /** Errors from failed compensation actions. */
-    compensationErrors: Array<{
-        stepName?: string;
-        error: unknown;
-    }>;
-}
-/** Type guard for SagaCompensationError. */
-declare function isSagaCompensationError(error: unknown): error is SagaCompensationError;
-/**
- * A `Workflow` whose result error union includes `SagaCompensationError`.
- * Identical to `Workflow` at runtime — only the static type is widened.
- */
-type SagaWorkflow<E, U = UnexpectedError, Deps = unknown, C = void> = Workflow<E | SagaCompensationError, U, Deps, C>;
-/**
- * Create a workflow that uses compensation. Identical to `createWorkflow` —
- * only the result type is widened to include `SagaCompensationError`.
- *
- * Prefer this when you intend to use `step(..., { compensate })` so the type
- * system reminds you to handle the SAGA_COMPENSATION_ERROR case.
- *
- * @example
- * ```typescript
- * const saga = createSagaWorkflow('checkout', { reserve, release, charge, refund });
- *
- * const result = await saga.run(async ({ step, deps }) => {
- *   const r = await step('reserve', () => deps.reserve(...), {
- *     compensate: (r) => deps.release(r.id),
- *   });
- *   await step('charge', () => deps.charge(...), {
- *     compensate: (p) => deps.refund(p.id),
- *   });
- *   return r;
- * });
- * ```
- */
-declare function createSagaWorkflow<const Deps extends Readonly<Record<string, AnyResultFn>>, U = UnexpectedError, C = void>(workflowName: string, deps: Deps, options?: WorkflowOptions<ErrorsOfDeps<Deps>, U, C>): SagaWorkflow<ErrorsOfDeps<Deps>, U, Deps, C>;
-/** Saga events emitted by `runSaga` for observability. */
-type SagaEvent = {
-    type: "saga_start";
-    sagaId: string;
-    ts: number;
-} | {
-    type: "saga_success";
-    sagaId: string;
-    ts: number;
-    durationMs: number;
-} | {
-    type: "saga_error";
-    sagaId: string;
-    ts: number;
-    durationMs: number;
-    error: unknown;
-} | {
-    type: "saga_compensation_start";
-    sagaId: string;
-    ts: number;
-    stepCount: number;
-} | {
-    type: "saga_compensation_step";
-    sagaId: string;
-    stepName?: string;
-    ts: number;
-    success: boolean;
-    error?: unknown;
-} | {
-    type: "saga_compensation_end";
-    sagaId: string;
-    ts: number;
-    durationMs: number;
-    success: boolean;
-    failedCount: number;
-};
-type SagaResult<T, E> = Result<T, E | UnexpectedError | SagaCompensationError, unknown>;
-/** Saga step function — like RunStep but every step takes an optional compensate. */
-interface SagaStep<E = unknown> {
-    <T, StepE extends E, StepC = unknown>(name: string, operation: () => Result<T, StepE, StepC> | AsyncResult<T, StepE, StepC>, options?: SagaStepOptions<T>): Promise<T>;
-    try: <T, Err extends E>(name: string, operation: () => T | Promise<T>, options: {
-        error: Err;
-        compensate?: CompensationAction<T>;
-    } | {
-        onError: (cause: unknown) => Err;
-        compensate?: CompensationAction<T>;
-    }) => Promise<T>;
-}
-/**
- * Run a saga with explicit error typing — for cases where you don't have a
- * deps object to infer errors from. Most users should reach for
- * `createSagaWorkflow` (or just `createWorkflow` with `step({ compensate })`).
- */
-declare function runSaga<T, E>(fn: (context: {
-    step: SagaStep<E>;
-}) => Promise<T>, options?: {
-    onError?: (error: E | UnexpectedError | SagaCompensationError) => void;
-    onEvent?: (event: SagaEvent) => void;
-    throwOnCompensationFailure?: boolean;
-}): Promise<SagaResult<T, E>>;
-
-/**
- * awaitly/streaming - Backpressure Controller
- *
- * Implements flow control for streams using high-water mark.
- * When buffered items exceed the threshold, writers are paused
- * until consumers catch up.
- */
-/**
- * State of the backpressure controller.
- */
-type BackpressureState = "flowing" | "paused";
-/**
- * Callback invoked when backpressure state changes.
- */
-type BackpressureCallback = (state: BackpressureState) => void;
-/**
- * Options for creating a BackpressureController.
- */
-interface BackpressureOptions {
-    /** High-water mark threshold (default: 16) */
-    highWaterMark?: number;
-    /** Low-water mark to resume (default: highWaterMark / 2) */
-    lowWaterMark?: number;
-    /** Callback when state changes */
-    onStateChange?: BackpressureCallback;
-}
-/**
- * Controller for managing stream backpressure.
- *
- * When the number of buffered items exceeds the high-water mark,
- * the controller enters "paused" state. It returns to "flowing"
- * when items are consumed and the buffer drops below the low-water mark.
- *
- * @example
- * ```typescript
- * const controller = createBackpressureController({ highWaterMark: 16 });
- *
- * // Track writes
- * controller.increment();
- * if (controller.state === 'paused') {
- *   await controller.waitForDrain();
- * }
- *
- * // Track reads (consumer)
- * controller.decrement();
- * ```
- */
-interface BackpressureController {
-    /** Current state */
-    readonly state: BackpressureState;
-    /** Current number of buffered items */
-    readonly bufferedCount: number;
-    /** High-water mark threshold */
-    readonly highWaterMark: number;
-    /** Low-water mark threshold */
-    readonly lowWaterMark: number;
-    /** Increment buffered count (called on write) */
-    increment(): void;
-    /** Decrement buffered count (called on read/consume) */
-    decrement(): void;
-    /** Set buffered count directly (for resuming) */
-    setCount(count: number): void;
-    /**
-     * Wait for the buffer to drain below low-water mark.
-     * Resolves immediately if already flowing.
-     */
-    waitForDrain(): Promise<void>;
-    /** Reset the controller to initial state */
-    reset(): void;
-}
-/**
- * Create a backpressure controller.
- *
- * @param options - Configuration options
- * @returns BackpressureController instance
- */
-declare function createBackpressureController(options?: BackpressureOptions): BackpressureController;
-/**
- * Check if backpressure should be applied.
- */
-declare function shouldApplyBackpressure(controller: BackpressureController): boolean;
-
-/**
- * awaitly/streaming - Memory Stream Store
- *
- * In-memory implementation of StreamStore for development and testing.
- * Data is not persisted across process restarts.
- */
-
-/**
- * Options for creating a memory stream store.
- */
-interface MemoryStreamStoreOptions {
-    /** Maximum items per stream (default: Infinity) */
-    maxItemsPerStream?: number;
-}
-/**
- * Create an in-memory StreamStore.
- *
- * @param options - Configuration options
- * @returns StreamStore implementation
- *
- * @example
- * ```typescript
- * const store = createMemoryStreamStore();
- *
- * // Use with workflow
- * const workflow = createWorkflow(deps, { streamStore: store });
- * ```
- */
-declare function createMemoryStreamStore(options?: MemoryStreamStoreOptions): StreamStore;
-/**
- * Create a memory stream store with a Map-like interface for testing.
- * Exposes additional methods for inspection.
- */
-interface TestableMemoryStreamStore extends StreamStore {
-    /** Clear all streams */
-    clear(): void;
-    /** Get all stream keys */
-    keys(): string[];
-    /** Check if a stream exists */
-    has(workflowId: string, namespace: string): boolean;
-    /** Delete a stream */
-    delete(workflowId: string, namespace: string): boolean;
-}
-/**
- * Create a testable memory stream store with additional inspection methods.
- */
-declare function createTestableMemoryStreamStore(options?: MemoryStreamStoreOptions): TestableMemoryStreamStore;
-
-/**
- * awaitly/streaming - File Stream Store
- *
- * File-based implementation of StreamStore for persistent storage.
- * Follows the patterns from persistence.ts.
- */
-
-/**
- * Minimal file system interface for stream operations.
- * Same as FileSystemInterface in persistence.ts.
- */
-interface FileSystemInterface {
-    readFile(path: string): Promise<string>;
-    writeFile(path: string, data: string): Promise<void>;
-    unlink(path: string): Promise<void>;
-    exists(path: string): Promise<boolean>;
-    readdir(path: string): Promise<string[]>;
-    mkdir(path: string, options?: {
-        recursive?: boolean;
-    }): Promise<void>;
-}
-/**
- * Options for creating a file stream store.
- */
-interface FileStreamStoreOptions {
-    /** Directory to store stream files */
-    directory: string;
-    /** File system implementation */
-    fs: FileSystemInterface;
-}
-/**
- * Create a file-based StreamStore.
- *
- * Each stream is stored in a directory structure:
- * - `{directory}/{workflowId}/{namespace}/metadata.json` - stream metadata
- * - `{directory}/{workflowId}/{namespace}/items.jsonl` - items in JSON lines format
- *
- * @param options - Configuration options
- * @returns StreamStore implementation
- *
- * @example
- * ```typescript
- * import * as fs from 'fs/promises';
- *
- * const store = createFileStreamStore({
- *   directory: './streams',
- *   fs: {
- *     readFile: (path) => fs.readFile(path, 'utf-8'),
- *     writeFile: (path, data) => fs.writeFile(path, data, 'utf-8'),
- *     unlink: (path) => fs.unlink(path),
- *     exists: async (path) => {
- *       try { await fs.access(path); return true; }
- *       catch { return false; }
- *     },
- *     readdir: (path) => fs.readdir(path),
- *     mkdir: (path, options) => fs.mkdir(path, options),
- *   },
- * });
- * ```
- */
-declare function createFileStreamStore(options: FileStreamStoreOptions): StreamStore;
-
-/**
- * awaitly/streaming - Stream Transformers
- *
- * Utilities for transforming streams: map, filter, chunk, flatMapAsync.
- * All transformers work with both StreamReader and AsyncIterable sources.
- */
-
-/**
- * A transform function that can be applied to stream items.
- */
-type TransformFn<T, U> = (item: T, index: number) => U | Promise<U>;
-/**
- * A filter predicate for stream items.
- */
-type FilterFn<T> = (item: T, index: number) => boolean | Promise<boolean>;
-/**
- * An async transform function that returns a Result.
- */
-type AsyncTransformFn<T, U, E> = (item: T, index: number) => AsyncResult<U, E>;
-/**
- * Convert a StreamReader to an AsyncIterable.
- *
- * This allows using for-await-of with StreamReaders.
- *
- * @param reader - StreamReader to convert
- * @returns AsyncIterable that yields stream values
- *
- * @example
- * ```typescript
- * const reader = step.getReadable<string>({ namespace: 'tokens' });
- *
- * for await (const token of toAsyncIterable(reader)) {
- *   process.stdout.write(token);
- * }
- * ```
- */
-declare function toAsyncIterable<T>(reader: StreamReader<T>): AsyncIterable<T>;
-/**
- * Transform each item in a stream.
- *
- * @param source - StreamReader or AsyncIterable to transform
- * @param fn - Transform function applied to each item
- * @returns AsyncIterable of transformed values
- *
- * @example
- * ```typescript
- * const reader = step.getReadable<number>({ namespace: 'numbers' });
- *
- * for await (const doubled of map(reader, (n) => n * 2)) {
- *   console.log(doubled);
- * }
- * ```
- */
-declare function map<T, U>(source: StreamReader<T> | AsyncIterable<T>, fn: TransformFn<T, U>): AsyncIterable<U>;
-/**
- * Filter items in a stream.
- *
- * @param source - StreamReader or AsyncIterable to filter
- * @param predicate - Filter function that returns true to keep item
- * @returns AsyncIterable of filtered values
- *
- * @example
- * ```typescript
- * const reader = step.getReadable<number>({ namespace: 'numbers' });
- *
- * for await (const even of filter(reader, (n) => n % 2 === 0)) {
- *   console.log(even);
- * }
- * ```
- */
-declare function filter<T>(source: StreamReader<T> | AsyncIterable<T>, predicate: FilterFn<T>): AsyncIterable<T>;
-/**
- * Group stream items into fixed-size chunks.
- *
- * @param source - StreamReader or AsyncIterable to chunk
- * @param size - Maximum number of items per chunk
- * @returns AsyncIterable of item arrays
- *
- * @example
- * ```typescript
- * const reader = step.getReadable<string>({ namespace: 'messages' });
- *
- * for await (const batch of chunk(reader, 10)) {
- *   await processBatch(batch);
- * }
- * ```
- */
-declare function chunk<T>(source: StreamReader<T> | AsyncIterable<T>, size: number): AsyncIterable<T[]>;
-/**
- * Transform each item to multiple items and flatten.
- *
- * @param source - StreamReader or AsyncIterable to transform
- * @param fn - Transform function that returns an iterable
- * @returns AsyncIterable of flattened values
- *
- * @example
- * ```typescript
- * const reader = step.getReadable<string>({ namespace: 'lines' });
- *
- * for await (const word of flatMap(reader, (line) => line.split(' '))) {
- *   console.log(word);
- * }
- * ```
- */
-declare function flatMap<T, U>(source: StreamReader<T> | AsyncIterable<T>, fn: (item: T, index: number) => Iterable<U> | AsyncIterable<U>): AsyncIterable<U>;
-/**
- * Transform each item with a Result-returning async function.
- *
- * This is the Result-aware version of flatMap. If the transform function
- * returns an error Result, the stream is terminated with that error.
- *
- * @param source - StreamReader or AsyncIterable to transform
- * @param fn - Transform function returning AsyncResult
- * @returns AsyncIterable of transformed values wrapped in Results
- *
- * @example
- * ```typescript
- * const reader = step.getReadable<Message>({ namespace: 'messages' });
- *
- * for await (const result of flatMapAsync(reader, async (msg) => {
- *   const processed = await processMessage(msg);
- *   return ok(processed);
- * })) {
- *   if (!result.ok) {
- *     console.error('Processing failed:', result.error);
- *     break;
- *   }
- *   console.log('Processed:', result.value);
- * }
- * ```
- */
-declare function flatMapAsync<T, U, E>(source: StreamReader<T> | AsyncIterable<T>, fn: AsyncTransformFn<T, Iterable<U> | AsyncIterable<U>, E>): AsyncIterable<Result<U, E>>;
-/**
- * Transform each item with a Result-returning async function.
- *
- * @param source - StreamReader or AsyncIterable to transform
- * @param fn - Transform function returning AsyncResult
- * @returns AsyncIterable of Results
- *
- * @example
- * ```typescript
- * const reader = step.getReadable<number>({ namespace: 'numbers' });
- *
- * for await (const result of mapAsync(reader, async (n) => {
- *   if (n < 0) return err('NEGATIVE_NUMBER');
- *   return ok(Math.sqrt(n));
- * })) {
- *   if (result.ok) {
- *     console.log('Sqrt:', result.value);
- *   }
- * }
- * ```
- */
-declare function mapAsync<T, U, E>(source: StreamReader<T> | AsyncIterable<T>, fn: AsyncTransformFn<T, U, E>): AsyncIterable<Result<U, E>>;
-/**
- * Take the first N items from a stream.
- *
- * @param source - StreamReader or AsyncIterable to take from
- * @param count - Maximum number of items to take
- * @returns AsyncIterable of up to N items
- *
- * @example
- * ```typescript
- * const reader = step.getReadable<string>({ namespace: 'messages' });
- *
- * for await (const message of take(reader, 10)) {
- *   console.log(message);
- * }
- * ```
- */
-declare function take<T>(source: StreamReader<T> | AsyncIterable<T>, count: number): AsyncIterable<T>;
-/**
- * Skip the first N items from a stream.
- *
- * @param source - StreamReader or AsyncIterable to skip from
- * @param count - Number of items to skip
- * @returns AsyncIterable starting after N items
- *
- * @example
- * ```typescript
- * const reader = step.getReadable<string>({ namespace: 'messages' });
- *
- * for await (const message of skip(reader, 100)) {
- *   console.log(message); // Messages 101+
- * }
- * ```
- */
-declare function skip<T>(source: StreamReader<T> | AsyncIterable<T>, count: number): AsyncIterable<T>;
-/**
- * Take items while predicate returns true.
- *
- * @param source - StreamReader or AsyncIterable
- * @param predicate - Predicate function
- * @returns AsyncIterable of items while predicate is true
- *
- * @example
- * ```typescript
- * const reader = step.getReadable<number>({ namespace: 'numbers' });
- *
- * for await (const n of takeWhile(reader, (n) => n < 100)) {
- *   console.log(n);
- * }
- * ```
- */
-declare function takeWhile<T>(source: StreamReader<T> | AsyncIterable<T>, predicate: FilterFn<T>): AsyncIterable<T>;
-/**
- * Skip items while predicate returns true.
- *
- * @param source - StreamReader or AsyncIterable
- * @param predicate - Predicate function
- * @returns AsyncIterable of items after predicate becomes false
- *
- * @example
- * ```typescript
- * const reader = step.getReadable<number>({ namespace: 'numbers' });
- *
- * for await (const n of skipWhile(reader, (n) => n < 100)) {
- *   console.log(n); // First n >= 100 and all after
- * }
- * ```
- */
-declare function skipWhile<T>(source: StreamReader<T> | AsyncIterable<T>, predicate: FilterFn<T>): AsyncIterable<T>;
-/**
- * Collect all stream items into an array.
- *
- * Warning: This loads all items into memory. Only use when you know
- * the stream is bounded.
- *
- * @param source - StreamReader or AsyncIterable
- * @returns Promise resolving to array of all items
- *
- * @example
- * ```typescript
- * const reader = step.getReadable<string>({ namespace: 'small-data' });
- * const items = await collect(reader);
- * console.log('Got', items.length, 'items');
- * ```
- */
-declare function collect<T>(source: StreamReader<T> | AsyncIterable<T>): Promise<T[]>;
-/**
- * Reduce stream items to a single value.
- *
- * @param source - StreamReader or AsyncIterable
- * @param reducer - Reducer function
- * @param initial - Initial accumulator value
- * @returns Promise resolving to final accumulated value
- *
- * @example
- * ```typescript
- * const reader = step.getReadable<number>({ namespace: 'numbers' });
- * const sum = await reduce(reader, (acc, n) => acc + n, 0);
- * console.log('Sum:', sum);
- * ```
- */
-declare function reduce<T, U>(source: StreamReader<T> | AsyncIterable<T>, reducer: (accumulator: U, item: T, index: number) => U | Promise<U>, initial: U): Promise<U>;
-/**
- * Pipe a source through multiple transformers.
- *
- * @param source - Initial source
- * @param transformers - Array of transformer functions
- * @returns Final transformed AsyncIterable
- *
- * @example
- * ```typescript
- * const reader = step.getReadable<number>({ namespace: 'numbers' });
- *
- * const result = pipe(
- *   reader,
- *   (s) => filter(s, (n) => n > 0),
- *   (s) => map(s, (n) => n * 2),
- *   (s) => take(s, 10)
- * );
- *
- * for await (const n of result) {
- *   console.log(n);
- * }
- * ```
- */
-declare function pipe<T>(source: StreamReader<T> | AsyncIterable<T>): AsyncIterable<T>;
-declare function pipe<T, A>(source: StreamReader<T> | AsyncIterable<T>, t1: (s: AsyncIterable<T>) => AsyncIterable<A>): AsyncIterable<A>;
-declare function pipe<T, A, B>(source: StreamReader<T> | AsyncIterable<T>, t1: (s: AsyncIterable<T>) => AsyncIterable<A>, t2: (s: AsyncIterable<A>) => AsyncIterable<B>): AsyncIterable<B>;
-declare function pipe<T, A, B, C>(source: StreamReader<T> | AsyncIterable<T>, t1: (s: AsyncIterable<T>) => AsyncIterable<A>, t2: (s: AsyncIterable<A>) => AsyncIterable<B>, t3: (s: AsyncIterable<B>) => AsyncIterable<C>): AsyncIterable<C>;
-declare function pipe<T, A, B, C, D>(source: StreamReader<T> | AsyncIterable<T>, t1: (s: AsyncIterable<T>) => AsyncIterable<A>, t2: (s: AsyncIterable<A>) => AsyncIterable<B>, t3: (s: AsyncIterable<B>) => AsyncIterable<C>, t4: (s: AsyncIterable<C>) => AsyncIterable<D>): AsyncIterable<D>;
-
-/**
- * awaitly/streaming
- *
- * Result-aware streaming for workflows.
- * All stream operations return Result types, enabling typed error handling
- * throughout the streaming pipeline.
- *
- * @example Basic usage
- * ```typescript
- * import { createWorkflow } from 'awaitly/workflow';
- * import { createMemoryStreamStore } from 'awaitly/workflow';
- *
- * const streamStore = createMemoryStreamStore();
- * const workflow = createWorkflow(deps, { streamStore });
- *
- * const result = await workflow(async ({ step }) => {
- *   const writer = step.getWritable<string>({ namespace: 'tokens' });
- *
- *   await step(() => generateAI({
- *     prompt: 'Hello',
- *     onToken: async (token) => { await writer.write(token); }
- *   }), { key: 'generate' });
- *
- *   await writer.close();
- * });
- * ```
- *
- * @example Consuming a stream
- * ```typescript
- * import { toAsyncIterable } from 'awaitly/workflow';
- *
- * const reader = step.getReadable<string>({ namespace: 'tokens' });
- *
- * for await (const token of toAsyncIterable(reader)) {
- *   process.stdout.write(token);
- * }
- * ```
- *
- * @example Stream transformations
- * ```typescript
- * import { map, filter, chunk, collect } from 'awaitly/workflow';
- *
- * const reader = step.getReadable<number>({ namespace: 'numbers' });
- *
- * // Transform pipeline
- * const evens = filter(reader, n => n % 2 === 0);
- * const doubled = map(evens, n => n * 2);
- * const batches = chunk(doubled, 10);
- *
- * for await (const batch of batches) {
- *   await processBatch(batch);
- * }
- * ```
- */
-
-/**
- * Options for creating an external stream reader.
- */
-interface ExternalReaderOptions {
-    /** Stream store instance */
-    store: StreamStore;
-    /** Workflow ID that owns the stream */
-    workflowId: string;
-    /** Stream namespace (default: 'default') */
-    namespace?: string;
-    /** Start reading from this position (default: 0) */
-    startIndex?: number;
-    /** Poll interval in ms when waiting for new items (default: 100) */
-    pollInterval?: number;
-    /** Stop polling after this many ms with no new items (default: 30000) */
-    pollTimeout?: number;
-}
-/**
- * Create a stream reader for external consumption (outside workflows).
- *
- * Use this in HTTP handlers, WebSocket handlers, or other contexts
- * where you need to consume a stream created by a workflow.
- *
- * @param options - Reader configuration
- * @returns StreamReader that can be used with toAsyncIterable()
- *
- * @example HTTP streaming response
- * ```typescript
- * app.get('/stream/:workflowId', async (req, res) => {
- *   const reader = getStreamReader({
- *     store: streamStore,
- *     workflowId: req.params.workflowId,
- *     namespace: 'ai-response',
- *   });
- *
- *   res.setHeader('Content-Type', 'text/event-stream');
- *
- *   for await (const chunk of toAsyncIterable(reader)) {
- *     res.write(`data: ${chunk}\n\n`);
- *   }
- *
- *   res.end();
- * });
- * ```
- *
- * @example Resume from last position
- * ```typescript
- * const reader = getStreamReader({
- *   store: streamStore,
- *   workflowId: runId,
- *   namespace: 'tokens',
- *   startIndex: lastReceivedPosition + 1,
- * });
- * ```
- */
-declare function getStreamReader<T>(options: ExternalReaderOptions): StreamReader<T>;
-
-/**
- * awaitly/webhook
- *
- * Webhook and event trigger adapters for exposing workflows as HTTP endpoints.
- * Framework-agnostic handlers that work with Express, Hono, Fastify, etc.
- */
-
-/**
- * Generic HTTP request representation.
- * Abstracts away framework-specific request objects.
- */
-interface WebhookRequest<Body = unknown> {
-    /** HTTP method (GET, POST, PUT, DELETE, etc.) */
-    method: string;
-    /** Request path (e.g., "/api/checkout") */
-    path: string;
-    /** Request headers */
-    headers: Record<string, string | string[] | undefined>;
-    /** Parsed request body (JSON) */
-    body: Body;
-    /** Query parameters */
-    query: Record<string, string | string[] | undefined>;
-    /** Path parameters (e.g., { id: "123" }) */
-    params: Record<string, string>;
-    /** Raw request object from framework (for advanced use cases) */
-    raw?: unknown;
-}
-/**
- * Generic HTTP response representation.
- */
-interface WebhookResponse<T = unknown> {
-    /** HTTP status code */
-    status: number;
-    /** Response headers */
-    headers?: Record<string, string>;
-    /** Response body (will be JSON serialized) */
-    body: T;
-}
-/**
- * Error response body structure.
- */
-interface ErrorResponseBody {
-    error: {
-        type: string;
-        message?: string;
-        details?: unknown;
-    };
-}
-/**
- * Input validation result.
- */
-type ValidationResult<T, E = string> = Result<T, E>;
-/**
- * Standard validation error type.
- */
-interface ValidationError {
-    type: "VALIDATION_ERROR";
-    message: string;
-    field?: string;
-    details?: unknown;
-}
-/**
- * Type guard for ValidationError.
- */
-declare function isValidationError(e: unknown): e is ValidationError;
-/**
- * Configuration for creating a webhook handler.
- *
- * @template TInput - The validated input type
- * @template TOutput - The workflow output type
- * @template TError - The workflow error type
- * @template TBody - The raw request body type
- * @template TUnexpected - The workflow's unexpected error type (default UnexpectedError)
- */
-interface WebhookHandlerConfig<TInput, TOutput, TError, TBody = unknown, TUnexpected = UnexpectedError> {
-    /**
-     * Validate and transform the incoming request.
-     * Return ok(input) to proceed, or err(validationError) to reject.
-     *
-     * @param req - The incoming request
-     * @returns Validated input or validation error
-     */
-    validateInput: (req: WebhookRequest<TBody>) => ValidationResult<TInput, ValidationError> | Promise<ValidationResult<TInput, ValidationError>>;
-    /**
-     * Map workflow result to HTTP response.
-     * Called for both success and error cases.
-     *
-     * @param result - The workflow result (error union is TError | TUnexpected)
-     * @param req - The original request (for context)
-     * @returns HTTP response
-     */
-    mapResult: (result: Result<TOutput, TError | TUnexpected>, req: WebhookRequest<TBody>) => WebhookResponse;
-    /**
-     * Optional: Map validation errors to HTTP response.
-     * Defaults to 400 Bad Request with error details.
-     *
-     * @param error - The validation error
-     * @param req - The original request
-     * @returns HTTP response
-     */
-    mapValidationError?: (error: ValidationError, req: WebhookRequest<TBody>) => WebhookResponse<ErrorResponseBody>;
-    /**
-     * Optional: Handle unexpected errors during request processing.
-     * Defaults to 500 Internal Server Error.
-     *
-     * @param error - The unexpected error
-     * @param req - The original request
-     * @returns HTTP response
-     */
-    mapUnexpectedError?: (error: unknown, req: WebhookRequest<TBody>) => WebhookResponse<ErrorResponseBody>;
-    /**
-     * Optional: Request middleware.
-     * Transform or enrich the request before validation.
-     *
-     * @param req - The incoming request
-     * @returns Transformed request
-     */
-    beforeValidation?: (req: WebhookRequest<TBody>) => WebhookRequest<TBody> | Promise<WebhookRequest<TBody>>;
-    /**
-     * Optional: Response middleware.
-     * Transform the response before sending.
-     *
-     * @param response - The response to send
-     * @param req - The original request
-     * @returns Transformed response
-     */
-    afterResponse?: (response: WebhookResponse, req: WebhookRequest<TBody>) => WebhookResponse | Promise<WebhookResponse>;
-}
-/**
- * A webhook handler function that processes requests.
- */
-type WebhookHandler<TBody = unknown> = (req: WebhookRequest<TBody>) => Promise<WebhookResponse>;
-/**
- * Default validation error mapper.
- * Returns 400 Bad Request with error details.
- */
-declare function defaultValidationErrorMapper(error: ValidationError): WebhookResponse<ErrorResponseBody>;
-/**
- * Default unexpected error mapper.
- * Returns 500 Internal Server Error.
- */
-declare function defaultUnexpectedErrorMapper(error: unknown): WebhookResponse<ErrorResponseBody>;
-/**
- * Create a webhook handler for a workflow.
- *
- * This factory creates an HTTP handler function that:
- * 1. Validates the incoming request
- * 2. Executes the workflow with the validated input
- * 3. Maps the result to an HTTP response
- *
- * The handler is framework-agnostic and returns a standard response object.
- * Use framework adapters (createExpressHandler, createHonoHandler, etc.) to
- * integrate with specific frameworks.
- *
- * @template TInput - The validated input type passed to the workflow
- * @template TOutput - The workflow output type
- * @template TError - The workflow error type
- * @template TBody - The raw request body type
- * @template TDeps - The workflow dependencies type
- *
- * @param workflow - The workflow function to execute
- * @param workflowFn - The workflow body function ({ step, deps, args }) => output
- * @param config - Handler configuration
- * @returns A webhook handler function
- *
- * @example
- * ```typescript
- * const checkoutWorkflow = createWorkflow('checkout', { chargeCard, sendEmail });
- *
- * const handler = createWebhookHandler(
- *   checkoutWorkflow,
- *   async ({ step, deps, args: input }) => {
- *     const charge = await step('chargeCard', () => deps.chargeCard(input.amount));
- *     await step('sendEmail', () => deps.sendEmail(input.email, charge.receiptUrl));
- *     return { chargeId: charge.id };
- *   },
- *   {
- *     validateInput: (req) => {
- *       const { amount, email } = req.body;
- *       if (!amount || !email) {
- *         return err({ type: 'VALIDATION_ERROR', message: 'Missing required fields' });
- *       }
- *       return ok({ amount, email });
- *     },
- *     mapResult: (result) => {
- *       if (result.ok) {
- *         return { status: 200, body: result.value };
- *       }
- *       if (result.error === 'CARD_DECLINED') {
- *         return { status: 402, body: { error: { type: 'CARD_DECLINED' } } };
- *       }
- *       return { status: 500, body: { error: { type: 'UNKNOWN' } } };
- *     },
- *   }
- * );
- *
- * // Use with Express
- * app.post('/checkout', async (req, res) => {
- *   const response = await handler(toWebhookRequest(req));
- *   res.status(response.status).json(response.body);
- * });
- * ```
- */
-declare function createWebhookHandler<TInput, TOutput, TError, TUnexpected, TBody = unknown, TDeps = unknown>(workflow: Workflow<TError, TUnexpected, TDeps>, workflowFn: (context: {
-    step: RunStep<TError | TUnexpected>;
-    deps: TDeps;
-    args: TInput;
-}) => TOutput | Promise<TOutput>, config: WebhookHandlerConfig<TInput, TOutput, TError, TBody, TUnexpected>): WebhookHandler<TBody>;
-declare function createWebhookHandler<TInput, TOutput, TError, TBody = unknown, TDeps = unknown>(workflow: Workflow<TError, UnexpectedError, TDeps>, workflowFn: (context: {
-    step: RunStep<TError | UnexpectedError>;
-    deps: TDeps;
-    args: TInput;
-}) => TOutput | Promise<TOutput>, config: WebhookHandlerConfig<TInput, TOutput, TError, TBody, UnexpectedError>): WebhookHandler<TBody>;
-/**
- * Configuration for a simple webhook handler without workflow.
- * Use with createSimpleHandler for endpoints that don't need step orchestration.
- *
- * @template TInput - Validated input type
- * @template TOutput - Handler success output type
- * @template TError - Handler error type
- * @template TBody - Raw request body type
- */
-interface SimpleHandlerConfig<TInput, TOutput, TError, TBody = unknown> {
-    /** Validate and transform the incoming request; return ok(input) or err(ValidationError). */
-    validateInput: (req: WebhookRequest<TBody>) => ValidationResult<TInput, ValidationError> | Promise<ValidationResult<TInput, ValidationError>>;
-    /** Execute the business logic; return Result. */
-    handler: (input: TInput, req: WebhookRequest<TBody>) => AsyncResult<TOutput, TError>;
-    /** Map the handler result to an HTTP response. */
-    mapResult: (result: Result<TOutput, TError>, req: WebhookRequest<TBody>) => WebhookResponse;
-    /** Optional: map validation errors to response. Defaults to 400 with error details. */
-    mapValidationError?: (error: ValidationError, req: WebhookRequest<TBody>) => WebhookResponse<ErrorResponseBody>;
-    /** Optional: handle unexpected errors. Defaults to 500. */
-    mapUnexpectedError?: (error: unknown, req: WebhookRequest<TBody>) => WebhookResponse<ErrorResponseBody>;
-}
-/**
- * Create a simple webhook handler without workflow orchestration.
- * Useful for simple endpoints that don't need step-based error handling.
- *
- * @example
- * ```typescript
- * const handler = createSimpleHandler({
- *   validateInput: (req) => {
- *     const { id } = req.params;
- *     if (!id) return err({ type: 'VALIDATION_ERROR', message: 'Missing id' });
- *     return ok({ id });
- *   },
- *   handler: async ({ id }) => {
- *     const user = await db.findUser(id);
- *     return user ? ok(user) : err('NOT_FOUND' as const);
- *   },
- *   mapResult: (result) => {
- *     if (result.ok) return { status: 200, body: result.value };
- *     return { status: 404, body: { error: { type: 'NOT_FOUND' } } };
- *   },
- * });
- * ```
- */
-declare function createSimpleHandler<TInput, TOutput, TError, TBody = unknown>(config: SimpleHandlerConfig<TInput, TOutput, TError, TBody>): WebhookHandler<TBody>;
-/**
- * Standard error mapping configuration.
- */
-interface ErrorMapping<TError> {
-    /** The error value to match */
-    error: TError;
-    /** HTTP status code for this error */
-    status: number;
-    /** Optional custom message */
-    message?: string;
-}
-/**
- * Create a result mapper from error mappings.
- * Provides a declarative way to map workflow errors to HTTP responses.
- *
- * @param mappings - Array of error mappings
- * @param defaultStatus - Default status for unmapped errors (default: 500)
- * @returns A mapResult function for use in handler config
- *
- * @example
- * ```typescript
- * const mapResult = createResultMapper<CheckoutOutput, CheckoutError>([
- *   { error: 'NOT_FOUND', status: 404, message: 'Resource not found' },
- *   { error: 'CARD_DECLINED', status: 402, message: 'Payment failed' },
- *   { error: 'RATE_LIMITED', status: 429, message: 'Too many requests' },
- * ]);
- *
- * const handler = createWebhookHandler(workflow, workflowFn, {
- *   validateInput,
- *   mapResult,
- * });
- * ```
- */
-declare function createResultMapper<TOutput, TError>(mappings: ErrorMapping<TError>[], options?: {
-    defaultStatus?: number;
-    successStatus?: number;
-}): (result: Result<TOutput, TError | UnexpectedError>) => WebhookResponse;
-/**
- * Express-style request object (minimal interface).
- */
-interface ExpressLikeRequest {
-    method: string;
-    path: string;
-    headers: Record<string, string | string[] | undefined>;
-    body: unknown;
-    query: Record<string, string | string[] | undefined>;
-    params: Record<string, string>;
-}
-/**
- * Express-style response object (minimal interface).
- */
-interface ExpressLikeResponse {
-    status(code: number): ExpressLikeResponse;
-    set(headers: Record<string, string>): ExpressLikeResponse;
-    json(body: unknown): void;
-}
-/**
- * Convert an Express-like request to WebhookRequest.
- *
- * @param req - Express-like request object
- * @returns WebhookRequest
- *
- * @example
- * ```typescript
- * app.post('/checkout', async (req, res) => {
- *   const webhookReq = toWebhookRequest(req);
- *   const response = await handler(webhookReq);
- *   res.status(response.status).json(response.body);
- * });
- * ```
- */
-declare function toWebhookRequest<TBody = unknown>(req: ExpressLikeRequest): WebhookRequest<TBody>;
-/**
- * Send a WebhookResponse using an Express-like response object.
- *
- * @param res - Express-like response object
- * @param response - WebhookResponse to send
- *
- * @example
- * ```typescript
- * app.post('/checkout', async (req, res) => {
- *   const response = await handler(toWebhookRequest(req));
- *   sendWebhookResponse(res, response);
- * });
- * ```
- */
-declare function sendWebhookResponse(res: ExpressLikeResponse, response: WebhookResponse): void;
-/**
- * Create an Express-compatible middleware from a webhook handler.
- *
- * @param handler - Webhook handler function
- * @returns Express middleware function
- *
- * @example
- * ```typescript
- * const handler = createWebhookHandler(workflow, workflowFn, config);
- * const middleware = createExpressHandler(handler);
- * app.post('/checkout', middleware);
- * ```
- */
-declare function createExpressHandler<TBody = unknown>(handler: WebhookHandler<TBody>): (req: ExpressLikeRequest, res: ExpressLikeResponse) => Promise<void>;
-/**
- * Create a validation error.
- *
- * @param message - Error message
- * @param field - Optional field name
- * @param details - Optional additional details
- * @returns ValidationError
- */
-declare function validationError(message: string, field?: string, details?: unknown): ValidationError;
-/**
- * Create a required field validator.
- *
- * @param fields - Field names to validate
- * @returns Validation function
- *
- * @example
- * ```typescript
- * const validateRequired = requireFields(['email', 'password']);
- *
- * const validateInput = (req) => {
- *   const result = validateRequired(req.body);
- *   if (!result.ok) return result;
- *   return ok(req.body as LoginInput);
- * };
- * ```
- */
-declare function requireFields(fields: string[]): (body: Record<string, unknown>) => ValidationResult<void, ValidationError>;
-/**
- * Compose multiple validators into a single validator.
- *
- * @param validators - Validators to compose
- * @returns Combined validator function
- *
- * @example
- * ```typescript
- * const validate = composeValidators(
- *   requireFields(['email', 'password']),
- *   validateEmailFormat,
- *   validatePasswordStrength
- * );
- * ```
- */
-declare function composeValidators<T>(...validators: Array<(input: T) => ValidationResult<void, ValidationError>>): (input: T) => ValidationResult<void, ValidationError>;
-/**
- * Generic event message for queue-based triggers.
- */
-interface EventMessage<T = unknown> {
-    /** Unique message ID */
-    id: string;
-    /** Event type/name */
-    type: string;
-    /** Event payload */
-    payload: T;
-    /** Event metadata */
-    metadata?: {
-        timestamp?: number;
-        source?: string;
-        correlationId?: string;
-        [key: string]: unknown;
-    };
-}
-/**
- * Result of processing an event.
- */
-interface EventProcessingResult {
-    /** Whether the event was processed successfully */
-    success: boolean;
-    /** Should the message be acknowledged (removed from queue)? */
-    ack: boolean;
-    /** Optional error details */
-    error?: {
-        type: string;
-        message?: string;
-        retryable?: boolean;
-    };
-}
-/**
- * Configuration for event trigger handlers.
- */
-interface EventTriggerConfig<TPayload, TOutput, TError, TUnexpected = UnexpectedError> {
-    /** Validate the event payload */
-    validatePayload: (event: EventMessage<TPayload>) => ValidationResult<TPayload, ValidationError>;
-    /** Map workflow result to processing result */
-    mapResult: (result: Result<TOutput, TError | TUnexpected>, event: EventMessage<TPayload>) => EventProcessingResult;
-    /** Optional: Determine if error is retryable */
-    isRetryable?: (error: TError | TUnexpected) => boolean;
-}
-/**
- * Event handler function type.
- */
-type EventHandler<TPayload = unknown> = (event: EventMessage<TPayload>) => Promise<EventProcessingResult>;
-/**
- * Create an event handler for queue-based triggers.
- *
- * @example
- * ```typescript
- * const handler = createEventHandler(
- *   checkoutWorkflow,
- *   async ({ step, deps, args: payload }) => {
- *     const charge = await step('chargeCard', () => deps.chargeCard(payload.amount));
- *     return { chargeId: charge.id };
- *   },
- *   {
- *     validatePayload: (event) => {
- *       if (!event.payload.amount) {
- *         return err({ type: 'VALIDATION_ERROR', message: 'Missing amount' });
- *       }
- *       return ok(event.payload);
- *     },
- *     mapResult: (result) => ({
- *       success: result.ok,
- *       ack: result.ok || !isRetryableError(result.error),
- *       error: result.ok ? undefined : { type: String(result.error) },
- *     }),
- *   }
- * );
- *
- * // Use with SQS, RabbitMQ, etc.
- * queue.consume(async (message) => {
- *   const result = await handler(message);
- *   if (result.ack) await message.ack();
- *   else await message.nack();
- * });
- * ```
- */
-declare function createEventHandler<TPayload, TOutput, TError, TDeps = unknown, TUnexpected = UnexpectedError>(workflow: Workflow<TError, TUnexpected, TDeps>, workflowFn: (context: {
-    step: RunStep<TError | TUnexpected>;
-    deps: TDeps;
-    args: TPayload;
-}) => TOutput | Promise<TOutput>, config: EventTriggerConfig<TPayload, TOutput, TError, TUnexpected>): EventHandler<TPayload>;
-
-/** A registered workflow definition */
-interface WorkflowRegistration<Deps extends Readonly<Record<string, AnyResultFn>> = Readonly<Record<string, AnyResultFn>>> {
-    /** Workflow dependencies (Result-returning functions) */
-    deps: Deps;
-    /** Workflow function */
-    fn: (context: {
-        step: RunStep<any>;
-        deps: Deps;
-        ctx: WorkflowContext;
-    }) => any;
-    /** Default durable options (version, lockTtlMs, etc.) */
-    durableDefaults?: Partial<Pick<DurableOptions, 'version' | 'lockTtlMs' | 'heartbeatIntervalMs'>>;
-}
-interface EnqueueOptions {
-    /** Custom workflow execution ID (default: auto-generated UUID) */
-    id?: string;
-    /** Idempotency key for deduplication */
-    idempotencyKey?: string;
-    /** Workflow input for idempotency conflict detection */
-    input?: unknown;
-    /** Custom metadata */
-    metadata?: Record<string, unknown>;
-}
-interface ScheduleOptions {
-    /** Repeat interval in milliseconds */
-    intervalMs: number;
-    /** Run immediately on schedule creation */
-    immediate?: boolean;
-}
-interface EngineOptions {
-    /** Snapshot store for workflow persistence */
-    store: SnapshotStore;
-    /** Registered workflows keyed by name */
-    workflows: Record<string, WorkflowRegistration>;
-    /** Max parallel workflow runs per tick (default: 5) */
-    concurrency?: number;
-    /** Event handler */
-    onEvent?: (event: EngineEvent) => void;
-    /** Error handler for background operations */
-    onError?: (error: unknown) => void;
-}
-type EngineEvent = {
-    type: "engine_start";
-    ts: number;
-} | {
-    type: "engine_stop";
-    ts: number;
-} | {
-    type: "engine_tick";
-    ts: number;
-    processed: number;
-} | {
-    type: "workflow_enqueued";
-    workflowName: string;
-    id: string;
-    ts: number;
-} | {
-    type: "workflow_started";
-    workflowName: string;
-    id: string;
-    ts: number;
-} | {
-    type: "workflow_completed";
-    workflowName: string;
-    id: string;
-    ts: number;
-} | {
-    type: "workflow_failed";
-    workflowName: string;
-    id: string;
-    error: unknown;
-    ts: number;
-} | {
-    type: "schedule_created";
-    workflowName: string;
-    scheduleId: string;
-    intervalMs: number;
-    ts: number;
-} | {
-    type: "schedule_removed";
-    scheduleId: string;
-    ts: number;
-};
-interface Engine {
-    /** Enqueue a workflow for execution. Returns the workflow execution ID. */
-    enqueue(name: string, options?: EnqueueOptions): Promise<string>;
-    /** Schedule recurring workflow execution. Returns the schedule ID. */
-    schedule(name: string, options: ScheduleOptions & EnqueueOptions): string;
-    /** Remove a schedule */
-    unschedule(scheduleId: string): boolean;
-    /** Start the polling loop */
-    start(pollIntervalMs?: number): void;
-    /** Stop the polling loop gracefully */
-    stop(): Promise<void>;
-    /** Execute a single tick manually (process pending workflows). Returns number processed. */
-    tick(): Promise<number>;
-    /** Get engine status */
-    status(): {
-        running: boolean;
-        pendingSchedules: number;
-    };
-}
-
-declare function createEngine(options: EngineOptions): Engine;
-
 /**
  * awaitly/resource
  *
@@ -3732,4 +721,4 @@ declare const batchPresets: {
     };
 };
 
-export { AnyResultFn, type ApprovalNeededContext, ApprovalRejected, type ApprovalResolvedContext, type ApprovalStatus, ApprovalStepOptions, type ApprovalStore, type ApprovalWebhookRequest, type ApprovalWebhookResponse, type AsyncTransformFn, type BackpressureCallback, type BackpressureController, type BackpressureOptions, type BackpressureState, type BatchConfig, type BatchOptions, type BatchProcessingError, type BatchProgress, type CompensationAction, type ConcurrentExecutionError, type DeleteStatesOptions, type DeleteStatesResult, type DurableOptions, type DurableWorkflowEvent, type Engine, type EngineEvent, type EngineOptions, type EnqueueOptions, type ErrorMapping, type ErrorResponseBody, ErrorsOfDeps, type EventHandler, type EventMessage, type EventProcessingResult, type EventTriggerConfig, type ExpressLikeRequest, type ExpressLikeResponse, type ExternalReaderOptions, type FileStreamStoreOptions, type FileSystemInterface, type FilterFn, GatedStepOptions, type HITLExecutionResult, type HITLOrchestrator, type HITLOrchestratorOptions, type HITLWorkflowFactoryOptions, HOOK_STEP_KEY_PREFIX, type IdempotencyConflictError, type InputValidationError, type InvalidBatchConfigError, type LeaseExpiredError, type MemoryStreamStoreOptions, type MigrationError, type MigrationFn, type Migrations, type NotificationChannel, PendingApproval, PendingHook, type PersistedWorkflowState, type PersistenceError, type PollerOptions, type Resource, type ResourceCleanupError, type ResourceScope, ResumeState, ResumeStateEntry, RunStep, type SagaCompensationError, type SagaEvent, type SagaResult, type SagaStep, type SagaStepOptions, type SagaWorkflow, type SagaWorkflowOptions, type SavedWorkflowState, type ScheduleOptions, type SerializedResumeState, type SimpleHandlerConfig, SnapshotStore, StepResult, type StoreLoadResult, type StoreSaveInput, StreamReader, StreamStore, type TestableMemoryStreamStore, type TransformFn, UnexpectedError, type ValidationError, type ValidationResult, type Version, type VersionIncompatibleError, type VersionMismatchError, type VersionedState, type VersionedWorkflowConfig, type WebhookHandler, type WebhookHandlerConfig, type WebhookRequest, type WebhookResponse, Workflow, WorkflowCancelledError, WorkflowContext, type WorkflowDiagramDSL, type WorkflowDiagramSourceLocation, type WorkflowDiagramState, type WorkflowDiagramStateType, type WorkflowDiagramTransition, WorkflowEvent, type WorkflowLock, WorkflowOptions, type WorkflowRegistration, WorkflowSnapshot, type WorkflowStateStore, batchPresets, chunk, clearStep, collect, composeMigrations, composeValidators, createApprovalChecker, createApprovalStateCollector, createApprovalStep, createApprovalWebhookHandler, createBackpressureController, createEngine, createEventHandler, createExpressHandler, createFileStreamStore, createHITLOrchestrator, createHook, createKeyRemoveMigration, createKeyRenameMigration, createMemoryApprovalStore, createMemoryStreamStore, createMemoryWorkflowStateStore, createResource, createResourceScope, createResultMapper, createResumeStateCollector, createSagaWorkflow, createSimpleHandler, createTestableMemoryStreamStore, createValueTransformMigration, createVersionedState, createVersionedStateLoader, createWebhookHandler, createWorkflow, defaultUnexpectedErrorMapper, defaultValidationErrorMapper, deserializeResumeState, durable, filter, flatMap, flatMapAsync, gatedStep, getPendingApprovals, getPendingHooks, getStreamReader, hasPendingApproval, hasPendingHook, injectApproval, injectHook, isApprovalRejected, isBatchProcessingError, isConcurrentExecution, isIdempotencyConflict, isInputValidationError, isInvalidBatchConfigError, isLeaseExpired, isMigrationError, isPendingApproval, isPendingHook, isPersistenceError, isResourceCleanupError, isResumeState, isSagaCompensationError, isSerializedResumeState, isStepComplete, isValidationError, isVersionIncompatibleError, isVersionMismatch, isWorkflowCancelled, map, mapAsync, parseVersionedState, pendingApproval, pendingHook, pipe, processInBatches, reduce, requireFields, runSaga, sendWebhookResponse, serializeResumeState, shouldApplyBackpressure, skip, skipWhile, stringifyVersionedState, take, takeWhile, toAsyncIterable, toResumeState, toWebhookRequest, validateInput, validationError, withScope };
+export { AnyResultFn, type BatchConfig, type BatchOptions, type BatchProcessingError, type BatchProgress, ErrorsOfDeps, HOOK_STEP_KEY_PREFIX, type InputValidationError, type InvalidBatchConfigError, PendingHook, type Resource, type ResourceCleanupError, type ResourceScope, UnexpectedError, Workflow, type WorkflowDiagramDSL, type WorkflowDiagramSourceLocation, type WorkflowDiagramState, type WorkflowDiagramStateType, type WorkflowDiagramTransition, WorkflowOptions, batchPresets, createHook, createResource, createResourceScope, createWorkflow, isBatchProcessingError, isInputValidationError, isInvalidBatchConfigError, isResourceCleanupError, pendingHook, processInBatches, validateInput, withScope };