@jagreehal/workflow 1.7.0 → 1.9.0

package/dist/index.d.cts

@@ -1,8 +1,261 @@
 import { WorkflowEvent, Result, AsyncResult, UnexpectedError, StepOptions, RetryOptions, TimeoutOptions, StepFailureMeta } from './core.cjs';
-export { BackoffStrategy, CauseOf, EmptyInputError, ErrorOf, Errors, ExtractCause, ExtractError, ExtractValue, MaybeAsyncResult, PromiseRejectedError, PromiseRejectionCause, RunOptions, RunOptionsWithCatch, RunOptionsWithoutCatch, RunStep, STEP_TIMEOUT_MARKER, ScopeType, SettledError, StepTimeoutError, StepTimeoutMarkerMeta, UnexpectedCause, UnexpectedStepFailureCause, UnwrapError, all, allAsync, allSettled, allSettledAsync, andThen, any, anyAsync, bimap, err, from, fromNullable, fromPromise, getStepTimeoutMeta, isErr, isOk, isStepTimeoutError, isUnexpectedError, map, mapError, mapErrorTry, mapTry, match, ok, orElse, orElseAsync, partition, recover, recoverAsync, run, tap, tapError, tryAsync, unwrap, unwrapOr, unwrapOrElse } from './core.cjs';
+export { BackoffStrategy, CauseOf, EmptyInputError, ErrorOf, Errors, ExtractCause, ExtractError, ExtractValue, MaybeAsyncResult, PromiseRejectedError, PromiseRejectionCause, RunOptions, RunOptionsWithCatch, RunOptionsWithoutCatch, RunStep, STEP_TIMEOUT_MARKER, ScopeType, SettledError, StepTimeoutError, StepTimeoutMarkerMeta, UnexpectedCause, UnexpectedStepFailureCause, UnwrapError, all, allAsync, allSettled, allSettledAsync, andThen, any, anyAsync, bimap, err, from, fromNullable, fromPromise, getStepTimeoutMeta, hydrate, isErr, isOk, isSerializedResult, isStepTimeoutError, isUnexpectedError, map, mapError, mapErrorTry, mapTry, match, ok, orElse, orElseAsync, partition, recover, recoverAsync, run, tap, tapError, tryAsync, unwrap, unwrapOr, unwrapOrElse } from './core.cjs';
 import { ResumeState, ResumeStateEntry, Workflow, WorkflowStrict, StepCache, AnyResultFn as AnyResultFn$1, ErrorsOfDeps as ErrorsOfDeps$1 } from './workflow.cjs';
-export { ApprovalRejected, ApprovalStepOptions, CausesOfDeps, PendingApproval, WorkflowOptions, WorkflowOptionsStrict, clearStep, createApprovalStep, createHITLCollector, createStepCollector, createWorkflow, getPendingApprovals, hasPendingApproval, injectApproval, isApprovalRejected, isPendingApproval, isStepComplete, pendingApproval } from './workflow.cjs';
+export { ApprovalRejected, ApprovalStepOptions, CausesOfDeps, PendingApproval, WorkflowContext, WorkflowOptions, WorkflowOptionsStrict, clearStep, createApprovalStep, createHITLCollector, createStepCollector, createWorkflow, getPendingApprovals, hasPendingApproval, injectApproval, isApprovalRejected, isPendingApproval, isStepComplete, pendingApproval } from './workflow.cjs';
 import { CollectableEvent, VisualizerOptions, DecisionStartEvent, DecisionBranchEvent, DecisionEndEvent, OutputFormat } from './visualize.cjs';
+export { BatchConfig, BatchOptions, BatchProcessingError, BatchProgress, InvalidBatchConfigError, batchPresets, isBatchProcessingError, isInvalidBatchConfigError, processInBatches } from './batch.cjs';
+export { Resource, ResourceCleanupError, ResourceScope, createResource, createResourceScope, isResourceCleanupError, withScope } from './resource.cjs';
+
+/**
+ * @jagreehal/workflow/tagged-error
+ *
+ * Factory for creating tagged error types with exhaustive pattern matching.
+ * Enables TypeScript to enforce that all error variants are handled.
+ *
+ * @example
+ * ```typescript
+ * // Define error types (Props via generic)
+ * class NotFoundError extends TaggedError("NotFoundError")<{
+ *   id: string;
+ *   resource: string;
+ * }> {}
+ *
+ * // Define with type-safe message (Props inferred from callback annotation)
+ * class ValidationError extends TaggedError("ValidationError", {
+ *   message: (p: { field: string; reason: string }) => `Invalid ${p.field}: ${p.reason}`,
+ * }) {}
+ *
+ * // Create instances
+ * const error = new NotFoundError({ id: "123", resource: "User" });
+ *
+ * // Runtime type check: instanceof TaggedError works!
+ * console.log(error instanceof TaggedError); // true
+ *
+ * // Exhaustive matching
+ * type AppError = NotFoundError | ValidationError;
+ * const message = TaggedError.match(error as AppError, {
+ *   NotFoundError: (e) => `Missing: ${e.resource} ${e.id}`,
+ *   ValidationError: (e) => `Invalid ${e.field}: ${e.reason}`,
+ * });
+ * ```
+ */
+/**
+ * Options for Error constructor (compatible with ES2022 ErrorOptions).
+ */
+interface TaggedErrorOptions {
+    cause?: unknown;
+}
+/**
+ * Options for TaggedError factory with type-safe message callback.
+ */
+interface TaggedErrorCreateOptions<Props extends Record<string, unknown>> {
+    /** Custom message generator from props. Annotate parameter for type safety. */
+    message: (props: Props) => string;
+}
+/**
+ * Base interface for all tagged errors.
+ */
+interface TaggedErrorBase extends Error {
+    readonly _tag: string;
+}
+/**
+ * Instance type for factory-created TaggedErrors.
+ */
+type TaggedErrorInstance<Tag extends string, Props> = TaggedErrorBase & {
+    readonly _tag: Tag;
+} & Readonly<Props>;
+/**
+ * Constructor args type - conditionally optional based on whether Props has required fields.
+ * - If Props is empty or all properties are optional: props argument is optional
+ * - If Props has any required properties: props argument is required
+ * @internal
+ */
+type ConstructorArgs<Props extends Record<string, unknown>> = {} extends Props ? [props?: Props | void, options?: TaggedErrorOptions] : [props: Props, options?: TaggedErrorOptions];
+/**
+ * Constructor type returned by TaggedError factory.
+ */
+interface TaggedErrorConstructor<Tag extends string, Props extends Record<string, unknown>> {
+    new (...args: ConstructorArgs<Props>): TaggedErrorInstance<Tag, Props>;
+    readonly prototype: TaggedErrorInstance<Tag, Props>;
+}
+/**
+ * Generic class factory type that allows `<Props>` parameterization.
+ * This enables the Effect.js-style syntax: `class X extends TaggedError("X")<Props> {}`
+ * @internal
+ */
+interface TaggedErrorClassFactory<Tag extends string> {
+    new <Props extends Record<string, unknown> = Record<string, never>>(...args: ConstructorArgs<Props>): TaggedErrorInstance<Tag, Props>;
+}
+/**
+ * Helper type to extract return type from a function type.
+ * @internal
+ */
+type FnReturnType<T> = T extends (...args: any[]) => infer R ? R : never;
+/**
+ * Helper type to get union of return types from all handlers.
+ * @internal
+ */
+type HandlersReturnType<H> = {
+    [K in keyof H]: FnReturnType<H[K]>;
+}[keyof H];
+/**
+ * Helper type to extract keys whose values are definitely functions (not undefined).
+ * Only excludes a tag from the fallback type if its handler is guaranteed to be
+ * a function. Keys where the value type includes undefined are NOT excluded,
+ * ensuring type safety with dynamic/conditional handlers.
+ * @internal
+ */
+type DefinitelyHandledKeys<H> = {
+    [K in keyof H]-?: undefined extends H[K] ? never : K;
+}[keyof H];
+/**
+ * Factory function to create tagged error classes.
+ *
+ * Two usage patterns:
+ *
+ * 1. **Props via generic** (default message is tag name):
+ *    ```typescript
+ *    class NotFoundError extends TaggedError("NotFoundError")<{ id: string }> {}
+ *    ```
+ *
+ * 2. **Props inferred from message callback** (type-safe message):
+ *    ```typescript
+ *    class NotFoundError extends TaggedError("NotFoundError", {
+ *      message: (p: { id: string }) => `Not found: ${p.id}`,
+ *    }) {}
+ *    ```
+ *
+ * Both support `instanceof TaggedError` checks at runtime.
+ *
+ * @param tag - The unique tag string for this error type
+ * @param options - Optional configuration with message generator (annotate param for type safety)
+ * @returns A class constructor that can be extended
+ */
+declare function TaggedError<Tag extends string>(tag: Tag): TaggedErrorClassFactory<Tag>;
+declare function TaggedError<Tag extends string, Props extends Record<string, unknown>>(tag: Tag, options: TaggedErrorCreateOptions<Props>): TaggedErrorConstructor<Tag, Props>;
+/**
+ * Namespace for static methods on TaggedError.
+ */
+declare namespace TaggedError {
+    /**
+     * Type guard to check if a value is an Error instance.
+     */
+    function isError(value: unknown): value is Error;
+    /**
+     * Type guard to check if a value is a TaggedError instance.
+     * Uses the same check as `instanceof TaggedError` - only genuine
+     * TaggedError instances (created via the factory) pass this guard.
+     */
+    function isTaggedError(value: unknown): value is TaggedErrorBase;
+    /**
+     * Exhaustively matches on a tagged error, requiring handlers for all variants.
+     *
+     * TypeScript will error if any variant in the error union is not handled.
+     *
+     * @param error - The tagged error to match
+     * @param handlers - Object mapping _tag values to handler functions
+     * @returns The return value of the matched handler
+     *
+     * @example
+     * ```typescript
+     * type AppError = NotFoundError | ValidationError;
+     *
+     * const message = TaggedError.match(error, {
+     *   NotFoundError: (e) => `Not found: ${e.id}`,
+     *   ValidationError: (e) => `Invalid: ${e.field}`,
+     * });
+     * ```
+     */
+    function match<E extends TaggedErrorBase, H extends {
+        [K in E["_tag"]]: (e: Extract<E, {
+            _tag: K;
+        }>) => unknown;
+    }>(error: E, handlers: H): HandlersReturnType<H>;
+    /**
+     * Partially matches on a tagged error with a fallback for unhandled variants.
+     *
+     * The fallback receives variants that are NOT definitely handled. A tag is
+     * considered "definitely handled" only if its handler is a function (not
+     * `undefined`). This ensures type safety even with dynamic/conditional handlers:
+     *
+     * ```typescript
+     * const maybeHandle = featureFlag ? (e) => e.id : undefined;
+     * TaggedError.matchPartial(
+     *   error,
+     *   { NotFoundError: maybeHandle },  // maybeHandle might be undefined
+     *   (e) => e._tag  // e correctly includes NotFoundError
+     * );
+     * ```
+     *
+     * @param error - The tagged error to match
+     * @param handlers - Partial object mapping _tag values to handler functions
+     * @param otherwise - Fallback handler for unmatched variants
+     * @returns The return value of the matched handler or fallback
+     *
+     * @example
+     * ```typescript
+     * const message = TaggedError.matchPartial(
+     *   error,
+     *   { NotFoundError: (e) => `Not found: ${e.id}` },
+     *   (e) => `Other error: ${e.message}`
+     * );
+     * ```
+     */
+    function matchPartial<E extends TaggedErrorBase, H extends Partial<{
+        [K in E["_tag"]]: (e: Extract<E, {
+            _tag: K;
+        }>) => unknown;
+    }>, T>(error: E, handlers: H, otherwise: (e: Exclude<E, {
+        _tag: DefinitelyHandledKeys<H>;
+    }>) => T): HandlersReturnType<H> | T;
+}
+
+/**
+ * Helper type to extract the _tag literal type from a TaggedError.
+ *
+ * @example
+ * ```typescript
+ * class MyError extends TaggedError("MyError")<{ id: string }> {}
+ * type Tag = TagOf<MyError>; // "MyError"
+ * ```
+ */
+type TagOf<E extends TaggedErrorBase> = E["_tag"];
+/**
+ * Helper type to extract a specific variant from a TaggedError union by tag.
+ *
+ * @example
+ * ```typescript
+ * type AppError = NotFoundError | ValidationError;
+ * type NotFound = ErrorByTag<AppError, "NotFoundError">; // NotFoundError
+ * ```
+ */
+type ErrorByTag<E extends TaggedErrorBase, Tag extends E["_tag"]> = Extract<E, {
+    _tag: Tag;
+}>;
+/**
+ * Reserved keys that are stripped from user props at runtime.
+ * These keys cannot be used as user-defined properties:
+ * - _tag: discriminant for pattern matching
+ * - name, message, stack: Error internals (preserved for logging/debugging)
+ *
+ * Note: 'cause' is NOT reserved - it can be used as a user prop.
+ */
+type ReservedErrorKeys = "_tag" | "name" | "message" | "stack";
+/**
+ * Helper type to extract props from a TaggedError.
+ * Excludes reserved keys that are stripped at runtime.
+ *
+ * @example
+ * ```typescript
+ * class MyError extends TaggedError("MyError")<{ id: string }> {}
+ * type Props = PropsOf<MyError>; // { id: string }
+ *
+ * // 'cause' is allowed as a user prop
+ * class DomainError extends TaggedError("DomainError")<{ cause: { field: string } }> {}
+ * type DomainProps = PropsOf<DomainError>; // { cause: { field: string } }
+ * ```
+ */
+type PropsOf<E extends TaggedErrorBase> = Omit<E, ReservedErrorKeys>;
 
 /**
  * @jagreehal/workflow/conditional
@@ -35,7 +288,7 @@ type ConditionalOptions = {
 /**
  * Context for conditional execution, used to emit events.
  */
-type ConditionalContext = {
+type ConditionalContext<C = unknown> = {
     /**
      * The workflow ID for event emission.
      */
@@ -43,7 +296,12 @@ type ConditionalContext = {
     /**
      * Event emitter function.
      */
-    onEvent?: (event: WorkflowEvent<unknown>) => void;
+    onEvent?: (event: WorkflowEvent<unknown, C>) => void;
+    /**
+     * Optional context value to include in emitted events.
+     * When provided, this context is automatically added to step_skipped events.
+     */
+    context?: C;
 };
 /**
  * Type for operations that can be either sync or async.
@@ -82,11 +340,11 @@ type Operation<T> = () => MaybeAsync<T>;
  * });
  * ```
  */
-declare function when<T>(condition: boolean, operation: Operation<T>, options?: ConditionalOptions, ctx?: ConditionalContext): Promise<T | undefined>;
+declare function when<T, C = unknown>(condition: boolean, operation: Operation<T>, options?: ConditionalOptions, ctx?: ConditionalContext<C>): Promise<T | undefined>;
 /**
  * Synchronous overload for when the operation returns a non-Promise value.
  */
-declare function when<T>(condition: boolean, operation: () => T, options?: ConditionalOptions, ctx?: ConditionalContext): T | undefined | Promise<T | undefined>;
+declare function when<T, C = unknown>(condition: boolean, operation: () => T, options?: ConditionalOptions, ctx?: ConditionalContext<C>): T | undefined | Promise<T | undefined>;
 /**
  * Run a step only if condition is false, return undefined if skipped.
  *
@@ -115,11 +373,11 @@ declare function when<T>(condition: boolean, operation: () => T, options?: Condi
  * });
  * ```
  */
-declare function unless<T>(condition: boolean, operation: Operation<T>, options?: ConditionalOptions, ctx?: ConditionalContext): Promise<T | undefined>;
+declare function unless<T, C = unknown>(condition: boolean, operation: Operation<T>, options?: ConditionalOptions, ctx?: ConditionalContext<C>): Promise<T | undefined>;
 /**
  * Synchronous overload for unless when the operation returns a non-Promise value.
  */
-declare function unless<T>(condition: boolean, operation: () => T, options?: ConditionalOptions, ctx?: ConditionalContext): T | undefined | Promise<T | undefined>;
+declare function unless<T, C = unknown>(condition: boolean, operation: () => T, options?: ConditionalOptions, ctx?: ConditionalContext<C>): T | undefined | Promise<T | undefined>;
 /**
  * Run a step only if condition is true, return default value if skipped.
  *
@@ -150,11 +408,11 @@ declare function unless<T>(condition: boolean, operation: () => T, options?: Con
  * });
  * ```
  */
-declare function whenOr<T, D>(condition: boolean, operation: Operation<T>, defaultValue: D, options?: ConditionalOptions, ctx?: ConditionalContext): Promise<T | D>;
+declare function whenOr<T, D, C = unknown>(condition: boolean, operation: Operation<T>, defaultValue: D, options?: ConditionalOptions, ctx?: ConditionalContext<C>): Promise<T | D>;
 /**
  * Synchronous overload for whenOr when the operation returns a non-Promise value.
  */
-declare function whenOr<T, D>(condition: boolean, operation: () => T, defaultValue: D, options?: ConditionalOptions, ctx?: ConditionalContext): T | D | Promise<T | D>;
+declare function whenOr<T, D, C = unknown>(condition: boolean, operation: () => T, defaultValue: D, options?: ConditionalOptions, ctx?: ConditionalContext<C>): T | D | Promise<T | D>;
 /**
  * Run a step only if condition is false, return default value if skipped.
  *
@@ -185,24 +443,25 @@ declare function whenOr<T, D>(condition: boolean, operation: () => T, defaultVal
  * });
  * ```
  */
-declare function unlessOr<T, D>(condition: boolean, operation: Operation<T>, defaultValue: D, options?: ConditionalOptions, ctx?: ConditionalContext): Promise<T | D>;
+declare function unlessOr<T, D, C = unknown>(condition: boolean, operation: Operation<T>, defaultValue: D, options?: ConditionalOptions, ctx?: ConditionalContext<C>): Promise<T | D>;
 /**
  * Synchronous overload for unlessOr when the operation returns a non-Promise value.
  */
-declare function unlessOr<T, D>(condition: boolean, operation: () => T, defaultValue: D, options?: ConditionalOptions, ctx?: ConditionalContext): T | D | Promise<T | D>;
+declare function unlessOr<T, D, C = unknown>(condition: boolean, operation: () => T, defaultValue: D, options?: ConditionalOptions, ctx?: ConditionalContext<C>): T | D | Promise<T | D>;
 /**
  * Create a set of conditional helpers bound to a workflow context.
  *
  * Use this factory when you want to automatically emit step_skipped events
  * to the workflow's event stream without passing context manually.
  *
- * @param ctx - The workflow context containing workflowId and onEvent
+ * @param ctx - The workflow context containing workflowId, onEvent, and optional context
  * @returns Object with bound when, unless, whenOr, and unlessOr functions
  *
  * @example
  * ```typescript
+ * // With run() - context is automatically included in events
  * const result = await run(async (step) => {
- *   const ctx = { workflowId, onEvent };
+ *   const ctx = { workflowId, onEvent, context: requestContext };
  *   const { when, whenOr } = createConditionalHelpers(ctx);
  *
  *   const user = await step(fetchUser(id));
@@ -214,10 +473,18 @@ declare function unlessOr<T, D>(condition: boolean, operation: () => T, defaultV
  *   );
  *
  *   return { user, premium };
- * }, { onEvent, workflowId });
+ * }, { onEvent, workflowId, context: requestContext });
+ *
+ * // With createWorkflow - access context from onEvent callback
+ * const workflow = createWorkflow({ fetchUser }, {
+ *   createContext: () => ({ requestId: 'req-123' }),
+ *   onEvent: (event, ctx) => {
+ *     // ctx is available here, can be passed to conditional helpers
+ *   }
+ * });
  * ```
  */
-declare function createConditionalHelpers(ctx: ConditionalContext): {
+declare function createConditionalHelpers<C = unknown>(ctx: ConditionalContext<C>): {
     /**
      * Run a step only if condition is true, return undefined if skipped.
      */
@@ -3263,4 +3530,4 @@ declare function errOutcome<E>(error: E): ScriptedOutcome<never, E>;
  */
 declare function throwOutcome(error: unknown): ScriptedOutcome<never, never>;
 
-export { AnyResultFn$1 as AnyResultFn, type ApprovalStatus, type ApprovalStore, type ApprovalWebhookRequest, type ApprovalWebhookResponse, type AssertionResult, AsyncResult, type AutotelAdapter, type AutotelAdapterConfig, type AutotelMetrics, type AutotelTraceFn, type CircuitBreaker, type CircuitBreakerConfig, type CircuitBreakerStats, CircuitOpenError, type CircuitState, type CombinedLimiterConfig, type CompensationAction, type ConcurrencyLimiter, type ConcurrencyLimiterConfig, type ConcurrencyLimiterStats, type ConditionalContext, type ConditionalOptions, type Devtools, type DevtoolsOptions, type ErrorMapping, type ErrorResponseBody, ErrorsOfDeps$1 as ErrorsOfDeps, type EventHandler, type EventMessage, type EventProcessingResult, type EventTriggerConfig, type ExpressLikeRequest, type ExpressLikeResponse, type FileCacheOptions, type FileSystemInterface, type HITLExecutionResult, type HITLOrchestrator, type HITLOrchestratorOptions, type HITLWorkflowFactoryOptions, type KVCacheOptions, type KeyValueStore, type MemoryCacheOptions, type MigrationError, type MigrationFn, type Migrations, type MockFunction, type MockStep, type NamedPolicy, type Policy, type PolicyFactory, type PolicyRegistry, type PollerOptions, type QueueFullError, type RateLimitExceededError, type RateLimiter, type RateLimiterConfig, type RateLimiterStats, Result, ResumeState, ResumeStateEntry, RetryOptions, type RunDiff, type SagaCompensationError, type SagaContext, type SagaEvent, type SagaResult, type SagaStepOptions, type SagaWorkflowOptions, type SavedWorkflowState, type ScriptedOutcome, type SerializedCause, type SerializedEntry, type SerializedMeta, type SerializedResult, type SerializedState, type SimpleHandlerConfig, type StatePersistence, StepCache, type StepDiff, type StepInvocation, StepOptions, type StepOptionsBuilder, type TestHarnessOptions, type TimelineEntry, TimeoutOptions, UnexpectedError, type ValidationError, type ValidationResult, type Version, type VersionIncompatibleError, type VersionedState, type VersionedWorkflowConfig, type WebhookHandler, type WebhookHandlerConfig, type WebhookRequest, type WebhookResponse, type WithPoliciesOptions, Workflow, WorkflowEvent, type WorkflowHarness, type WorkflowRun, type WorkflowSnapshot, type WorkflowStateStore, WorkflowStrict, circuitBreakerPresets, compareSnapshots, composeMigrations, composeValidators, conditionalPolicy, createApprovalChecker, createApprovalWebhookHandler, createAutotelAdapter, createAutotelEventHandler, createCircuitBreaker, createCombinedLimiter, createConcurrencyLimiter, createConditionalHelpers, createConsoleLogger, createDevtools, createEventHandler, createExpressHandler, createFileCache, createHITLOrchestrator, createHydratingCache, createKVCache, createKeyRemoveMigration, createKeyRenameMigration, createMemoryApprovalStore, createMemoryCache, createMemoryWorkflowStateStore, createMockFn, createPolicyApplier, createPolicyBundle, createPolicyRegistry, createRateLimiter, createResultMapper, createSagaWorkflow, createSimpleHandler, createSnapshot, createStatePersistence, createTestClock, createValueTransformMigration, createVersionedState, createVersionedStateLoader, createWebhookHandler, createWorkflowHarness, defaultUnexpectedErrorMapper, defaultValidationErrorMapper, deserializeCause, deserializeEntry, deserializeMeta, deserializeResult, deserializeState, envPolicy, errOutcome, isCircuitOpenError, isMigrationError, isQueueFullError, isRateLimitExceededError, isSagaCompensationError, isValidationError, isVersionIncompatibleError, mergePolicies, migrateState, okOutcome, parseState, parseVersionedState, quickVisualize, rateLimiterPresets, renderDiff, requireFields, retryPolicies, retryPolicy, runSaga, sendWebhookResponse, serializeCause, serializeEntry, serializeMeta, serializeResult, serializeState, servicePolicies, stepOptions, stringifyState, stringifyVersionedState, throwOutcome, timeoutPolicies, timeoutPolicy, toWebhookRequest, unless, unlessOr, validationError, when, whenOr, withAutotelTracing, withPolicies, withPolicy };
+export { AnyResultFn$1 as AnyResultFn, type ApprovalStatus, type ApprovalStore, type ApprovalWebhookRequest, type ApprovalWebhookResponse, type AssertionResult, AsyncResult, type AutotelAdapter, type AutotelAdapterConfig, type AutotelMetrics, type AutotelTraceFn, type CircuitBreaker, type CircuitBreakerConfig, type CircuitBreakerStats, CircuitOpenError, type CircuitState, type CombinedLimiterConfig, type CompensationAction, type ConcurrencyLimiter, type ConcurrencyLimiterConfig, type ConcurrencyLimiterStats, type ConditionalContext, type ConditionalOptions, type Devtools, type DevtoolsOptions, type ErrorByTag, type ErrorMapping, type ErrorResponseBody, ErrorsOfDeps$1 as ErrorsOfDeps, type EventHandler, type EventMessage, type EventProcessingResult, type EventTriggerConfig, type ExpressLikeRequest, type ExpressLikeResponse, type FileCacheOptions, type FileSystemInterface, type HITLExecutionResult, type HITLOrchestrator, type HITLOrchestratorOptions, type HITLWorkflowFactoryOptions, type KVCacheOptions, type KeyValueStore, type MemoryCacheOptions, type MigrationError, type MigrationFn, type Migrations, type MockFunction, type MockStep, type NamedPolicy, type Policy, type PolicyFactory, type PolicyRegistry, type PollerOptions, type PropsOf, type QueueFullError, type RateLimitExceededError, type RateLimiter, type RateLimiterConfig, type RateLimiterStats, Result, ResumeState, ResumeStateEntry, RetryOptions, type RunDiff, type SagaCompensationError, type SagaContext, type SagaEvent, type SagaResult, type SagaStepOptions, type SagaWorkflowOptions, type SavedWorkflowState, type ScriptedOutcome, type SerializedCause, type SerializedEntry, type SerializedMeta, type SerializedResult, type SerializedState, type SimpleHandlerConfig, type StatePersistence, StepCache, type StepDiff, type StepInvocation, StepOptions, type StepOptionsBuilder, type TagOf, TaggedError, type TaggedErrorBase, type TaggedErrorConstructor, type TaggedErrorCreateOptions, type TaggedErrorOptions, type TestHarnessOptions, type TimelineEntry, TimeoutOptions, UnexpectedError, type ValidationError, type ValidationResult, type Version, type VersionIncompatibleError, type VersionedState, type VersionedWorkflowConfig, type WebhookHandler, type WebhookHandlerConfig, type WebhookRequest, type WebhookResponse, type WithPoliciesOptions, Workflow, WorkflowEvent, type WorkflowHarness, type WorkflowRun, type WorkflowSnapshot, type WorkflowStateStore, WorkflowStrict, circuitBreakerPresets, compareSnapshots, composeMigrations, composeValidators, conditionalPolicy, createApprovalChecker, createApprovalWebhookHandler, createAutotelAdapter, createAutotelEventHandler, createCircuitBreaker, createCombinedLimiter, createConcurrencyLimiter, createConditionalHelpers, createConsoleLogger, createDevtools, createEventHandler, createExpressHandler, createFileCache, createHITLOrchestrator, createHydratingCache, createKVCache, createKeyRemoveMigration, createKeyRenameMigration, createMemoryApprovalStore, createMemoryCache, createMemoryWorkflowStateStore, createMockFn, createPolicyApplier, createPolicyBundle, createPolicyRegistry, createRateLimiter, createResultMapper, createSagaWorkflow, createSimpleHandler, createSnapshot, createStatePersistence, createTestClock, createValueTransformMigration, createVersionedState, createVersionedStateLoader, createWebhookHandler, createWorkflowHarness, defaultUnexpectedErrorMapper, defaultValidationErrorMapper, deserializeCause, deserializeEntry, deserializeMeta, deserializeResult, deserializeState, envPolicy, errOutcome, isCircuitOpenError, isMigrationError, isQueueFullError, isRateLimitExceededError, isSagaCompensationError, isValidationError, isVersionIncompatibleError, mergePolicies, migrateState, okOutcome, parseState, parseVersionedState, quickVisualize, rateLimiterPresets, renderDiff, requireFields, retryPolicies, retryPolicy, runSaga, sendWebhookResponse, serializeCause, serializeEntry, serializeMeta, serializeResult, serializeState, servicePolicies, stepOptions, stringifyState, stringifyVersionedState, throwOutcome, timeoutPolicies, timeoutPolicy, toWebhookRequest, unless, unlessOr, validationError, when, whenOr, withAutotelTracing, withPolicies, withPolicy };