awaitly 1.34.0 → 2.0.0

package/dist/result/retry.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/slugs.ts","../../src/tagged-error.ts","../../src/errors.ts","../../src/result/index.ts","../../src/result/retry.ts"],"sourcesContent":["/**\n * awaitly/slugs\n *\n * Source-of-truth slug namespace. Every concept that surfaces as a runtime\n * error, lint rule, static-analyzer diagnostic, visualizer event, or skill rule\n * has exactly one canonical kebab-case slug here.\n *\n * Slugs are public API. Renames are a major version bump. Adds are non-breaking.\n *\n * Categories:\n * - step-*       step() discipline\n * - workflow-*   createWorkflow / run / runWithState shape\n * - result-*     Result usage\n * - error-*      Boundary handling\n * - concurrency-* step.all/map/race vs Promise.*\n * - runtime-*    Failures only observable at runtime\n */\n\nexport const AWAITLY_SLUGS = {\n  // --- step-* ---\n  \"step-require-id\": \"step-require-id\",\n  \"step-no-immediate-execution\": \"step-no-immediate-execution\",\n  \"step-require-thunk-for-key\": \"step-require-thunk-for-key\",\n  \"step-no-bare-await\": \"step-no-bare-await\",\n  \"step-no-try-catch-wrap\": \"step-no-try-catch-wrap\",\n  \"step-stable-cache-keys\": \"step-stable-cache-keys\",\n\n  // --- workflow-* ---\n  \"workflow-no-floating\": \"workflow-no-floating\",\n  \"workflow-options-position\": \"workflow-options-position\",\n  \"workflow-callback-shape\": \"workflow-callback-shape\",\n  \"workflow-no-callable-form\": \"workflow-no-callable-form\",\n  \"workflow-no-dynamic-import\": \"workflow-no-dynamic-import\",\n\n  // --- result-* ---\n  \"result-no-floating\": \"result-no-floating\",\n  \"result-require-handling\": \"result-require-handling\",\n  \"result-no-double-wrap\": \"result-no-double-wrap\",\n  \"result-no-manual-propagation\": \"result-no-manual-propagation\",\n  \"result-no-direct-ok-err\": \"result-no-direct-ok-err\",\n\n  // --- error-* ---\n  \"error-check-unexpected-first\": \"error-check-unexpected-first\",\n  \"error-access-cause\": \"error-access-cause\",\n  \"error-normalize\": \"error-normalize\",\n  \"error-no-throw-in-deps\": \"error-no-throw-in-deps\",\n\n  // --- concurrency-* ---\n  \"concurrency-no-promise-all\": \"concurrency-no-promise-all\",\n  \"concurrency-no-promise-race\": \"concurrency-no-promise-race\",\n  \"concurrency-no-promise-allsettled\": \"concurrency-no-promise-allsettled\",\n\n  // --- runtime-* ---\n  \"runtime-step-timeout\": \"runtime-step-timeout\",\n  \"runtime-step-aborted\": \"runtime-step-aborted\",\n  \"runtime-retry-exhausted\": \"runtime-retry-exhausted\",\n  \"runtime-rate-limit\": \"runtime-rate-limit\",\n  \"runtime-circuit-open\": \"runtime-circuit-open\",\n  \"runtime-unexpected\": \"runtime-unexpected\",\n  \"runtime-resolver-not-found\": \"runtime-resolver-not-found\",\n  \"runtime-saga-compensation\": \"runtime-saga-compensation\",\n} as const;\n\n/** All canonical awaitly slugs as a string-literal union. */\nexport type AwaitlySlug = keyof typeof AWAITLY_SLUGS;\n\n/** Categories derived from slug prefixes. */\nexport type AwaitlySlugCategory =\n  | \"step\"\n  | \"workflow\"\n  | \"result\"\n  | \"error\"\n  | \"concurrency\"\n  | \"runtime\";\n\n/** Returns the category (prefix) of a slug. */\nexport function slugCategory(slug: AwaitlySlug): AwaitlySlugCategory {\n  return slug.split(\"-\")[0] as AwaitlySlugCategory;\n}\n\n/**\n * Returns the canonical docs URL for a slug. Resolves to the matching\n * anchored section on the consolidated rule index page.\n */\nexport function slugDocsUrl(slug: AwaitlySlug): string {\n  return `https://jagreehal.github.io/awaitly/rules/#${slug}`;\n}\n\n/** Type guard: is a string a known awaitly slug? */\nexport function isAwaitlySlug(value: string): value is AwaitlySlug {\n  return Object.prototype.hasOwnProperty.call(AWAITLY_SLUGS, value);\n}\n\n/** All slugs as an array. */\n// Object.keys returns string[] — cast is safe because AWAITLY_SLUGS is `as const`\n// and the module's keys are never mutated.\nexport const ALL_SLUGS: readonly AwaitlySlug[] = Object.keys(\n  AWAITLY_SLUGS\n) as AwaitlySlug[];\n","/**\n * awaitly/tagged-error\n *\n * Factory for creating tagged error types with exhaustive pattern matching.\n * Enables TypeScript to enforce that all error variants are handled.\n *\n * @example\n * ```typescript\n * // Define error types (Props via generic)\n * class NotFoundError extends TaggedError(\"NotFoundError\")<{\n *   id: string;\n *   resource: string;\n * }> {}\n *\n * // Define with type-safe message (Props inferred from callback annotation)\n * class ValidationError extends TaggedError(\"ValidationError\", {\n *   message: (p: { field: string; reason: string }) => `Invalid ${p.field}: ${p.reason}`,\n * }) {}\n *\n * // Create instances\n * const error = new NotFoundError({ id: \"123\", resource: \"User\" });\n *\n * // Runtime type check: instanceof TaggedError works!\n * console.log(error instanceof TaggedError); // true\n *\n * // Exhaustive matching\n * type AppError = NotFoundError | ValidationError;\n * const message = TaggedError.match(error as AppError, {\n *   NotFoundError: (e) => `Missing: ${e.resource} ${e.id}`,\n *   ValidationError: (e) => `Invalid ${e.field}: ${e.reason}`,\n * });\n * ```\n */\n\nimport { type AwaitlySlug, slugDocsUrl } from \"./slugs\";\n\n/**\n * Options for Error constructor (compatible with ES2022 ErrorOptions).\n */\nexport interface TaggedErrorOptions {\n  cause?: unknown;\n}\n\n/**\n * Options for TaggedError factory with type-safe message callback.\n */\nexport interface TaggedErrorCreateOptions<Props extends Record<string, unknown>> {\n  /** Custom message generator from props. Annotate parameter for type safety. */\n  message: (props: Props) => string;\n  /**\n   * Canonical awaitly slug for this error class. When set, instances carry\n   * `code`, `hint`, and `docsUrl` populated from the slugs namespace.\n   * Required together with `hint` for awaitly-system errors.\n   */\n  slug?: AwaitlySlug;\n  /**\n   * One-line \"do X instead\" guidance shown alongside the error.\n   * Required when `slug` is set.\n   */\n  hint?: string;\n}\n\n/**\n * Base interface for all tagged errors.\n */\nexport interface TaggedErrorBase extends Error {\n  readonly _tag: string;\n  /** Canonical slug for awaitly-system errors. Undefined for user errors that opt out. */\n  readonly code?: AwaitlySlug;\n  /** One-line guidance. Undefined when no slug is set. */\n  readonly hint?: string;\n  /** Canonical docs URL. Undefined when no slug is set. */\n  readonly docsUrl?: string;\n}\n\n/**\n * Internal base class for instanceof checks.\n * All TaggedError-created classes extend this.\n * @internal\n */\nclass InternalTaggedErrorBase extends Error implements TaggedErrorBase {\n  readonly _tag!: string;\n}\n\n/**\n * Instance type for factory-created TaggedErrors.\n */\ntype TaggedErrorInstance<Tag extends string, Props> = TaggedErrorBase & {\n  readonly _tag: Tag;\n} & Readonly<Props>;\n\n/**\n * Constructor args type - conditionally optional based on whether Props has required fields.\n * - If Props is empty or all properties are optional: props argument is optional\n * - If Props has any required properties: props argument is required\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/no-empty-object-type\ntype ConstructorArgs<Props extends Record<string, unknown>> = {} extends Props\n  ? [props?: Props | void, options?: TaggedErrorOptions]\n  : [props: Props, options?: TaggedErrorOptions];\n\n/**\n * Constructor type returned by TaggedError factory.\n */\nexport interface TaggedErrorConstructor<\n  Tag extends string,\n  Props extends Record<string, unknown>,\n> {\n  new (...args: ConstructorArgs<Props>): TaggedErrorInstance<Tag, Props>;\n  readonly prototype: TaggedErrorInstance<Tag, Props>;\n}\n\n/**\n * Generic class factory type that allows `<Props>` parameterization.\n * This enables the Effect.js-style syntax: `class X extends TaggedError(\"X\")<Props> {}`\n * @internal\n */\nexport interface TaggedErrorClassFactory<Tag extends string> {\n  new <Props extends Record<string, unknown> = Record<string, never>>(\n    ...args: ConstructorArgs<Props>\n  ): TaggedErrorInstance<Tag, Props>;\n}\n\n/**\n * Helper type to extract return type from a function type.\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype FnReturnType<T> = T extends (...args: any[]) => infer R ? R : never;\n\n/**\n * Helper type to get union of return types from all handlers.\n * @internal\n */\ntype HandlersReturnType<H> = { [K in keyof H]: FnReturnType<H[K]> }[keyof H];\n\n/**\n * Helper type to extract keys whose values are definitely functions (not undefined).\n * Only excludes a tag from the fallback type if its handler is guaranteed to be\n * a function. Keys where the value type includes undefined are NOT excluded,\n * ensuring type safety with dynamic/conditional handlers.\n * @internal\n */\ntype DefinitelyHandledKeys<H> = {\n  [K in keyof H]-?: undefined extends H[K] ? never : K;\n}[keyof H];\n\n/**\n * Factory function to create tagged error classes.\n *\n * Two usage patterns:\n *\n * 1. **Props via generic** (default message is tag name):\n *    ```typescript\n *    class NotFoundError extends TaggedError(\"NotFoundError\")<{ id: string }> {}\n *    ```\n *\n * 2. **Props inferred from message callback** (type-safe message):\n *    ```typescript\n *    class NotFoundError extends TaggedError(\"NotFoundError\", {\n *      message: (p: { id: string }) => `Not found: ${p.id}`,\n *    }) {}\n *    ```\n *\n * Both support `instanceof TaggedError` checks at runtime.\n *\n * @param tag - The unique tag string for this error type\n * @param options - Optional configuration with message generator (annotate param for type safety)\n * @returns A class constructor that can be extended\n */\n\n// Overload 1: No options - use <Props> generic syntax, default message is tag\nfunction TaggedError<Tag extends string>(\n  tag: Tag\n): TaggedErrorClassFactory<Tag>;\n\n// Overload 2: With message option - Props inferred from callback parameter annotation\nfunction TaggedError<Tag extends string, Props extends Record<string, unknown>>(\n  tag: Tag,\n  options: TaggedErrorCreateOptions<Props>\n): TaggedErrorConstructor<Tag, Props>;\n\n// Implementation\nfunction TaggedError<Tag extends string, Props extends Record<string, unknown>>(\n  tag: Tag,\n  options?: TaggedErrorCreateOptions<Props>\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n): any {\n  return class extends InternalTaggedErrorBase {\n    override readonly _tag: Tag = tag;\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    constructor(props?: any, errorOptions?: TaggedErrorOptions) {\n      // Generate message: call callback if provided (even for prop-less errors), else use tag\n      const message = options?.message ? options.message(props ?? {}) : tag;\n\n      super(message);\n      this.name = tag;\n\n      // Spine fields: populate when factory was given a slug\n      if (options?.slug !== undefined) {\n        if (!options.hint) {\n          throw new TypeError(\n            `TaggedError: 'hint' is required when 'slug' is set (slug: \"${options.slug}\")`\n          );\n        }\n        Object.defineProperty(this, \"code\", {\n          value: options.slug,\n          enumerable: true,\n          writable: false,\n          configurable: false,\n        });\n        Object.defineProperty(this, \"hint\", {\n          value: options.hint,\n          enumerable: true,\n          writable: false,\n          configurable: false,\n        });\n        Object.defineProperty(this, \"docsUrl\", {\n          value: slugDocsUrl(options.slug),\n          enumerable: true,\n          writable: false,\n          configurable: false,\n        });\n      }\n\n      // Maintains proper prototype chain for instanceof checks\n      Object.setPrototypeOf(this, new.target.prototype);\n\n      // Assign props to instance, stripping reserved keys:\n      // - _tag: discriminant for pattern matching (cannot be forged)\n      // - name, message, stack: Error internals (preserve for logging/debugging)\n      // - code, hint, docsUrl: spine fields stripped when slug is set, to prevent\n      //   Object.assign from clobbering the non-configurable/non-writable own props\n      // Note: 'cause' is allowed as a user prop (common for domain errors)\n      if (props && typeof props === \"object\") {\n        let safeProps: Record<string, unknown>;\n        if (options?.slug !== undefined) {\n          const {\n            _tag: _,\n            name: _n,\n            message: _m,\n            stack: _s,\n            code: _c,\n            hint: _h,\n            docsUrl: _d,\n            ...rest\n          } = props;\n          safeProps = rest;\n        } else {\n          const {\n            _tag: _,\n            name: _n,\n            message: _m,\n            stack: _s,\n            ...rest\n          } = props;\n          safeProps = rest;\n        }\n\n        const hasUserCause = Object.prototype.hasOwnProperty.call(\n          safeProps,\n          \"cause\"\n        );\n        const userCause = hasUserCause\n          ? (safeProps as { cause?: unknown }).cause\n          : undefined;\n        if (hasUserCause) {\n          delete (safeProps as { cause?: unknown }).cause;\n        }\n\n        const hasOptionsCause = errorOptions?.cause !== undefined;\n        if (hasUserCause && hasOptionsCause) {\n          throw new TypeError(\n            \"TaggedError: cannot provide 'cause' in props when also setting ErrorOptions.cause\"\n          );\n        }\n\n        Object.assign(this, safeProps);\n\n        if (hasUserCause) {\n          (this as { cause?: unknown }).cause = userCause;\n        }\n        if (hasOptionsCause) {\n          (this as { cause?: unknown }).cause = errorOptions?.cause;\n        }\n      } else if (errorOptions?.cause !== undefined) {\n        (this as { cause?: unknown }).cause = errorOptions.cause;\n      }\n    }\n  };\n}\n\n// Add Symbol.hasInstance so `instanceof TaggedError` works\nObject.defineProperty(TaggedError, Symbol.hasInstance, {\n  value: (instance: unknown): boolean => instance instanceof InternalTaggedErrorBase,\n});\n\n/**\n * Namespace for static methods on TaggedError.\n */\n// eslint-disable-next-line @typescript-eslint/no-namespace\nnamespace TaggedError {\n  /**\n   * Type guard to check if a value is an Error instance.\n   */\n  export function isError(value: unknown): value is Error {\n    return value instanceof Error;\n  }\n\n  /**\n   * Type guard to check if a value is a TaggedError instance.\n   * Uses the same check as `instanceof TaggedError` - only genuine\n   * TaggedError instances (created via the factory) pass this guard.\n   */\n  export function isTaggedError(value: unknown): value is TaggedErrorBase {\n    return value instanceof InternalTaggedErrorBase;\n  }\n\n  /**\n   * Exhaustively matches on a tagged error, requiring handlers for all variants.\n   *\n   * TypeScript will error if any variant in the error union is not handled.\n   *\n   * @remarks When to use: You want compile-time enforcement that every tagged variant is handled.\n   *\n   * @param error - The tagged error to match\n   * @param handlers - Object mapping _tag values to handler functions\n   * @returns The return value of the matched handler\n   *\n   * @example\n   * ```typescript\n   * type AppError = NotFoundError | ValidationError;\n   *\n   * const message = TaggedError.match(error, {\n   *   NotFoundError: (e) => `Not found: ${e.id}`,\n   *   ValidationError: (e) => `Invalid: ${e.field}`,\n   * });\n   * ```\n   */\n  export function match<\n    E extends TaggedErrorBase,\n    H extends { [K in E[\"_tag\"]]: (e: Extract<E, { _tag: K }>) => unknown },\n  >(error: E, handlers: H): HandlersReturnType<H> {\n    const tag = error._tag as E[\"_tag\"];\n    const handler = handlers[tag];\n    return handler(\n      error as Extract<E, { _tag: typeof tag }>\n    ) as HandlersReturnType<H>;\n  }\n\n  /**\n   * Partially matches on a tagged error with a fallback for unhandled variants.\n   *\n   * The fallback receives variants that are NOT definitely handled. A tag is\n   * considered \"definitely handled\" only if its handler is a function (not\n   * `undefined`). This ensures type safety even with dynamic/conditional handlers:\n   *\n   * ```typescript\n   * const maybeHandle = featureFlag ? (e) => e.id : undefined;\n   * TaggedError.matchPartial(\n   *   error,\n   *   { NotFoundError: maybeHandle },  // maybeHandle might be undefined\n   *   (e) => e._tag  // e correctly includes NotFoundError\n   * );\n   * ```\n   *\n   * @param error - The tagged error to match\n   * @param handlers - Partial object mapping _tag values to handler functions\n   * @param otherwise - Fallback handler for unmatched variants\n   * @returns The return value of the matched handler or fallback\n   *\n   * @example\n   * ```typescript\n   * const message = TaggedError.matchPartial(\n   *   error,\n   *   { NotFoundError: (e) => `Not found: ${e.id}` },\n   *   (e) => `Other error: ${e.message}`\n   * );\n   * ```\n   */\n  export function matchPartial<\n    E extends TaggedErrorBase,\n    H extends Partial<{\n      [K in E[\"_tag\"]]: (e: Extract<E, { _tag: K }>) => unknown;\n    }>,\n    T,\n  >(\n    error: E,\n    handlers: H,\n    otherwise: (e: Exclude<E, { _tag: DefinitelyHandledKeys<H> }>) => T\n  ): HandlersReturnType<H> | T {\n    const tag = error._tag as E[\"_tag\"];\n    const handler = handlers[tag];\n    if (handler) {\n      return handler(\n        error as Extract<E, { _tag: typeof tag }>\n      ) as HandlersReturnType<H>;\n    }\n    return otherwise(error as Exclude<E, { _tag: DefinitelyHandledKeys<H> }>);\n  }\n}\n\nexport { TaggedError };\n\n/**\n * Helper type to extract the _tag literal type from a TaggedError.\n *\n * @example\n * ```typescript\n * class MyError extends TaggedError(\"MyError\")<{ id: string }> {}\n * type Tag = TagOf<MyError>; // \"MyError\"\n * ```\n */\nexport type TagOf<E extends TaggedErrorBase> = E[\"_tag\"];\n\n/**\n * Helper type to extract a specific variant from a TaggedError union by tag.\n *\n * @example\n * ```typescript\n * type AppError = NotFoundError | ValidationError;\n * type NotFound = ErrorByTag<AppError, \"NotFoundError\">; // NotFoundError\n * ```\n */\nexport type ErrorByTag<\n  E extends TaggedErrorBase,\n  Tag extends E[\"_tag\"],\n> = Extract<E, { _tag: Tag }>;\n\n/**\n * Reserved keys that are stripped from user props at runtime.\n * These keys cannot be used as user-defined properties:\n * - _tag: discriminant for pattern matching\n * - name, message, stack: Error internals (preserved for logging/debugging)\n * - code, hint, docsUrl: spine fields (non-configurable own properties when slug is set)\n *\n * Note: 'cause' is NOT reserved - it can be used as a user prop.\n */\ntype ReservedErrorKeys = \"_tag\" | \"name\" | \"message\" | \"stack\" | \"code\" | \"hint\" | \"docsUrl\";\n\n/**\n * Helper type to extract props from a TaggedError.\n * Excludes reserved keys that are stripped at runtime.\n *\n * @example\n * ```typescript\n * class MyError extends TaggedError(\"MyError\")<{ id: string }> {}\n * type Props = PropsOf<MyError>; // { id: string }\n *\n * // 'cause' is allowed as a user prop\n * class DomainError extends TaggedError(\"DomainError\")<{ cause: { field: string } }> {}\n * type DomainProps = PropsOf<DomainError>; // { cause: { field: string } }\n * ```\n */\nexport type PropsOf<E extends TaggedErrorBase> = Omit<E, ReservedErrorKeys>;\n","/**\n * awaitly/errors\n *\n * Pre-built error types for common failure scenarios.\n * Uses TaggedError for type-safe exhaustive matching.\n *\n * @example\n * ```typescript\n * import { TimeoutError, RetryExhaustedError, RateLimitError, CircuitBreakerOpenError } from 'awaitly/errors';\n *\n * // Create errors\n * const timeout = new TimeoutError({ operation: 'fetchUser', ms: 5000 });\n * const retryFailed = new RetryExhaustedError({ operation: 'sendEmail', attempts: 3 });\n *\n * // Pattern match\n * TaggedError.match(error, {\n *   TimeoutError: (e) => `${e.operation} timed out after ${e.ms}ms`,\n *   RetryExhaustedError: (e) => `${e.operation} failed after ${e.attempts} attempts`,\n *   RateLimitError: (e) => `Rate limit exceeded, retry after ${e.retryAfterMs}ms`,\n *   CircuitBreakerOpenError: (e) => `Circuit ${e.circuitName} is open`,\n * });\n * ```\n */\n\n/**\n * Spine policy:\n *\n * Awaitly-system errors (raised by awaitly internals on workflow execution\n * failure modes) carry a `slug` + `hint` so they participate in the\n * AI-DX spine: TimeoutError, RetryExhaustedError, RateLimitError,\n * CircuitBreakerOpenError, CompensationError, UnexpectedError.\n *\n * Convenience domain errors (ValidationError, NotFoundError,\n * UnauthorizedError, NetworkError) are deliberately NOT slugged — they\n * represent USER domain failures and would force user code into the\n * awaitly slug namespace. Users can opt in by adding `slug` + `hint`\n * to their own TaggedError subclasses.\n */\n\nimport { TaggedError } from \"./tagged-error\";\n\n// =============================================================================\n// Error Factory\n// =============================================================================\n\n/**\n * Factory function to create tagged error classes with default values.\n *\n * This is a convenience wrapper around TaggedError that allows specifying\n * default property values for error types.\n *\n * @example\n * ```typescript\n * const NetworkError = makeError('NetworkError', {\n *   defaults: { retryable: true },\n *   message: (p) => `Network error: ${p.reason}`,\n * });\n *\n * class MyNetworkError extends NetworkError<{ reason: string; code?: number }> {}\n * ```\n */\nexport function makeError<Tag extends string>(\n  tag: Tag,\n  options?: {\n    message?: (props: Record<string, unknown>) => string;\n    defaults?: Record<string, unknown>;\n  }\n) {\n  const messageGenerator = options?.message ?? (() => tag);\n  const defaults = options?.defaults ?? {};\n\n  const BaseClass = TaggedError(tag, {\n    message: (props: Record<string, unknown>) =>\n      messageGenerator({ ...defaults, ...props }),\n  });\n\n  return class extends BaseClass {\n    constructor(props?: Record<string, unknown>) {\n      super({ ...defaults, ...props } as Record<string, unknown>);\n      Object.assign(this, { ...defaults, ...props });\n    }\n  };\n}\n\n// =============================================================================\n// Pre-built Error Types\n// =============================================================================\n\n/**\n * Error thrown when an operation times out.\n *\n * @example\n * ```typescript\n * const error = new TimeoutError({\n *   operation: 'fetchUser',\n *   ms: 5000,\n * });\n * console.log(error.message); // \"TimeoutError: fetchUser timed out after 5000ms\"\n * ```\n */\nexport class TimeoutError extends TaggedError(\"TimeoutError\", {\n  slug: \"runtime-step-timeout\",\n  hint: \"Increase the step's timeout option, or check why the upstream operation is slow.\",\n  message: (p: {\n    /** Name of the operation that timed out */\n    operation?: string;\n    /** Timeout duration in milliseconds */\n    ms: number;\n  }) =>\n    p.operation\n      ? `TimeoutError: ${p.operation} timed out after ${p.ms}ms`\n      : `TimeoutError: Operation timed out after ${p.ms}ms`,\n}) {}\n\n/**\n * Error thrown when all retry attempts are exhausted.\n *\n * @example\n * ```typescript\n * const error = new RetryExhaustedError({\n *   operation: 'sendEmail',\n *   attempts: 3,\n *   lastError: originalError,\n * });\n * console.log(error.message); // \"RetryExhaustedError: sendEmail failed after 3 attempts\"\n * ```\n */\nexport class RetryExhaustedError extends TaggedError(\"RetryExhaustedError\", {\n  slug: \"runtime-retry-exhausted\",\n  hint: \"All retry attempts failed. Inspect lastError and decide whether to surface it or compensate.\",\n  message: (p: {\n    /** Name of the operation that failed */\n    operation?: string;\n    /** Total number of retry attempts made */\n    attempts: number;\n    /** The last error encountered before giving up */\n    lastError?: unknown;\n  }) =>\n    p.operation\n      ? `RetryExhaustedError: ${p.operation} failed after ${p.attempts} attempts`\n      : `RetryExhaustedError: Operation failed after ${p.attempts} attempts`,\n}) {}\n\n/**\n * Error thrown when a rate limit is exceeded.\n *\n * @example\n * ```typescript\n * const error = new RateLimitError({\n *   limiterName: 'api-calls',\n *   retryAfterMs: 1000,\n * });\n * console.log(error.message); // \"RateLimitError: Rate limit exceeded for api-calls\"\n * ```\n */\nexport class RateLimitError extends TaggedError(\"RateLimitError\", {\n  slug: \"runtime-rate-limit\",\n  hint: \"Wait retryAfterMs before retrying, or apply step.cache to deduplicate calls.\",\n  message: (p: {\n    /** Name of the rate limiter that was exceeded */\n    limiterName?: string;\n    /** Time in milliseconds until the rate limit resets */\n    retryAfterMs?: number;\n  }) =>\n    p.limiterName\n      ? `RateLimitError: Rate limit exceeded for ${p.limiterName}${p.retryAfterMs ? `, retry after ${p.retryAfterMs}ms` : \"\"}`\n      : `RateLimitError: Rate limit exceeded${p.retryAfterMs ? `, retry after ${p.retryAfterMs}ms` : \"\"}`,\n}) {}\n\n/**\n * Error thrown when a circuit breaker is open.\n *\n * @example\n * ```typescript\n * const error = new CircuitBreakerOpenError({\n *   circuitName: 'payment-api',\n *   state: 'OPEN',\n *   retryAfterMs: 30000,\n * });\n * console.log(error.message); // \"CircuitBreakerOpenError: Circuit payment-api is OPEN\"\n * ```\n */\nexport class CircuitBreakerOpenError extends TaggedError(\n  \"CircuitBreakerOpenError\",\n  {\n    slug: \"runtime-circuit-open\",\n    hint: \"The circuit is open. Wait for it to half-open or fall back to a degraded path.\",\n    message: (p: {\n      /** Name of the circuit breaker */\n      circuitName: string;\n      /** Current state of the circuit */\n      state?: \"OPEN\" | \"HALF_OPEN\";\n      /** Time in milliseconds until the circuit may close */\n      retryAfterMs?: number;\n    }) =>\n      `CircuitBreakerOpenError: Circuit ${p.circuitName} is ${p.state ?? \"OPEN\"}${p.retryAfterMs ? `, retry after ${Math.ceil(p.retryAfterMs / 1000)}s` : \"\"}`,\n  }\n) {}\n\n/**\n * Error thrown when validation fails.\n *\n * @example\n * ```typescript\n * const error = new ValidationError({\n *   field: 'email',\n *   reason: 'Invalid email format',\n * });\n * console.log(error.message); // \"ValidationError: Invalid email - Invalid email format\"\n * ```\n */\nexport class ValidationError extends TaggedError(\"ValidationError\", {\n  message: (p: {\n    /** Field that failed validation */\n    field: string;\n    /** Reason for validation failure */\n    reason: string;\n    /** Raw value that failed validation */\n    value?: unknown;\n  }) => `ValidationError: Invalid ${p.field} - ${p.reason}`,\n}) {}\n\n/**\n * Error thrown when a resource is not found.\n *\n * @example\n * ```typescript\n * const error = new NotFoundError({\n *   resource: 'User',\n *   id: '123',\n * });\n * console.log(error.message); // \"NotFoundError: User with id 123 not found\"\n * ```\n */\nexport class NotFoundError extends TaggedError(\"NotFoundError\", {\n  message: (p: {\n    /** Type of resource that was not found */\n    resource: string;\n    /** Identifier of the missing resource */\n    id?: string;\n  }) =>\n    p.id\n      ? `NotFoundError: ${p.resource} with id ${p.id} not found`\n      : `NotFoundError: ${p.resource} not found`,\n}) {}\n\n/**\n * Error thrown when access is denied.\n *\n * @example\n * ```typescript\n * const error = new UnauthorizedError({\n *   action: 'delete',\n *   resource: 'User',\n * });\n * console.log(error.message); // \"UnauthorizedError: Not authorized to delete User\"\n * ```\n */\nexport class UnauthorizedError extends TaggedError(\"UnauthorizedError\", {\n  message: (p: {\n    /** Action that was attempted */\n    action?: string;\n    /** Resource that was being accessed */\n    resource?: string;\n    /** Reason for denial */\n    reason?: string;\n  }) =>\n    p.reason\n      ? `UnauthorizedError: ${p.reason}`\n      : p.action && p.resource\n        ? `UnauthorizedError: Not authorized to ${p.action} ${p.resource}`\n        : \"UnauthorizedError: Access denied\",\n}) {}\n\n/**\n * Error thrown for network-related failures.\n *\n * @example\n * ```typescript\n * const error = new NetworkError({\n *   url: 'https://api.example.com/users',\n *   reason: 'Connection refused',\n *   retryable: true,\n * });\n * ```\n */\nexport class NetworkError extends TaggedError(\"NetworkError\", {\n  message: (p: {\n    /** URL that was being accessed */\n    url?: string;\n    /** Reason for the network failure */\n    reason: string;\n    /** Whether this error is retryable */\n    retryable?: boolean;\n    /** HTTP status code if applicable */\n    statusCode?: number;\n  }) =>\n    p.url\n      ? `NetworkError: ${p.reason} (${p.url})`\n      : `NetworkError: ${p.reason}`,\n}) {}\n\n/**\n * Error thrown when a saga compensation fails.\n *\n * @example\n * ```typescript\n * const error = new CompensationError({\n *   step: 'chargeCard',\n *   originalError: paymentError,\n *   compensationError: refundError,\n * });\n * ```\n */\nexport class CompensationError extends TaggedError(\"CompensationError\", {\n  slug: \"runtime-saga-compensation\",\n  hint: \"A saga compensation step failed. Inspect compensationError and ensure compensation is idempotent.\",\n  message: (p: {\n    /** Step that triggered compensation */\n    step: string;\n    /** The original error that caused compensation */\n    originalError?: unknown;\n    /** Error that occurred during compensation */\n    compensationError?: unknown;\n  }) => `CompensationError: Failed to compensate step ${p.step}`,\n}) {}\n\n// =============================================================================\n// Unexpected Error\n// =============================================================================\n\n/**\n * Default error type for uncaught exceptions and cancellation in workflows.\n * This is the default `U` type when `catchUnexpected` is not provided.\n *\n * @example\n * ```typescript\n * // Automatically used as the default — no need to pass catchUnexpected:\n * const workflow = createWorkflow(\"checkout\", { chargeCard, sendEmail });\n *\n * // Equivalent to:\n * const workflow = createWorkflow(\"checkout\", { chargeCard, sendEmail }, {\n *   catchUnexpected: (cause) => new UnexpectedError({ cause }),\n * });\n * ```\n */\nexport class UnexpectedError extends TaggedError(\"UnexpectedError\", {\n  slug: \"runtime-unexpected\",\n  hint: \"An unexpected exception escaped a step. Inspect cause; consider returning a typed Result instead of throwing.\",\n  message: (p: {\n    /** The original thrown value or cancellation error */\n    cause?: unknown;\n  }) => `UnexpectedError: ${p.cause instanceof Error ? p.cause.message : String(p.cause ?? \"unknown\")}`,\n}) {}\n\n// =============================================================================\n// Union Type for Common Errors\n// =============================================================================\n\n/**\n * Union of all pre-built error types.\n * Useful for exhaustive pattern matching.\n *\n * @example\n * ```typescript\n * function handleError(error: AwaitlyError): string {\n *   return TaggedError.match(error, {\n *     TimeoutError: (e) => `Timeout: ${e.ms}ms`,\n *     RetryExhaustedError: (e) => `Retries: ${e.attempts}`,\n *     RateLimitError: (e) => `Rate limited`,\n *     CircuitBreakerOpenError: (e) => `Circuit open: ${e.circuitName}`,\n *     ValidationError: (e) => `Invalid: ${e.field}`,\n *     NotFoundError: (e) => `Not found: ${e.resource}`,\n *     UnauthorizedError: (e) => `Unauthorized`,\n *     NetworkError: (e) => `Network: ${e.reason}`,\n *     CompensationError: (e) => `Compensation failed: ${e.step}`,\n *     UnexpectedError: (e) => e.message,\n *   });\n * }\n * ```\n */\nexport type AwaitlyError =\n  | TimeoutError\n  | RetryExhaustedError\n  | RateLimitError\n  | CircuitBreakerOpenError\n  | ValidationError\n  | NotFoundError\n  | UnauthorizedError\n  | NetworkError\n  | CompensationError\n  | UnexpectedError;\n\n/**\n * The six awaitly-system errors that carry slug + hint + docsUrl spine fields.\n *\n * Distinguishes spine-bearing errors from user-domain convenience errors\n * (ValidationError, NotFoundError, UnauthorizedError, NetworkError) so that\n * downstream tooling (lint, analyzer, docs generator) can target the spine\n * roster without duplicating the class list.\n */\nexport type AwaitlySystemError =\n  | TimeoutError\n  | RetryExhaustedError\n  | RateLimitError\n  | CircuitBreakerOpenError\n  | CompensationError\n  | UnexpectedError;\n\n/**\n * Roster of awaitly-system error classes that participate in the slug spine.\n *\n * Adding a new system error means adding it to `AwaitlySystemError`, this\n * roster, and `slugs.ts`. The integrity test in `spine-integrity.test.ts`\n * iterates this roster, so a missing entry there is caught at CI time.\n *\n * @internal Tooling integration point (docs generator, integrity tests). Not\n *   a stable user-facing API — application code should not depend on this\n *   array's identity or order.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const AWAITLY_SYSTEM_ERROR_CLASSES: ReadonlyArray<new (...args: any[]) => AwaitlySystemError> = [\n  TimeoutError,\n  RetryExhaustedError,\n  RateLimitError,\n  CircuitBreakerOpenError,\n  CompensationError,\n  UnexpectedError,\n];\n\n// =============================================================================\n// Type Guards\n// =============================================================================\n\n/**\n * Check if an error is a TimeoutError.\n */\nexport function isTimeoutError(error: unknown): error is TimeoutError {\n  return TaggedError.isTaggedError(error) && error._tag === \"TimeoutError\";\n}\n\n/**\n * Check if an error is a RetryExhaustedError.\n */\nexport function isRetryExhaustedError(\n  error: unknown\n): error is RetryExhaustedError {\n  return (\n    TaggedError.isTaggedError(error) && error._tag === \"RetryExhaustedError\"\n  );\n}\n\n/**\n * Check if an error is a RateLimitError.\n */\nexport function isRateLimitError(error: unknown): error is RateLimitError {\n  return TaggedError.isTaggedError(error) && error._tag === \"RateLimitError\";\n}\n\n/**\n * Check if an error is a CircuitBreakerOpenError.\n */\nexport function isCircuitBreakerOpenError(\n  error: unknown\n): error is CircuitBreakerOpenError {\n  return (\n    TaggedError.isTaggedError(error) && error._tag === \"CircuitBreakerOpenError\"\n  );\n}\n\n/**\n * Check if an error is a ValidationError.\n */\nexport function isValidationError(error: unknown): error is ValidationError {\n  return TaggedError.isTaggedError(error) && error._tag === \"ValidationError\";\n}\n\n/**\n * Check if an error is a NotFoundError.\n */\nexport function isNotFoundError(error: unknown): error is NotFoundError {\n  return TaggedError.isTaggedError(error) && error._tag === \"NotFoundError\";\n}\n\n/**\n * Check if an error is an UnauthorizedError.\n */\nexport function isUnauthorizedError(\n  error: unknown\n): error is UnauthorizedError {\n  return TaggedError.isTaggedError(error) && error._tag === \"UnauthorizedError\";\n}\n\n/**\n * Check if an error is a NetworkError.\n */\nexport function isNetworkError(error: unknown): error is NetworkError {\n  return TaggedError.isTaggedError(error) && error._tag === \"NetworkError\";\n}\n\n/**\n * Check if an error is a CompensationError.\n */\nexport function isCompensationError(\n  error: unknown\n): error is CompensationError {\n  return TaggedError.isTaggedError(error) && error._tag === \"CompensationError\";\n}\n\n/**\n * Check if an error is any AwaitlyError.\n */\nexport function isAwaitlyError(error: unknown): error is AwaitlyError {\n  if (!TaggedError.isTaggedError(error)) return false;\n  const tag = error._tag;\n  return [\n    \"TimeoutError\",\n    \"RetryExhaustedError\",\n    \"RateLimitError\",\n    \"CircuitBreakerOpenError\",\n    \"ValidationError\",\n    \"NotFoundError\",\n    \"UnauthorizedError\",\n    \"NetworkError\",\n    \"CompensationError\",\n    \"UnexpectedError\",\n  ].includes(tag);\n}\n","/**\n * awaitly/result (internal)\n *\n * Core Result primitives - minimal bundle for typed error handling.\n * This file is intentionally kept small for optimal tree-shaking.\n * The full orchestration (run, step, etc.) lives in core.ts.\n */\n\n// =============================================================================\n// Core Result Types\n// =============================================================================\n\n/**\n * Represents a successful result.\n * Use `ok(value)` to create instances.\n */\nexport type Ok<T> = {\n  ok: true;\n  value: T;\n};\n\n/**\n * Represents a failed result.\n * Use `err(error)` to create instances.\n */\nexport type Err<E, C = unknown> = {\n  ok: false;\n  error: E;\n  cause?: C;\n};\n\n/**\n * Represents a successful computation or a failed one.\n */\nexport type Result<T, E = unknown, C = unknown> = Ok<T> | Err<E, C>;\n\n/**\n * A Promise that resolves to a Result.\n */\nexport type AsyncResult<T, E = unknown, C = unknown> = Promise<Result<T, E, C>>;\n\n/** Discriminant for PromiseRejectedError type - use in switch statements */\nexport const PROMISE_REJECTED = \"PROMISE_REJECTED\" as const;\n\n// =============================================================================\n// Named Error Constants (for static analysis)\n// =============================================================================\n\n/**\n * Named error constant for unexpected/unhandled errors.\n * Used by the analyzer when a step doesn't declare errors.\n */\nexport const AWAITLY_UNEXPECTED = \"AWAITLY_UNEXPECTED\" as const;\n\n/**\n * Named error constant for cancelled operations.\n */\nexport const AWAITLY_CANCELLED = \"AWAITLY_CANCELLED\" as const;\n\n/**\n * Named error constant for timed-out operations.\n */\nexport const AWAITLY_TIMEOUT = \"AWAITLY_TIMEOUT\" as const;\n\n// =============================================================================\n// Static Analysis Helpers\n// =============================================================================\n\n/**\n * Helper to create a tuple of string literal tags with preserved literal types.\n * Use this when you need to store error tags in a variable while keeping\n * TypeScript's literal type inference (avoiding widening to string[]).\n *\n * @param t - The string literal tags\n * @returns The same array with preserved literal types\n *\n * @example\n * ```typescript\n * // Without tags() - type widens to string[]\n * const errs = ['CART_NOT_FOUND', 'CART_EMPTY'];  // string[]\n *\n * // With tags() - literal types preserved\n * const errs = tags('CART_NOT_FOUND', 'CART_EMPTY');  // readonly ['CART_NOT_FOUND', 'CART_EMPTY']\n *\n * await step('getCart', () => getCart(id), {\n *   errors: errs,  // Analyzer can extract literal types\n *   out: 'cart',\n * });\n * ```\n */\nexport const tags = <const T extends readonly string[]>(...t: T): T => t;\n\nimport { UnexpectedError } from \"../errors\";\nexport { UnexpectedError };\nexport type PromiseRejectedError = { type: typeof PROMISE_REJECTED; cause: unknown };\n/** Cause type for promise rejections in async batch helpers */\nexport type PromiseRejectionCause = { type: \"PROMISE_REJECTION\"; reason: unknown };\nexport type EmptyInputError = { type: \"EMPTY_INPUT\"; message: string };\nexport type MaybeAsyncResult<T, E, C = unknown> = Result<T, E, C> | Promise<Result<T, E, C>>;\n\n// =============================================================================\n// Result Constructors\n// =============================================================================\n\n/**\n * Creates a successful Result.\n *\n * @remarks When to use: Wrap a successful value in a Result for consistent return types.\n */\nexport function ok(): Ok<void>;\nexport function ok<T>(value: T): Ok<T>;\nexport function ok<T>(value?: T): Ok<T | void> {\n  return { ok: true as const, value: value as T | void };\n}\n\n/**\n * Creates a failed Result.\n *\n * @remarks When to use: Return a typed failure without throwing so callers can handle it explicitly.\n */\nexport function err<E, C = unknown>(error: E, options?: { cause?: C }): Err<E, C> {\n  const cause = options?.cause;\n  return { ok: false as const, error, ...(cause !== undefined ? { cause } : {}) } as Err<E, C>;\n}\n\n// =============================================================================\n// Type Guards\n// =============================================================================\n\n/**\n * Checks if a Result is successful.\n *\n * @remarks When to use: Prefer functional-style checks or array filtering over `result.ok`.\n */\nexport const isOk = <T, E, C>(r: Result<T, E, C>): r is Ok<T> => r.ok;\n\n/**\n * Checks if a Result is a failure.\n *\n * @remarks When to use: Prefer functional-style checks or array filtering over `result.ok`.\n */\nexport const isErr = <T, E, C>(r: Result<T, E, C>): r is Err<E, C> => !r.ok;\n\n/**\n * Checks if an error is an UnexpectedError.\n *\n * @remarks When to use: Distinguish unexpected failures from your typed error union.\n */\nexport const isUnexpectedError = (e: unknown): e is UnexpectedError =>\n  e instanceof UnexpectedError ||\n  (typeof e === \"object\" &&\n    e !== null &&\n    \"_tag\" in e &&\n    (e as { _tag: string })._tag === \"UnexpectedError\");\n\n/**\n * Checks if an error is a PromiseRejectedError.\n */\nexport const isPromiseRejectedError = (e: unknown): e is PromiseRejectedError =>\n  typeof e === \"object\" &&\n  e !== null &&\n  \"type\" in e &&\n  e.type === PROMISE_REJECTED;\n\n// =============================================================================\n// Error Matching\n// =============================================================================\n\nexport type MatchErrorHandlers<E extends string, R> = {\n  [K in Exclude<E, \"UnexpectedError\">]: (error: K) => R;\n} & {\n  UnexpectedError: (error: UnexpectedError) => R;\n};\n\n/**\n * Match on string error types with exhaustive checking.\n * Takes an error value (not a Result) and handlers for each error type.\n */\nexport function matchError<E extends string, R>(\n  handlers: MatchErrorHandlers<E, R>\n): (error: E | UnexpectedError) => R;\nexport function matchError<E extends string, R>(\n  error: E | UnexpectedError,\n  handlers: MatchErrorHandlers<E, R>\n): R;\nexport function matchError<E extends string, R>(\n  errorOrHandlers: E | UnexpectedError | MatchErrorHandlers<E, R>,\n  handlers?: MatchErrorHandlers<E, R>\n): R | ((error: E | UnexpectedError) => R) {\n  if (handlers === undefined) {\n    const h = errorOrHandlers as MatchErrorHandlers<E, R>;\n    return (e: E | UnexpectedError) => matchError(e, h);\n  }\n  const error = errorOrHandlers as E | UnexpectedError;\n  // Handle UnexpectedError instances\n  if (isUnexpectedError(error)) {\n    return handlers.UnexpectedError(error as UnexpectedError);\n  }\n  // Handle string literal errors\n  type StringErrors = Exclude<E, \"UnexpectedError\">;\n  return (handlers as unknown as Record<string, (e: string) => R>)[error as StringErrors](error as StringErrors);\n}\n\n// =============================================================================\n// Type Utilities\n// =============================================================================\n\ntype AnyFunction = (...args: never[]) => unknown;\n\n/**\n * Helper to extract the error type from Result or AsyncResult return values.\n * Works even when a function is declared to return a union of both forms.\n */\ntype ErrorOfReturn<R> = Extract<Awaited<R>, { ok: false }> extends { error: infer E }\n  ? E\n  : never;\n\n/**\n * Extract error type from a single function's return type\n */\nexport type ErrorOf<T extends AnyFunction> = ErrorOfReturn<ReturnType<T>>;\n\n/**\n * Extract union of error types from multiple functions (tuple form)\n */\nexport type Errors<T extends AnyFunction[]> = {\n  [K in keyof T]: ErrorOf<T[K]>;\n}[number];\n\n/**\n * Extract union of error types from a deps object.\n *\n * @example\n * ```typescript\n * const deps = { getUser, createOrder, sendEmail };\n * type E = ErrorsOf<typeof deps>;\n * // = \"NOT_FOUND\" | \"ORDER_FAILED\" | \"EMAIL_ERROR\"\n * ```\n */\nexport type ErrorsOf<Deps extends Record<string, AnyFunction>> = {\n  [K in keyof Deps]: ErrorOf<Deps[K]>;\n}[keyof Deps];\n\n/**\n * Extract value type from Result\n */\nexport type ExtractValue<T> = T extends { ok: true; value: infer U }\n  ? U\n  : never;\n\n/**\n * Extract error type from Result\n */\nexport type ExtractError<T> = T extends { ok: false; error: infer E }\n  ? E\n  : never;\n\n/**\n * Extract cause type from Result\n */\nexport type ExtractCause<T> = T extends { ok: false; cause?: infer C }\n  ? C\n  : never;\n\n/**\n * Helper to extract the cause type from Result or AsyncResult return values.\n * Works even when a function is declared to return a union of both forms.\n */\ntype CauseOfReturn<R> = Extract<Awaited<R>, { ok: false }> extends { cause?: infer C }\n  ? C\n  : never;\n\n/**\n * Extract cause type from a function's return type\n */\nexport type CauseOf<T extends AnyFunction> = CauseOfReturn<ReturnType<T>>;\n\n// =============================================================================\n// Unwrap Utilities\n// =============================================================================\n\n/**\n * Error thrown when attempting to unwrap an Err result.\n */\nexport class UnwrapError extends Error {\n  public readonly error: unknown;\n  public readonly cause?: unknown;\n\n  constructor(result: Err<unknown, unknown>) {\n    const errorStr =\n      typeof result.error === \"string\"\n        ? result.error\n        : JSON.stringify(result.error);\n    super(`Attempted to unwrap an Err: ${errorStr}`);\n    this.name = \"UnwrapError\";\n    this.error = result.error;\n    this.cause = result.cause;\n  }\n}\n\n/**\n * Extracts the value from an Ok result, or throws UnwrapError if it's an Err.\n *\n * @remarks When to use: Only at boundaries or tests where a failure should be fatal.\n */\nexport const unwrap = <T, E, C>(r: Result<T, E, C>): T => {\n  if (r.ok) return r.value;\n  throw new UnwrapError(r);\n};\n\n/**\n * Extracts the value from an Ok result, or returns a default value if it's an Err.\n *\n * @remarks When to use: Provide a safe fallback without branching.\n */\nexport const unwrapOr = <T, E, C>(r: Result<T, E, C>, defaultValue: T): T =>\n  r.ok ? r.value : defaultValue;\n\n/**\n * Extracts the value from an Ok result, or calls a function to get a default value if it's an Err.\n *\n * @remarks When to use: Compute a fallback from the error (logging, metrics, or derived defaults).\n */\nexport const unwrapOrElse = <T, E, C>(\n  r: Result<T, E, C>,\n  fn: (error: E, cause?: C) => T\n): T => (r.ok ? r.value : fn(r.error, r.cause));\n\n/**\n * Alias for `unwrap`. Returns the success value or throws.\n *\n * The Result is already computed; use when you want the value or throw (e.g. at boundaries or in tests).\n *\n * @param r - The Result to unwrap\n * @returns The success value if the Result is successful\n * @throws {UnwrapError} If the Result is an error (includes the error and cause)\n */\nexport const runOrThrow = <T, E, C>(r: Result<T, E, C>): T => unwrap(r);\n\n/**\n * Awaits a Promise of a Result, then returns the success value or rejects.\n *\n * The returned promise **resolves with T** on success and **rejects with UnwrapError** on failure.\n * UnwrapError extends Error and carries the original `error` and `cause` from the Err.\n *\n * @param ar - A Promise or thenable that resolves to a Result\n * @returns A Promise that resolves with the success value or rejects with UnwrapError\n */\nexport const runOrThrowAsync = <T, E, C>(\n  ar: PromiseLike<Result<T, E, C>>\n): Promise<T> => Promise.resolve(ar).then(unwrap);\n\n/**\n * Convenience alias for `unwrapOr(r, null)`. Returns the success value or null.\n *\n * @param r - The Result to unwrap\n * @returns The success value if successful, otherwise null\n */\nexport const runOrNull = <T, E, C>(r: Result<T, E, C>): T | null =>\n  r.ok ? r.value : null;\n\n/**\n * Convenience alias for `unwrapOr(r, undefined)`. Returns the success value or undefined.\n *\n * @param r - The Result to unwrap\n * @returns The success value if successful, otherwise undefined\n */\nexport const runOrUndefined = <T, E, C>(r: Result<T, E, C>): T | undefined =>\n  r.ok ? r.value : undefined;\n\n// =============================================================================\n// Wrapping Functions\n// =============================================================================\n\n/**\n * Wraps a synchronous function that might throw into a Result.\n *\n * @remarks When to use: Wrap sync code that might throw so exceptions become Err values.\n */\nexport function from<T>(fn: () => T): Ok<T> | Err<unknown, unknown>;\nexport function from<T, E>(fn: () => T, onError: (cause: unknown) => E): Ok<T> | Err<E, unknown>;\nexport function from<T, E>(fn: () => T, onError?: (cause: unknown) => E) {\n  try {\n    return ok(fn());\n  } catch (cause) {\n    return onError ? err(onError(cause), { cause }) : err(cause);\n  }\n}\n\n/**\n * Wraps a Promise into a Result.\n *\n * @remarks When to use: Wrap a Promise and keep the raw rejection as Err; use tryAsync to map errors.\n */\nexport function fromPromise<T>(promise: Promise<T>): Promise<Ok<T> | Err<unknown, unknown>>;\nexport function fromPromise<T, E>(\n  promise: Promise<T>,\n  onError: (cause: unknown) => E\n): Promise<Ok<T> | Err<E, unknown>>;\nexport async function fromPromise<T, E>(\n  promise: Promise<T>,\n  onError?: (cause: unknown) => E\n): Promise<Ok<T> | Err<E | unknown, unknown>> {\n  try {\n    return ok(await promise);\n  } catch (cause) {\n    return onError ? err(onError(cause), { cause }) : err(cause);\n  }\n}\n\n/**\n * Wraps an async function that might throw into an AsyncResult.\n *\n * @remarks When to use: Wrap async work and map thrown/rejected values into your typed error union.\n */\nexport function tryAsync<T>(fn: () => Promise<T>): AsyncResult<T, unknown>;\nexport function tryAsync<T, E>(\n  fn: () => Promise<T>,\n  onError: (cause: unknown) => E\n): AsyncResult<T, E>;\nexport async function tryAsync<T, E>(\n  fn: () => Promise<T>,\n  onError?: (cause: unknown) => E\n): AsyncResult<T, E | unknown> {\n  try {\n    return ok(await fn());\n  } catch (cause) {\n    return onError ? err(onError(cause), { cause }) : err(cause);\n  }\n}\n\n/**\n * Converts a nullable value into a Result.\n *\n * @remarks When to use: Turn null/undefined into a typed error before continuing.\n */\nexport function fromNullable<T, E>(\n  value: T | null | undefined,\n  onNull: () => E\n): Result<T, E> {\n  return value != null ? ok(value) : err(onNull());\n}\n\n// =============================================================================\n// Transformers\n// =============================================================================\n\n/**\n * Transforms the value inside an Ok result.\n *\n * @remarks When to use: Transform only the Ok value while leaving Err untouched.\n */\nexport function map<T, U>(r: Ok<T>, fn: (value: T) => U): Ok<U>;\nexport function map<T, U, E, C>(r: Err<E, C>, fn: (value: T) => U): Err<E, C>;\nexport function map<T, U, E, C>(r: Result<T, E, C>, fn: (value: T) => U): Result<U, E, C>;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function map(r: any, fn: any): any {\n  return r.ok ? ok(fn(r.value)) : r;\n}\n\n/**\n * Transforms the error inside an Err result.\n *\n * @remarks When to use: Retype or normalize errors while leaving Ok values unchanged.\n */\nexport function mapError<T, E, F, C>(\n  r: Result<T, E, C>,\n  fn: (error: E, cause?: C) => F\n): Result<T, F, C> {\n  return r.ok ? r : err(fn(r.error, r.cause), { cause: r.cause });\n}\n\n/**\n * Pattern match on a Result.\n *\n * @remarks When to use: Handle both Ok and Err in a single expression that returns a value.\n */\nexport function match<T, E, C, R>(handlers: { ok: (value: T) => R; err: (error: E, cause?: C) => R }): (r: Result<T, E, C>) => R;\nexport function match<T, E, C, R>(r: Ok<T>, handlers: { ok: (value: T) => R; err: (error: E, cause?: C) => R }): R;\nexport function match<T, E, C, R>(r: Err<E, C>, handlers: { ok: (value: T) => R; err: (error: E, cause?: C) => R }): R;\nexport function match<T, E, C, R>(r: Result<T, E, C>, handlers: { ok: (value: T) => R; err: (error: E, cause?: C) => R }): R;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function match(r: any, handlers?: any): any {\n  if (handlers === undefined) {\n    const h = r;\n    return (result: Result<unknown, unknown, unknown>) => match(result, h);\n  }\n  return r.ok ? handlers.ok(r.value) : handlers.err(r.error, r.cause);\n}\n\n/**\n * Chain Result-returning functions.\n *\n * @remarks When to use: Chain dependent operations that return Result without nested branching.\n */\nexport function andThen<T, U>(r: Ok<T>, fn: (value: T) => Ok<U>): Ok<U>;\nexport function andThen<T, F, C2>(r: Ok<T>, fn: (value: T) => Err<F, C2>): Err<F, C2>;\nexport function andThen<T, U, F, C2>(r: Ok<T>, fn: (value: T) => Result<U, F, C2>): Result<U, F, C2>;\nexport function andThen<T, U, E, F, C1, C2>(r: Err<E, C1>, fn: (value: T) => Result<U, F, C2>): Err<E, C1>;\nexport function andThen<T, U, E, F, C1, C2>(r: Result<T, E, C1>, fn: (value: T) => Result<U, F, C2>): Result<U, E | F, C1 | C2>;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function andThen(r: any, fn: any): any {\n  return r.ok ? fn(r.value) : r;\n}\n\n/**\n * Execute a side effect on Ok values.\n *\n * @remarks When to use: Add side effects (logging, metrics) on Ok without changing the Result.\n */\nexport function tap<T, E, C>(\n  r: Result<T, E, C>,\n  fn: (value: T) => void\n): Result<T, E, C> {\n  if (r.ok) fn(r.value);\n  return r;\n}\n\n/**\n * Execute a side effect on Err values.\n *\n * @remarks When to use: Add side effects (logging, metrics) on Err without changing the Result.\n */\nexport function tapError<T, E, C>(\n  r: Result<T, E, C>,\n  fn: (error: E, cause?: C) => void\n): Result<T, E, C> {\n  if (!r.ok) fn(r.error, r.cause);\n  return r;\n}\n\n/**\n * Transform value with a function that might throw.\n *\n * @remarks When to use: Transform Ok values with a function that might throw and capture the failure.\n */\nexport function mapTry<T, U, E, F, C>(\n  r: Result<T, E, C>,\n  fn: (value: T) => U,\n  onError: (thrown: unknown) => F\n): Result<U, E | F, C | unknown> {\n  if (!r.ok) return r;\n  try {\n    return ok(fn(r.value));\n  } catch (error) {\n    return err(onError(error), { cause: error });\n  }\n}\n\n/**\n * Transform error with a function that might throw.\n *\n * @remarks When to use: Transform errors when the mapping might throw and you want that captured.\n */\nexport function mapErrorTry<T, E, F, G, C>(\n  r: Result<T, E, C>,\n  fn: (error: E) => F,\n  onError: (thrown: unknown) => G\n): Result<T, F | G, C | unknown> {\n  if (r.ok) return r;\n  try {\n    return err(fn(r.error), { cause: r.cause });\n  } catch (error) {\n    return err(onError(error), { cause: error });\n  }\n}\n\n/**\n * Transform both value and error.\n */\nexport function bimap<T, U, E, F, C>(\n  r: Result<T, E, C>,\n  onOk: (value: T) => U,\n  onErr: (error: E, cause?: C) => F\n): Result<U, F, C> {\n  return r.ok ? ok(onOk(r.value)) : err(onErr(r.error, r.cause), { cause: r.cause });\n}\n\n/**\n * Provide an alternative Result if the first is an Err.\n *\n * @remarks When to use: Recover from Err by returning a fallback Result or retyping the error.\n */\nexport function orElse<T, E, E2, C, C2>(\n  r: Result<T, E, C>,\n  fn: (error: E, cause?: C) => Result<T, E2, C2>\n): Result<T, E2, C | C2> {\n  return r.ok ? r : fn(r.error, r.cause);\n}\n\n/**\n * Async version of orElse.\n */\nexport async function orElseAsync<T, E, E2, C, C2>(\n  r: Result<T, E, C>,\n  fn: (error: E, cause?: C) => Promise<Result<T, E2, C2>>\n): Promise<Result<T, E2, C | C2>> {\n  return r.ok ? r : fn(r.error, r.cause);\n}\n\n/**\n * Recover from errors - always returns Ok<T>.\n */\nexport function recover<T, E, C>(\n  r: Result<T, E, C>,\n  fn: (error: E, cause?: C) => T\n): Ok<T> {\n  return r.ok ? ok(r.value) : ok(fn(r.error, r.cause));\n}\n\n/**\n * Async version of recover - always returns Promise<Ok<T>>.\n */\nexport async function recoverAsync<T, E, C>(\n  r: Result<T, E, C> | Promise<Result<T, E, C>>,\n  fn: (error: E, cause?: C) => T | Promise<T>\n): Promise<Ok<T>> {\n  const resolved = await r;\n  if (resolved.ok) return ok(resolved.value);\n  return ok(await fn(resolved.error, resolved.cause));\n}\n\n// =============================================================================\n// Result Hydration (Serialization)\n// =============================================================================\n\n/**\n * Hydrate a serialized Result back into a proper Result object.\n */\nexport function hydrate<T, E, C = unknown>(value: unknown): Result<T, E, C> | null {\n  if (typeof value !== \"object\" || value === null) return null;\n  if (!(\"ok\" in value)) return null;\n\n  const obj = value as Record<string, unknown>;\n  if (obj.ok === true && \"value\" in obj) {\n    return ok(obj.value as T);\n  }\n  if (obj.ok === false && \"error\" in obj) {\n    return err(obj.error as E, { cause: obj.cause as C });\n  }\n  return null;\n}\n\n/**\n * Type guard to check if a value is a serialized Result.\n */\nexport function isSerializedResult(\n  value: unknown\n): value is { ok: boolean; value?: unknown; error?: unknown; cause?: unknown } {\n  if (typeof value !== \"object\" || value === null) return false;\n  if (!(\"ok\" in value)) return false;\n  const obj = value as Record<string, unknown>;\n  return (\n    (obj.ok === true && \"value\" in obj) ||\n    (obj.ok === false && \"error\" in obj)\n  );\n}\n\n// =============================================================================\n// Batch Operations\n// =============================================================================\n\ntype AllValues<T extends readonly Result<unknown, unknown, unknown>[]> = {\n  [K in keyof T]: T[K] extends Ok<infer V>\n    ? V\n    : T[K] extends Err<unknown, unknown>\n      ? never\n      : T[K] extends Result<infer V, unknown, unknown>\n        ? V\n        : never;\n};\ntype AllErrors<T extends readonly Result<unknown, unknown, unknown>[]> = {\n  [K in keyof T]: T[K] extends Ok<unknown>\n    ? never\n    : T[K] extends Err<infer E, unknown>\n      ? E\n      : T[K] extends Result<unknown, infer E, unknown>\n        ? E\n        : never;\n}[number];\ntype AllCauses<T extends readonly Result<unknown, unknown, unknown>[]> = {\n  [K in keyof T]: T[K] extends Ok<unknown>\n    ? never\n    : T[K] extends Err<unknown, infer C>\n      ? C\n      : T[K] extends Result<unknown, unknown, infer C>\n        ? C\n        : never;\n}[number];\n\n// Conditional type: returns Ok<...> when there are no errors, Result<...> otherwise\n// Note: We only check AllErrors, not AllCauses - causes only matter when there are errors\ntype AllResult<T extends readonly Result<unknown, unknown, unknown>[]> =\n  [AllErrors<T>] extends [never]\n    ? Ok<AllValues<T>>\n    : Result<AllValues<T>, AllErrors<T>, AllCauses<T>>;\n\n/**\n * Combines multiple Results into a single Result containing an array of values.\n * Returns the first Err encountered, or Ok with all values.\n */\nexport function all<const T extends readonly Result<unknown, unknown, unknown>[]>(\n  results: T\n): AllResult<T> {\n  const values: unknown[] = [];\n  for (const result of results) {\n    if (!result.ok) {\n      return result as unknown as AllResult<T>;\n    }\n    values.push(result.value);\n  }\n  return ok(values) as AllResult<T>;\n}\n\n/**\n * Async version of all - works with Promises of Results.\n */\nexport async function allAsync<\n  const T extends readonly (Result<unknown, unknown, unknown> | Promise<Result<unknown, unknown, unknown>>)[]\n>(\n  results: T\n): Promise<\n  Result<\n    { [K in keyof T]: T[K] extends Result<infer V, unknown, unknown> | Promise<Result<infer V, unknown, unknown>> ? V : never },\n    | { [K in keyof T]: T[K] extends Result<unknown, infer E, unknown> | Promise<Result<unknown, infer E, unknown>> ? E : never }[number]\n    | PromiseRejectedError,\n    | { [K in keyof T]: T[K] extends Result<unknown, unknown, infer C> | Promise<Result<unknown, unknown, infer C>> ? C : never }[number]\n    | PromiseRejectionCause\n  >\n> {\n  const values: unknown[] = [];\n  for (const resultOrPromise of results) {\n    try {\n      const r = await resultOrPromise;\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      if (!r.ok) return r as any;\n      values.push(r.value);\n    } catch (reason) {\n      return err(\n        { type: PROMISE_REJECTED, cause: reason } as PromiseRejectedError,\n        { cause: { type: \"PROMISE_REJECTION\", reason } as PromiseRejectionCause }\n      );\n    }\n  }\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return ok(values) as any;\n}\n\nexport type SettledError<E, C = unknown> = { error: E; cause?: C };\n\n// Conditional type: returns Ok<...> when there are no errors, Result<...> otherwise\ntype AllSettledResult<T extends readonly Result<unknown, unknown, unknown>[]> =\n  [AllErrors<T>] extends [never]\n    ? Ok<AllValues<T>>\n    : Result<AllValues<T>, SettledError<AllErrors<T>, AllCauses<T>>[]>;\n\n/**\n * Collects all Results, returning Ok with values if all succeed,\n * or Err with array of errors if any fail.\n */\nexport function allSettled<const T extends readonly Result<unknown, unknown, unknown>[]>(\n  results: T\n): AllSettledResult<T> {\n  const values: unknown[] = [];\n  const errors: SettledError<unknown>[] = [];\n\n  for (const result of results) {\n    if (result.ok) {\n      values.push(result.value);\n    } else {\n      errors.push({ error: result.error, cause: result.cause });\n    }\n  }\n\n  if (errors.length > 0) {\n    return err(errors) as unknown as AllSettledResult<T>;\n  }\n\n  return ok(values) as unknown as AllSettledResult<T>;\n}\n\n/**\n * Async version of allSettled.\n */\nexport async function allSettledAsync<\n  const T extends readonly (Result<unknown, unknown, unknown> | Promise<Result<unknown, unknown, unknown>>)[]\n>(\n  results: T\n): Promise<\n  Result<\n    { [K in keyof T]: T[K] extends Result<infer V, unknown, unknown> | Promise<Result<infer V, unknown, unknown>> ? V : never },\n    SettledError<\n      | { [K in keyof T]: T[K] extends Result<unknown, infer E, unknown> | Promise<Result<unknown, infer E, unknown>> ? E : never }[number]\n      | PromiseRejectedError,\n      | { [K in keyof T]: T[K] extends Result<unknown, unknown, infer C> | Promise<Result<unknown, unknown, infer C>> ? C : never }[number]\n      | PromiseRejectionCause\n    >[]\n  >\n> {\n  const settled = await Promise.all(\n    results.map((item) =>\n      Promise.resolve(item)\n        .then((result) => ({ status: \"result\" as const, result }))\n        .catch((reason) => ({\n          status: \"rejected\" as const,\n          error: { type: PROMISE_REJECTED, cause: reason } as PromiseRejectedError,\n          cause: { type: \"PROMISE_REJECTION\", reason } as PromiseRejectionCause,\n        }))\n    )\n  );\n\n  const values: unknown[] = [];\n  const errors: SettledError<unknown, unknown>[] = [];\n\n  for (const item of settled) {\n    if (item.status === \"rejected\") {\n      errors.push({ error: item.error, cause: item.cause });\n    } else if (item.result.ok) {\n      values.push(item.result.value);\n    } else {\n      errors.push({ error: item.result.error, cause: item.result.cause });\n    }\n  }\n\n  if (errors.length > 0) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    return err(errors) as any;\n  }\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return ok(values) as any;\n}\n\n/**\n * Partitions Results into { values, errors }.\n */\nexport function partition<T, E, C>(\n  results: readonly Result<T, E, C>[]\n): { values: T[]; errors: E[] } {\n  const values: T[] = [];\n  const errors: E[] = [];\n  for (const r of results) {\n    if (r.ok) values.push(r.value);\n    else errors.push(r.error);\n  }\n  return { values, errors };\n}\n\n/**\n * Returns the first Ok result, or an EmptyInputError/first Err if all fail.\n */\nexport function any<const T extends readonly Result<unknown, unknown, unknown>[]>(\n  results: T\n): T extends readonly []\n  ? Err<EmptyInputError, unknown>\n  : Result<\n      { [K in keyof T]: T[K] extends Result<infer V, unknown, unknown> ? V : never }[number],\n      AllErrors<T> | EmptyInputError,\n      AllCauses<T>\n    >;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function any(results: any): any {\n  if (results.length === 0) {\n    return err({ type: \"EMPTY_INPUT\", message: \"any() requires at least one Result\" });\n  }\n  let firstErr: Err<unknown, unknown> | undefined;\n  for (const r of results) {\n    if (r.ok) return r;\n    if (!firstErr) firstErr = r;\n  }\n  return firstErr;\n}\n\n/**\n * Async version of any - races promises and returns first success.\n */\nexport async function anyAsync<\n  const T extends readonly (Result<unknown, unknown, unknown> | Promise<Result<unknown, unknown, unknown>>)[]\n>(\n  results: T\n): Promise<\n  T extends readonly []\n    ? Err<EmptyInputError, unknown>\n    : Result<\n        { [K in keyof T]: T[K] extends Result<infer V, unknown, unknown> | Promise<Result<infer V, unknown, unknown>> ? V : never }[number],\n        | { [K in keyof T]: T[K] extends Result<unknown, infer E, unknown> | Promise<Result<unknown, infer E, unknown>> ? E : never }[number]\n        | EmptyInputError\n        | PromiseRejectedError,\n        | { [K in keyof T]: T[K] extends Result<unknown, unknown, infer C> | Promise<Result<unknown, unknown, infer C>> ? C : never }[number]\n        | PromiseRejectionCause\n      >\n> {\n  if (results.length === 0) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    return err({ type: \"EMPTY_INPUT\", message: \"anyAsync() requires at least one Result\" }) as any;\n  }\n\n  return new Promise((resolve) => {\n    let settled = false;\n    let pendingCount = results.length;\n    let firstError: Err<unknown, unknown> | null = null;\n\n    for (const item of results) {\n      Promise.resolve(item)\n        .catch((reason) =>\n          err(\n            { type: PROMISE_REJECTED, cause: reason } as PromiseRejectedError,\n            { cause: { type: \"PROMISE_REJECTION\", reason } as PromiseRejectionCause }\n          )\n        )\n        .then((result) => {\n          if (settled) return;\n\n          if (result.ok) {\n            settled = true;\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            resolve(result as any);\n            return;\n          }\n\n          if (!firstError) firstError = result;\n          pendingCount--;\n\n          if (pendingCount === 0) {\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            resolve(firstError as any);\n          }\n        });\n    }\n  });\n}\n\n/**\n * Combines exactly two Results into a tuple.\n */\nexport function zip<A, EA, CA, B, EB, CB>(\n  a: Result<A, EA, CA>,\n  b: Result<B, EB, CB>\n): Result<[A, B], EA | EB, CA | CB> {\n  if (!a.ok) return a;\n  if (!b.ok) return b;\n  return ok([a.value, b.value]);\n}\n\n/**\n * Async version of zip.\n */\nexport async function zipAsync<A, EA, CA, B, EB, CB>(\n  a: Result<A, EA, CA> | Promise<Result<A, EA, CA>>,\n  b: Result<B, EB, CB> | Promise<Result<B, EB, CB>>\n): Promise<Result<[A, B], EA | EB | PromiseRejectedError, CA | CB | PromiseRejectionCause>> {\n  // Wrap rejections into PromiseRejectedError (consistent with allAsync)\n  const wrapRejection = <T, E, C>(\n    p: Result<T, E, C> | Promise<Result<T, E, C>>\n  ): Promise<Result<T, E | PromiseRejectedError, C | PromiseRejectionCause>> =>\n    Promise.resolve(p).catch((reason) =>\n      err(\n        { type: PROMISE_REJECTED, cause: reason } as PromiseRejectedError,\n        { cause: { type: \"PROMISE_REJECTION\", reason } as PromiseRejectionCause }\n      )\n    );\n\n  const [ra, rb] = await Promise.all([wrapRejection(a), wrapRejection(b)]);\n  return zip(ra, rb);\n}\n\n// =============================================================================\n// Flatten\n// =============================================================================\n\n/**\n * Flattens a nested Result into a single Result.\n *\n * @remarks When to use: Unwrap a Result<Result<T, E1>, E2> into Result<T, E1 | E2> after an operation that returns nested Results.\n */\nexport function flatten<T, E1, C1, E2, C2>(\n  result: Result<Result<T, E1, C1>, E2, C2>\n): Result<T, E1 | E2, C1 | C2> {\n  if (!result.ok) return result as Err<E2, C2>;\n  return result.value;\n}\n\n// =============================================================================\n// Deserialization (improved hydrate)\n// =============================================================================\n\n/** Discriminant for deserialization errors */\nexport const DESERIALIZATION_ERROR = \"DESERIALIZATION_ERROR\" as const;\n\n/** Error type returned when deserialize() receives invalid input */\nexport type DeserializationError = { type: typeof DESERIALIZATION_ERROR; value: unknown };\n\n/**\n * Deserialize a value back into a Result.\n * Returns a typed DeserializationError on invalid input instead of null.\n *\n * @remarks When to use: Rehydrate Results from JSON, RPC, or server actions with type-safe error handling.\n */\nexport function deserialize<T, E, C = unknown>(\n  value: unknown\n): Result<T, E | DeserializationError, C> {\n  if (typeof value !== \"object\" || value === null) {\n    return err({ type: DESERIALIZATION_ERROR, value } as DeserializationError);\n  }\n  if (!(\"ok\" in value)) {\n    return err({ type: DESERIALIZATION_ERROR, value } as DeserializationError);\n  }\n\n  const obj = value as Record<string, unknown>;\n  if (obj.ok === true && \"value\" in obj) {\n    return ok(obj.value as T);\n  }\n  if (obj.ok === false && \"error\" in obj) {\n    return err(obj.error as E, { cause: obj.cause as C });\n  }\n  return err({ type: DESERIALIZATION_ERROR, value } as DeserializationError);\n}\n\n// =============================================================================\n// Serialization\n// =============================================================================\n\n/** A plain serialized form of a Result, safe to JSON.stringify. */\nexport type SerializedResult<T, E> = { ok: true; value: T } | { ok: false; error: E };\n\n/**\n * Serialize a Result to a plain object (inverse of `deserialize`).\n * Strips cause — safe for JSON.stringify, RPC, and server actions.\n *\n * @remarks When to use: Sending Results over the wire or storing them in JSON.\n */\nexport function serialize<T, E>(result: Result<T, E>): SerializedResult<T, E> {\n  return result.ok\n    ? { ok: true, value: result.value }\n    : { ok: false, error: result.error };\n}\n\n// =============================================================================\n// Partial error matching\n// =============================================================================\n\n/**\n * Non-exhaustive error match — handle the errors you care about; let the rest fall through to fallback.\n *\n * @example\n * ```typescript\n * const message = matchErrorPartial(\n *   error,\n *   { NOT_FOUND: () => 'Resource not found' },\n *   (e) => `Unexpected: ${e}`\n * );\n * ```\n */\nexport function matchErrorPartial<E extends string, R>(\n  error: E | UnexpectedError,\n  handlers: Partial<MatchErrorHandlers<E, R>>,\n  fallback: (error: E | UnexpectedError) => R\n): R {\n  if (isUnexpectedError(error)) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const h = (handlers as any).UnexpectedError as ((e: UnexpectedError) => R) | undefined;\n    return h ? h(error) : fallback(error);\n  }\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const h = (handlers as any)[error as string] as ((e: E) => R) | undefined;\n  return h ? h(error as E) : fallback(error);\n}\n\n// Retry helper is intentionally NOT re-exported here.\n// Import from the dedicated subpath to keep awaitly/result minimal:\n//   import { tryAsyncRetry } from 'awaitly/result/retry';\n","/**\n * awaitly/result retry support\n *\n * Retry async operations with configurable backoff without the full workflow engine.\n */\n\nimport type { AsyncResult } from \"./index\";\nimport { ok, err, tryAsync } from \"./index\";\nimport type { RetryOptions } from \"../core\";\nimport { UnexpectedError } from \"../errors\";\n\n/** Object-style config for async edge wrapping with optional retry. */\nexport type TryAsyncBoundaryConfig<T, E> = {\n  /** Async operation to execute (may throw/reject). */\n  try: () => Promise<T>;\n  /** Maps thrown/rejected causes into typed domain errors. */\n  catch: (cause: unknown) => E;\n  /** Optional retry policy; when omitted, no retries are performed. */\n  retry?: RetryOptions<E>;\n};\n\nconst computeDelay = (\n  attempt: number,\n  initialDelay: number,\n  backoff: NonNullable<RetryOptions[\"backoff\"]>\n): number => {\n  switch (backoff) {\n    case \"linear\":\n      return initialDelay * attempt;\n    case \"exponential\":\n      return initialDelay * 2 ** (attempt - 1);\n    case \"fixed\":\n    default:\n      return initialDelay;\n  }\n};\n\nconst sleep = (ms: number) =>\n  new Promise<void>((resolve) => setTimeout(resolve, ms));\n\n/**\n * Wraps an async function that might throw into an AsyncResult, with retry support.\n *\n * @remarks When to use: Wrap async work with retry logic for transient failures without needing the full workflow engine.\n *\n * @example\n * ```typescript\n * const result = await tryAsyncRetry(\n *   () => fetch('/api/data').then(r => r.json()),\n *   (cause) => ({ type: 'FETCH_FAILED' as const, cause }),\n *   { retry: { attempts: 3, initialDelay: 100, backoff: 'exponential' } }\n * );\n * ```\n */\nexport function tryAsyncRetry<T>(\n  fn: () => Promise<T>,\n  config: { retry: RetryOptions<unknown> }\n): AsyncResult<T, unknown>;\nexport function tryAsyncRetry<T, E>(\n  fn: () => Promise<T>,\n  onError: (cause: unknown) => E,\n  config: { retry: RetryOptions<E> }\n): AsyncResult<T, E>;\nexport async function tryAsyncRetry<T, E>(\n  fn: () => Promise<T>,\n  onErrorOrConfig: ((cause: unknown) => E) | { retry: RetryOptions<unknown> },\n  maybeConfig?: { retry: RetryOptions<E> }\n): AsyncResult<T, E | unknown> {\n  const onError =\n    typeof onErrorOrConfig === \"function\" ? onErrorOrConfig : undefined;\n  const config =\n    typeof onErrorOrConfig === \"function\" ? maybeConfig! : onErrorOrConfig;\n  const retry = config.retry;\n  const attempts = Math.max(1, retry.attempts);\n  const initialDelay = retry.initialDelay ?? 100;\n  const backoff = retry.backoff ?? \"exponential\";\n  const shouldRetryFn = retry.shouldRetry ?? (() => true);\n\n  const execute = async (): AsyncResult<T, E | unknown> => {\n    try {\n      return ok(await fn());\n    } catch (cause) {\n      return onError ? err(onError(cause), { cause }) : err(cause);\n    }\n  };\n\n  let result = await execute();\n  for (let attempt = 1; attempt < attempts; attempt++) {\n    if (result.ok) return result;\n    if (!shouldRetryFn(result.error as E, attempt)) return result;\n    await sleep(computeDelay(attempt, initialDelay, backoff));\n    result = await execute();\n  }\n  return result;\n}\n\n/**\n * Object-style boundary wrapper for async vendor edges.\n *\n * Keeps async/await ergonomics while centralizing error classification and\n * retry policy in one place.\n *\n * @example\n * ```typescript\n * const result = await tryAsyncBoundary({\n *   try: () => paymentProvider.authorize(card, total),\n *   catch: (cause) =>\n *     isTimeout(cause)\n *       ? new PaymentLimbo({ attemptId, cause })\n *       : new TransientVendorError({ vendor: \"stripe\", cause }),\n *   retry: {\n *     attempts: 3,\n *     initialDelay: 100,\n *     shouldRetry: (e) => e instanceof TransientVendorError,\n *   },\n * });\n * ```\n */\nexport function tryAsyncBoundary<T, E>(\n  config: TryAsyncBoundaryConfig<T, E>\n): AsyncResult<T, E>;\nexport function tryAsyncBoundary<T>(\n  config: {\n    try: () => Promise<T>;\n    retry?: RetryOptions<UnexpectedError>;\n  }\n): AsyncResult<T, UnexpectedError>;\nexport function tryAsyncBoundary<T, E>(\n  config:\n    | { try: () => Promise<T>; retry?: RetryOptions<UnexpectedError> }\n    | TryAsyncBoundaryConfig<T, E>\n): AsyncResult<T, E | UnexpectedError> {\n  if (\"catch\" in config && typeof config.catch === \"function\") {\n    if (!config.retry) {\n      return tryAsync(config.try, config.catch);\n    }\n    return tryAsyncRetry(config.try, config.catch, { retry: config.retry });\n  }\n\n  const onUnexpected = (cause: unknown) => new UnexpectedError({ cause });\n  if (!config.retry) {\n    return tryAsync(config.try, onUnexpected);\n  }\n  return tryAsyncRetry(config.try, onUnexpected, {\n    retry: config.retry as RetryOptions<UnexpectedError>,\n  });\n}\n"],"mappings":"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","names":["AWAITLY_SLUGS","slugDocsUrl","slug","ALL_SLUGS","AWAITLY_SLUGS","InternalTaggedErrorBase","TaggedError","tag","options","props","errorOptions","message","slugDocsUrl","safeProps","_","_n","_m","_s","_c","_h","_d","rest","hasUserCause","userCause","hasOptionsCause","instance","isError","value","isTaggedError","match","error","handlers","handler","matchPartial","otherwise","TimeoutError","TaggedError","p","RetryExhaustedError","RateLimitError","CircuitBreakerOpenError","ValidationError","NotFoundError","UnauthorizedError","NetworkError","CompensationError","UnexpectedError","ok","value","err","error","options","cause","tryAsync","fn","onError","ok","cause","err","computeDelay","attempt","initialDelay","backoff","sleep","ms","resolve","tryAsyncRetry","fn","onErrorOrConfig","maybeConfig","onError","retry","attempts","shouldRetryFn","execute","ok","cause","err","result","tryAsyncBoundary","config","tryAsync","onUnexpected","UnexpectedError"]}

package/dist/retry.cjs

@@ -1,2 +0,0 @@
-"use strict";var P=Object.defineProperty;var ct=Object.getOwnPropertyDescriptor;var dt=Object.getOwnPropertyNames;var pt=Object.prototype.hasOwnProperty;var St=(t,e)=>{for(var n in e)P(t,n,{get:e[n],enumerable:!0})},ht=(t,e,n,u)=>{if(e&&typeof e=="object"||typeof e=="function")for(let i of dt(e))!pt.call(t,i)&&i!==n&&P(t,i,{get:()=>e[i],enumerable:!(u=ct(e,i))||u.enumerable});return t};var ft=t=>ht(P({},"__esModule",{value:!0}),t);var Ht={};St(Ht,{Duration:()=>m,Schedule:()=>Rt,addDelay:()=>nt,andThen:()=>ut,days:()=>T,delays:()=>st,exponential:()=>G,fibonacci:()=>K,fixed:()=>Wt,forever:()=>H,hours:()=>w,intersect:()=>ot,isDuration:()=>F,jittered:()=>et,linear:()=>J,map:()=>rt,maxDelay:()=>V,millis:()=>D,minDelay:()=>X,minutes:()=>b,modifyDelay:()=>lt,once:()=>Z,recurs:()=>L,run:()=>q,seconds:()=>_,spaced:()=>$,stop:()=>B,tap:()=>at,toDays:()=>j,toHours:()=>N,toMillis:()=>l,toMinutes:()=>W,toSeconds:()=>C,union:()=>it,untilInput:()=>Y,untilOutput:()=>tt,upTo:()=>Q,upToElapsed:()=>U,whileInput:()=>v,whileOutput:()=>z});module.exports=ft(Ht);function D(t){return{_tag:"Duration",millis:t}}function _(t){return{_tag:"Duration",millis:t*1e3}}function b(t){return{_tag:"Duration",millis:t*60*1e3}}function w(t){return{_tag:"Duration",millis:t*60*60*1e3}}function T(t){return{_tag:"Duration",millis:t*24*60*60*1e3}}var Dt={_tag:"Duration",millis:0},mt={_tag:"Duration",millis:1/0};function l(t){return t.millis}function C(t){return t.millis/1e3}function W(t){return t.millis/(60*1e3)}function N(t){return t.millis/(3600*1e3)}function j(t){return t.millis/(1440*60*1e3)}function k(t,e){return{_tag:"Duration",millis:t.millis+e.millis}}function yt(t,e){return{_tag:"Duration",millis:Math.max(0,t.millis-e.millis)}}function x(t,e){return{_tag:"Duration",millis:t.millis*e}}function It(t,e){return{_tag:"Duration",millis:t.millis/e}}function Ot(t,e){return t.millis<e.millis}function xt(t,e){return t.millis<=e.millis}function gt(t,e){return t.millis>e.millis}function _t(t,e){return t.millis>=e.millis}function bt(t,e){return t.millis===e.millis}function A(t,e){return t.millis<=e.millis?t:e}function E(t,e){return t.millis>=e.millis?t:e}function wt(t,e,n){return A(E(t,e),n)}function Tt(t){return t.millis===0}function kt(t){return t.millis===1/0}function Mt(t){return Number.isFinite(t.millis)&&t.millis>0}function F(t){return typeof t=="object"&&t!==null&&"_tag"in t&&t._tag==="Duration"&&"millis"in t&&typeof t.millis=="number"}function Pt(t){let e=t.millis;if(e===1/0)return"\u221E";if(e===0)return"0ms";let n=Math.floor(e/(1440*60*1e3)),u=Math.floor(e%(1440*60*1e3)/(3600*1e3)),i=Math.floor(e%(3600*1e3)/(60*1e3)),o=Math.floor(e%(60*1e3)/1e3),r=e%1e3,a=[];return n>0&&a.push(`${n}d`),u>0&&a.push(`${u}h`),i>0&&a.push(`${i}m`),o>0&&a.push(`${o}s`),r>0&&a.length===0&&a.push(`${r}ms`),a.join(" ")||"0ms"}function Ct(t){let e=t.trim().match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)$/i);if(!e)return;let n=parseFloat(e[1]);switch(e[2].toLowerCase()){case"ms":return D(n);case"s":return _(n);case"m":return b(n);case"h":return w(n);case"d":return T(n);default:return}}var m={millis:D,seconds:_,minutes:b,hours:w,days:T,zero:Dt,infinity:mt,toMillis:l,toSeconds:C,toMinutes:W,toHours:N,toDays:j,add:k,subtract:yt,multiply:x,divide:It,lessThan:Ot,lessThanOrEqual:xt,greaterThan:gt,greaterThanOrEqual:_t,equals:bt,min:A,max:E,clamp:wt,isZero:Tt,isInfinite:kt,isFinite:Mt,isDuration:F,format:Pt,parse:Ct};var h={iterations:0,elapsed:m.zero,lastInput:void 0,lastOutput:void 0};function d(t,e){return{_tag:"Continue",delay:t,output:e}}function S(){return{_tag:"Done"}}function c(t,e,n,u){return{iterations:t.iterations+1,elapsed:k(t.elapsed,e),lastInput:n,lastOutput:u}}function H(){return{_tag:"Schedule",initial:h,step:(t,e)=>d(m.zero,e.iterations)}}function L(t){return{_tag:"Schedule",initial:h,step:(e,n)=>n.iterations<t?d(m.zero,n.iterations):S()}}function Z(){return{_tag:"Schedule",initial:h,step:(t,e)=>e.iterations===0?d(m.zero,void 0):S()}}function B(){return{_tag:"Schedule",initial:h,step:()=>S()}}function $(t){return{_tag:"Schedule",initial:h,step:(e,n)=>d(t,n.iterations)}}var Wt=$;function G(t,e=2){return{_tag:"Schedule",initial:h,step:(n,u)=>{let i=x(t,Math.pow(e,u.iterations));return d(i,i)}}}function J(t){return{_tag:"Schedule",initial:h,step:(e,n)=>{let u=x(t,n.iterations+1);return d(u,u)}}}function K(t){let e=[1,1];for(let n=2;n<50;n++)e[n]=e[n-1]+e[n-2];return{_tag:"Schedule",initial:h,step:(n,u)=>{let i=Math.min(u.iterations,e.length-1),o=x(t,e[i]);return d(o,o)}}}function Q(t){return e=>({_tag:"Schedule",initial:e.initial,step:(n,u)=>u.iterations>=t?S():e.step(n,u)})}function U(t){return e=>({_tag:"Schedule",initial:e.initial,step:(n,u)=>l(u.elapsed)>=l(t)?S():e.step(n,u)})}function V(t){return e=>({_tag:"Schedule",initial:e.initial,step:(n,u)=>{let i=e.step(n,u);if(i._tag==="Done")return i;let o=l(i.delay)>l(t)?t:i.delay;return d(o,i.output)}})}function X(t){return e=>({_tag:"Schedule",initial:e.initial,step:(n,u)=>{let i=e.step(n,u);if(i._tag==="Done")return i;let o=l(i.delay)<l(t)?t:i.delay;return d(o,i.output)}})}function v(t){return e=>({_tag:"Schedule",initial:e.initial,step:(n,u)=>t(n)?e.step(n,u):S()})}function z(t){return e=>({_tag:"Schedule",initial:e.initial,step:(n,u)=>{let i=e.step(n,u);return i._tag==="Done"||t(i.output)?i:S()}})}function Y(t){return v(e=>!t(e))}function tt(t){return z(e=>!t(e))}function et(t=.2){return e=>({_tag:"Schedule",initial:e.initial,step:(n,u)=>{let i=e.step(n,u);if(i._tag==="Done")return i;let o=1-t+Math.random()*t*2,r=D(l(i.delay)*o);return d(r,i.output)}})}function nt(t){return e=>({_tag:"Schedule",initial:e.initial,step:(n,u)=>{let i=e.step(n,u);if(i._tag==="Done")return i;let o=D(Math.random()*l(t)),r=k(i.delay,o);return d(r,i.output)}})}function ut(t){return e=>{let n={inSecondPhase:!1,firstState:e.initial,secondState:t.initial};return{_tag:"Schedule",initial:{...h,meta:n},step:(u,i)=>{let o=i.meta??n;if(!o.inSecondPhase){let p=e.step(u,o.firstState);if(p._tag==="Continue"){let g=p.nextState??c(o.firstState,p.delay,u,p.output),M={...c(i,p.delay,u,p.output),meta:{...o,firstState:g}};return{_tag:"Continue",delay:p.delay,output:p.output,nextState:M}}let s=t.step(u,t.initial);if(s._tag==="Done")return S();let y=s.nextState??c(t.initial,s.delay,u,s.output),I={...c(i,s.delay,u,s.output),meta:{inSecondPhase:!0,firstState:o.firstState,secondState:y}};return{_tag:"Continue",delay:s.delay,output:s.output,nextState:I}}let r=t.step(u,o.secondState);if(r._tag==="Done")return S();let a=r.nextState??c(o.secondState,r.delay,u,r.output),O={...c(i,r.delay,u,r.output),meta:{...o,secondState:a}};return{_tag:"Continue",delay:r.delay,output:r.output,nextState:O}}}}}function it(t,e){let n={firstState:t.initial,secondState:e.initial};return{_tag:"Schedule",initial:{...h,meta:n},step:(u,i)=>{let o=i.meta??n,r=t.step(u,o.firstState),a=e.step(u,o.secondState);if(r._tag==="Done"&&a._tag==="Done")return S();let O=r._tag==="Continue"?r.nextState??c(o.firstState,r.delay,u,r.output):o.firstState,p=a._tag==="Continue"?a.nextState??c(o.secondState,a.delay,u,a.output):o.secondState,s=r._tag==="Continue"?l(r.delay):1/0,y=a._tag==="Continue"?l(a.delay):1/0,I=D(Math.min(s,y)),g=[r._tag==="Continue"?r.output:void 0,a._tag==="Continue"?a.output:void 0],M={...c(i,I,u,g),meta:{firstState:O,secondState:p}};return{_tag:"Continue",delay:I,output:g,nextState:M}}}}function ot(t,e){let n={firstState:t.initial,secondState:e.initial};return{_tag:"Schedule",initial:{...h,meta:n},step:(u,i)=>{let o=i.meta??n,r=t.step(u,o.firstState),a=e.step(u,o.secondState);if(r._tag==="Done"||a._tag==="Done")return S();let O=r.nextState??c(o.firstState,r.delay,u,r.output),p=a.nextState??c(o.secondState,a.delay,u,a.output),s=D(Math.max(l(r.delay),l(a.delay))),y=[r.output,a.output],I={...c(i,s,u,y),meta:{firstState:O,secondState:p}};return{_tag:"Continue",delay:s,output:y,nextState:I}}}}function rt(t){return e=>({_tag:"Schedule",initial:e.initial,step:(n,u)=>{let i=e.step(n,u);return i._tag==="Done"?S():d(i.delay,t(i.output))}})}function at(t){return e=>({_tag:"Schedule",initial:e.initial,step:(n,u)=>{let i=e.step(n,u);return i._tag==="Continue"&&t(i.output,u),i}})}function lt(t){return e=>({_tag:"Schedule",initial:e.initial,step:(n,u)=>{let i=e.step(n,u);return i._tag==="Done"?i:d(t(i.delay,i.output),i.output)}})}function q(t){let e=t.initial;return{next(n){let u=t.step(n,e);return u._tag==="Done"?{done:!0}:(e=u.nextState??c(e,u.delay,n,u.output),{done:!1,value:{delay:u.delay,output:u.output}})}}}function st(t,e=100){let n=[],u=q(t);for(let i=0;i<e;i++){let o=u.next(void 0);if(o.done)break;n.push(o.value.delay)}return n}function Nt(t){return typeof t=="object"&&t!==null&&"_tag"in t&&t._tag==="Schedule"}function f(t){return{...t,pipe(e){let n=e(t);return Nt(n)?f(n):n}}}var R=t=>f($(t)),jt=(t,e)=>f(G(t,e)),Ft=t=>f(J(t)),$t=t=>f(K(t)),vt=t=>f(L(t)),zt=()=>f(H()),qt=()=>f(Z()),At=(t,e)=>f(it(t,e)),Et=(t,e)=>f(ot(t,e)),Rt={forever:zt,once:qt,recurs:vt,stop:B,spaced:R,fixed:R,exponential:jt,linear:Ft,fibonacci:$t,upTo:Q,upToElapsed:U,maxDelay:V,minDelay:X,whileInput:v,whileOutput:z,untilInput:Y,untilOutput:tt,jittered:et,addDelay:nt,andThen:ut,union:At,intersect:Et,map:rt,tap:at,modifyDelay:lt,run:q,delays:st};0&&(module.exports={Duration,Schedule,addDelay,andThen,days,delays,exponential,fibonacci,fixed,forever,hours,intersect,isDuration,jittered,linear,map,maxDelay,millis,minDelay,minutes,modifyDelay,once,recurs,run,seconds,spaced,stop,tap,toDays,toHours,toMillis,toMinutes,toSeconds,union,untilInput,untilOutput,upTo,upToElapsed,whileInput,whileOutput});
-//# sourceMappingURL=retry.cjs.map

package/dist/retry.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/retry-entry.ts","../src/duration.ts","../src/schedule/index.ts"],"sourcesContent":["/**\n * awaitly/retry\n *\n * Composable retry and polling strategies: build complex backoff patterns\n * by composing simple building blocks.\n *\n * @example\n * ```typescript\n * import { Schedule, Duration } from 'awaitly/retry';\n *\n * // Exponential backoff with jitter, max 5 attempts\n * const retryStrategy = Schedule.exponential(Duration.millis(100))\n *   .pipe(Schedule.jittered(0.2))\n *   .pipe(Schedule.upTo(5));\n *\n * // Use with workflows\n * const result = await step.retry(fetchData, { schedule: retryStrategy });\n * ```\n */\n\n// Re-export everything from schedule.ts\nexport * from \"./schedule\";\n\n// Also export Duration for convenience\nexport {\n  type Duration as DurationType,\n  Duration,\n  millis,\n  seconds,\n  minutes,\n  hours,\n  days,\n  toMillis,\n  toSeconds,\n  toMinutes,\n  toHours,\n  toDays,\n  isDuration,\n} from \"./duration\";\n","/**\n * awaitly/duration\n *\n * Type-safe duration handling inspired by Effect's Duration module.\n * Prevents unit confusion (milliseconds vs seconds) with explicit constructors.\n */\n\n// =============================================================================\n// Duration Type\n// =============================================================================\n\n/**\n * A type-safe representation of a time duration.\n * Use the constructor functions (millis, seconds, etc.) to create durations.\n */\nexport interface Duration {\n  readonly _tag: \"Duration\";\n  readonly millis: number;\n}\n\n// =============================================================================\n// Constructors\n// =============================================================================\n\n/**\n * Create a Duration from milliseconds.\n *\n * @example\n * ```typescript\n * const d = Duration.millis(500)\n * ```\n */\nexport function millis(ms: number): Duration {\n  return { _tag: \"Duration\", millis: ms };\n}\n\n/**\n * Create a Duration from seconds.\n *\n * @example\n * ```typescript\n * const d = Duration.seconds(5)  // 5000ms\n * ```\n */\nexport function seconds(s: number): Duration {\n  return { _tag: \"Duration\", millis: s * 1000 };\n}\n\n/**\n * Create a Duration from minutes.\n *\n * @example\n * ```typescript\n * const d = Duration.minutes(2)  // 120000ms\n * ```\n */\nexport function minutes(m: number): Duration {\n  return { _tag: \"Duration\", millis: m * 60 * 1000 };\n}\n\n/**\n * Create a Duration from hours.\n *\n * @example\n * ```typescript\n * const d = Duration.hours(1)  // 3600000ms\n * ```\n */\nexport function hours(h: number): Duration {\n  return { _tag: \"Duration\", millis: h * 60 * 60 * 1000 };\n}\n\n/**\n * Create a Duration from days.\n *\n * @example\n * ```typescript\n * const d = Duration.days(1)  // 86400000ms\n * ```\n */\nexport function days(d: number): Duration {\n  return { _tag: \"Duration\", millis: d * 24 * 60 * 60 * 1000 };\n}\n\n/**\n * Zero duration.\n */\nexport const zero: Duration = { _tag: \"Duration\", millis: 0 };\n\n/**\n * Infinite duration (represented as Infinity milliseconds).\n */\nexport const infinity: Duration = { _tag: \"Duration\", millis: Infinity };\n\n// =============================================================================\n// Conversions\n// =============================================================================\n\n/**\n * Convert a Duration to milliseconds.\n */\nexport function toMillis(duration: Duration): number {\n  return duration.millis;\n}\n\n/**\n * Convert a Duration to seconds.\n */\nexport function toSeconds(duration: Duration): number {\n  return duration.millis / 1000;\n}\n\n/**\n * Convert a Duration to minutes.\n */\nexport function toMinutes(duration: Duration): number {\n  return duration.millis / (60 * 1000);\n}\n\n/**\n * Convert a Duration to hours.\n */\nexport function toHours(duration: Duration): number {\n  return duration.millis / (60 * 60 * 1000);\n}\n\n/**\n * Convert a Duration to days.\n */\nexport function toDays(duration: Duration): number {\n  return duration.millis / (24 * 60 * 60 * 1000);\n}\n\n// =============================================================================\n// Operations\n// =============================================================================\n\n/**\n * Add two durations.\n *\n * @example\n * ```typescript\n * const total = Duration.add(Duration.seconds(5), Duration.millis(500))\n * // 5500ms\n * ```\n */\nexport function add(a: Duration, b: Duration): Duration {\n  return { _tag: \"Duration\", millis: a.millis + b.millis };\n}\n\n/**\n * Subtract duration b from duration a.\n * Result is clamped to zero (no negative durations).\n *\n * @example\n * ```typescript\n * const remaining = Duration.subtract(Duration.seconds(5), Duration.seconds(2))\n * // 3000ms\n * ```\n */\nexport function subtract(a: Duration, b: Duration): Duration {\n  return { _tag: \"Duration\", millis: Math.max(0, a.millis - b.millis) };\n}\n\n/**\n * Multiply a duration by a factor.\n *\n * @example\n * ```typescript\n * const doubled = Duration.multiply(Duration.seconds(5), 2)\n * // 10000ms\n * ```\n */\nexport function multiply(duration: Duration, factor: number): Duration {\n  return { _tag: \"Duration\", millis: duration.millis * factor };\n}\n\n/**\n * Divide a duration by a divisor.\n *\n * @example\n * ```typescript\n * const half = Duration.divide(Duration.seconds(10), 2)\n * // 5000ms\n * ```\n */\nexport function divide(duration: Duration, divisor: number): Duration {\n  return { _tag: \"Duration\", millis: duration.millis / divisor };\n}\n\n// =============================================================================\n// Comparisons\n// =============================================================================\n\n/**\n * Check if duration a is less than duration b.\n */\nexport function lessThan(a: Duration, b: Duration): boolean {\n  return a.millis < b.millis;\n}\n\n/**\n * Check if duration a is less than or equal to duration b.\n */\nexport function lessThanOrEqual(a: Duration, b: Duration): boolean {\n  return a.millis <= b.millis;\n}\n\n/**\n * Check if duration a is greater than duration b.\n */\nexport function greaterThan(a: Duration, b: Duration): boolean {\n  return a.millis > b.millis;\n}\n\n/**\n * Check if duration a is greater than or equal to duration b.\n */\nexport function greaterThanOrEqual(a: Duration, b: Duration): boolean {\n  return a.millis >= b.millis;\n}\n\n/**\n * Check if two durations are equal.\n */\nexport function equals(a: Duration, b: Duration): boolean {\n  return a.millis === b.millis;\n}\n\n/**\n * Get the minimum of two durations.\n */\nexport function min(a: Duration, b: Duration): Duration {\n  return a.millis <= b.millis ? a : b;\n}\n\n/**\n * Get the maximum of two durations.\n */\nexport function max(a: Duration, b: Duration): Duration {\n  return a.millis >= b.millis ? a : b;\n}\n\n/**\n * Clamp a duration between a minimum and maximum.\n */\nexport function clamp(duration: Duration, minimum: Duration, maximum: Duration): Duration {\n  return min(max(duration, minimum), maximum);\n}\n\n// =============================================================================\n// Predicates\n// =============================================================================\n\n/**\n * Check if a duration is zero.\n */\nexport function isZero(duration: Duration): boolean {\n  return duration.millis === 0;\n}\n\n/**\n * Check if a duration is infinite.\n */\nexport function isInfinite(duration: Duration): boolean {\n  return duration.millis === Infinity;\n}\n\n/**\n * Check if a duration is finite and positive.\n */\nexport function isFinite(duration: Duration): boolean {\n  return Number.isFinite(duration.millis) && duration.millis > 0;\n}\n\n/**\n * Type guard to check if a value is a Duration.\n */\nexport function isDuration(value: unknown): value is Duration {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    \"_tag\" in value &&\n    value._tag === \"Duration\" &&\n    \"millis\" in value &&\n    typeof value.millis === \"number\"\n  );\n}\n\n// =============================================================================\n// Formatting\n// =============================================================================\n\n/**\n * Format a duration as a human-readable string.\n *\n * @example\n * ```typescript\n * Duration.format(Duration.seconds(90))  // \"1m 30s\"\n * Duration.format(Duration.millis(500))  // \"500ms\"\n * ```\n */\nexport function format(duration: Duration): string {\n  const ms = duration.millis;\n\n  if (ms === Infinity) return \"∞\";\n  if (ms === 0) return \"0ms\";\n\n  const days = Math.floor(ms / (24 * 60 * 60 * 1000));\n  const hours = Math.floor((ms % (24 * 60 * 60 * 1000)) / (60 * 60 * 1000));\n  const minutes = Math.floor((ms % (60 * 60 * 1000)) / (60 * 1000));\n  const seconds = Math.floor((ms % (60 * 1000)) / 1000);\n  const millis = ms % 1000;\n\n  const parts: string[] = [];\n  if (days > 0) parts.push(`${days}d`);\n  if (hours > 0) parts.push(`${hours}h`);\n  if (minutes > 0) parts.push(`${minutes}m`);\n  if (seconds > 0) parts.push(`${seconds}s`);\n  if (millis > 0 && parts.length === 0) parts.push(`${millis}ms`);\n\n  return parts.join(\" \") || \"0ms\";\n}\n\n// =============================================================================\n// Parsing\n// =============================================================================\n\n/**\n * Parse a duration from a string like \"100ms\", \"5s\", \"2m\", \"1h\", \"1d\".\n * Returns undefined if parsing fails.\n *\n * @example\n * ```typescript\n * Duration.parse(\"5s\")    // Duration.seconds(5)\n * Duration.parse(\"100ms\") // Duration.millis(100)\n * Duration.parse(\"2m\")    // Duration.minutes(2)\n * ```\n */\nexport function parse(input: string): Duration | undefined {\n  const match = input.trim().match(/^(\\d+(?:\\.\\d+)?)\\s*(ms|s|m|h|d)$/i);\n  if (!match) return undefined;\n\n  const value = parseFloat(match[1]);\n  const unit = match[2].toLowerCase();\n\n  switch (unit) {\n    case \"ms\":\n      return millis(value);\n    case \"s\":\n      return seconds(value);\n    case \"m\":\n      return minutes(value);\n    case \"h\":\n      return hours(value);\n    case \"d\":\n      return days(value);\n    default:\n      return undefined;\n  }\n}\n\n// =============================================================================\n// Namespace Export\n// =============================================================================\n\n/**\n * Duration namespace with all functions for convenient access.\n *\n * @example\n * ```typescript\n * import { Duration } from \"awaitly\";\n *\n * const timeout = Duration.seconds(30);\n * const delay = Duration.millis(100);\n * const total = Duration.add(timeout, delay);\n *\n * console.log(Duration.format(total));  // \"30s 100ms\"\n * ```\n */\nexport const Duration = {\n  // Constructors\n  millis,\n  seconds,\n  minutes,\n  hours,\n  days,\n  zero,\n  infinity,\n\n  // Conversions\n  toMillis,\n  toSeconds,\n  toMinutes,\n  toHours,\n  toDays,\n\n  // Operations\n  add,\n  subtract,\n  multiply,\n  divide,\n\n  // Comparisons\n  lessThan,\n  lessThanOrEqual,\n  greaterThan,\n  greaterThanOrEqual,\n  equals,\n  min,\n  max,\n  clamp,\n\n  // Predicates\n  isZero,\n  isInfinite,\n  isFinite,\n  isDuration,\n\n  // Formatting\n  format,\n  parse,\n} as const;\n\nexport type { Duration as DurationType };\n","/**\n * awaitly/schedule\n *\n * Composable scheduling primitives inspired by Effect's Schedule module.\n * Build complex retry and polling strategies by composing simple building blocks.\n *\n * @example\n * ```typescript\n * // \"Exponential backoff with jitter, max 5 attempts, then poll every minute\"\n * const schedule = Schedule.exponential(Duration.millis(100))\n *   .pipe(Schedule.jittered(0.2))\n *   .pipe(Schedule.upTo(5))\n *   .pipe(Schedule.andThen(Schedule.spaced(Duration.minutes(1))))\n *\n * // Use with workflows\n * const result = await step('fetchData', () => fetchData(), { schedule })\n * ```\n */\n\nimport { Duration, millis, toMillis, multiply, add, type Duration as DurationType } from \"../duration\";\n\n// =============================================================================\n// Types\n// =============================================================================\n\n/**\n * The state maintained by a schedule during execution.\n */\nexport interface ScheduleState {\n  /** Number of iterations completed */\n  readonly iterations: number;\n  /** Total elapsed time since schedule started */\n  readonly elapsed: DurationType;\n  /** The last input received (if any) */\n  readonly lastInput?: unknown;\n  /** The last output produced (if any) */\n  readonly lastOutput?: unknown;\n  /** Combinator-specific metadata (used by andThen, union, intersect, etc.) */\n  readonly meta?: unknown;\n}\n\n/**\n * Decision returned by a schedule step.\n * Combinators can optionally provide `nextState` to thread custom state through execution.\n */\nexport type ScheduleDecision<Out> =\n  | { readonly _tag: \"Continue\"; readonly delay: DurationType; readonly output: Out; readonly nextState?: ScheduleState }\n  | { readonly _tag: \"Done\" };\n\n/**\n * A Schedule defines a recurring pattern with delays and outputs.\n *\n * @typeParam In - The input type (from retry attempts, etc.)\n * @typeParam Out - The output type (often the delay or iteration count)\n */\nexport interface Schedule<In = unknown, Out = unknown> {\n  readonly _tag: \"Schedule\";\n  /** Compute the next step given input and current state */\n  readonly step: (input: In, state: ScheduleState) => ScheduleDecision<Out>;\n  /** Initial state for this schedule */\n  readonly initial: ScheduleState;\n}\n\n// =============================================================================\n// Internal Helpers\n// =============================================================================\n\nconst initialState: ScheduleState = {\n  iterations: 0,\n  elapsed: Duration.zero,\n  lastInput: undefined,\n  lastOutput: undefined,\n};\n\nfunction continueWith<Out>(delay: DurationType, output: Out): ScheduleDecision<Out> {\n  return { _tag: \"Continue\", delay, output };\n}\n\nfunction done<Out>(): ScheduleDecision<Out> {\n  return { _tag: \"Done\" };\n}\n\nfunction updateState(state: ScheduleState, delay: DurationType, input: unknown, output: unknown): ScheduleState {\n  return {\n    iterations: state.iterations + 1,\n    elapsed: add(state.elapsed, delay),\n    lastInput: input,\n    lastOutput: output,\n  };\n}\n\n// =============================================================================\n// Base Schedules\n// =============================================================================\n\n/**\n * A schedule that repeats forever with no delay.\n */\nexport function forever<In = unknown>(): Schedule<In, number> {\n  return {\n    _tag: \"Schedule\",\n    initial: initialState,\n    step: (_input, state) => continueWith(Duration.zero, state.iterations),\n  };\n}\n\n/**\n * A schedule that repeats exactly n times.\n *\n * @example\n * ```typescript\n * const thrice = Schedule.recurs(3)\n * ```\n */\nexport function recurs<In = unknown>(n: number): Schedule<In, number> {\n  return {\n    _tag: \"Schedule\",\n    initial: initialState,\n    step: (_input, state) =>\n      state.iterations < n ? continueWith(Duration.zero, state.iterations) : done(),\n  };\n}\n\n/**\n * A schedule that repeats once.\n */\nexport function once<In = unknown>(): Schedule<In, void> {\n  return {\n    _tag: \"Schedule\",\n    initial: initialState,\n    step: (_input, state) =>\n      state.iterations === 0 ? continueWith(Duration.zero, undefined) : done(),\n  };\n}\n\n/**\n * A schedule that always stops immediately.\n */\nexport function stop<In = unknown>(): Schedule<In, never> {\n  return {\n    _tag: \"Schedule\",\n    initial: initialState,\n    step: () => done(),\n  };\n}\n\n// =============================================================================\n// Delay-Based Schedules\n// =============================================================================\n\n/**\n * A schedule that waits a fixed duration between each iteration.\n *\n * @example\n * ```typescript\n * const pollEvery5s = Schedule.spaced(Duration.seconds(5))\n * ```\n */\nexport function spaced<In = unknown>(delay: DurationType): Schedule<In, number> {\n  return {\n    _tag: \"Schedule\",\n    initial: initialState,\n    step: (_input, state) => continueWith(delay, state.iterations),\n  };\n}\n\n/**\n * Alias for spaced - a fixed interval schedule.\n */\nexport const fixed = spaced;\n\n/**\n * A schedule with exponentially increasing delays.\n * delay(n) = base * factor^n\n *\n * @example\n * ```typescript\n * // 100ms, 200ms, 400ms, 800ms, ...\n * const exponential = Schedule.exponential(Duration.millis(100))\n *\n * // With custom factor: 100ms, 300ms, 900ms, ...\n * const triple = Schedule.exponential(Duration.millis(100), 3)\n * ```\n */\nexport function exponential<In = unknown>(\n  base: DurationType,\n  factor: number = 2\n): Schedule<In, DurationType> {\n  return {\n    _tag: \"Schedule\",\n    initial: initialState,\n    step: (_input, state) => {\n      const delay = multiply(base, Math.pow(factor, state.iterations));\n      return continueWith(delay, delay);\n    },\n  };\n}\n\n/**\n * A schedule with linearly increasing delays.\n * delay(n) = base * (n + 1)\n *\n * @example\n * ```typescript\n * // 100ms, 200ms, 300ms, 400ms, ...\n * const linear = Schedule.linear(Duration.millis(100))\n * ```\n */\nexport function linear<In = unknown>(base: DurationType): Schedule<In, DurationType> {\n  return {\n    _tag: \"Schedule\",\n    initial: initialState,\n    step: (_input, state) => {\n      const delay = multiply(base, state.iterations + 1);\n      return continueWith(delay, delay);\n    },\n  };\n}\n\n/**\n * A schedule with fibonacci-sequence delays.\n * delay(n) follows fibonacci: base, base, 2*base, 3*base, 5*base, ...\n *\n * @example\n * ```typescript\n * // 100ms, 100ms, 200ms, 300ms, 500ms, 800ms, ...\n * const fib = Schedule.fibonacci(Duration.millis(100))\n * ```\n */\nexport function fibonacci<In = unknown>(base: DurationType): Schedule<In, DurationType> {\n  // Precompute fibonacci numbers for reasonable iteration counts\n  const fibNumbers: number[] = [1, 1];\n  for (let i = 2; i < 50; i++) {\n    fibNumbers[i] = fibNumbers[i - 1] + fibNumbers[i - 2];\n  }\n\n  return {\n    _tag: \"Schedule\",\n    initial: initialState,\n    step: (_input, state) => {\n      const fibIndex = Math.min(state.iterations, fibNumbers.length - 1);\n      const delay = multiply(base, fibNumbers[fibIndex]);\n      return continueWith(delay, delay);\n    },\n  };\n}\n\n// =============================================================================\n// Combinators: Limits\n// =============================================================================\n\n/**\n * Limit a schedule to at most n iterations.\n *\n * @example\n * ```typescript\n * // Exponential backoff, max 5 attempts\n * const limited = Schedule.exponential(Duration.millis(100))\n *   .pipe(Schedule.upTo(5))\n * ```\n */\nexport function upTo<In, Out>(\n  n: number\n): (schedule: Schedule<In, Out>) => Schedule<In, Out> {\n  return (schedule) => ({\n    _tag: \"Schedule\",\n    initial: schedule.initial,\n    step: (input, state) => {\n      if (state.iterations >= n) return done();\n      return schedule.step(input, state);\n    },\n  });\n}\n\n/**\n * Limit a schedule by total elapsed time.\n *\n * @example\n * ```typescript\n * // Retry for at most 30 seconds\n * const timeLimited = Schedule.spaced(Duration.seconds(1))\n *   .pipe(Schedule.upToElapsed(Duration.seconds(30)))\n * ```\n */\nexport function upToElapsed<In, Out>(\n  maxElapsed: DurationType\n): (schedule: Schedule<In, Out>) => Schedule<In, Out> {\n  return (schedule) => ({\n    _tag: \"Schedule\",\n    initial: schedule.initial,\n    step: (input, state) => {\n      if (toMillis(state.elapsed) >= toMillis(maxElapsed)) return done();\n      return schedule.step(input, state);\n    },\n  });\n}\n\n/**\n * Cap the maximum delay of a schedule.\n *\n * @example\n * ```typescript\n * // Exponential, but never more than 30 seconds\n * const capped = Schedule.exponential(Duration.millis(100))\n *   .pipe(Schedule.maxDelay(Duration.seconds(30)))\n * ```\n */\nexport function maxDelay<In, Out>(\n  max: DurationType\n): (schedule: Schedule<In, Out>) => Schedule<In, Out> {\n  return (schedule) => ({\n    _tag: \"Schedule\",\n    initial: schedule.initial,\n    step: (input, state) => {\n      const decision = schedule.step(input, state);\n      if (decision._tag === \"Done\") return decision;\n      const capped = toMillis(decision.delay) > toMillis(max) ? max : decision.delay;\n      return continueWith(capped, decision.output);\n    },\n  });\n}\n\n/**\n * Set a minimum delay for a schedule.\n *\n * @example\n * ```typescript\n * const atLeast1s = schedule.pipe(Schedule.minDelay(Duration.seconds(1)))\n * ```\n */\nexport function minDelay<In, Out>(\n  min: DurationType\n): (schedule: Schedule<In, Out>) => Schedule<In, Out> {\n  return (schedule) => ({\n    _tag: \"Schedule\",\n    initial: schedule.initial,\n    step: (input, state) => {\n      const decision = schedule.step(input, state);\n      if (decision._tag === \"Done\") return decision;\n      const floored = toMillis(decision.delay) < toMillis(min) ? min : decision.delay;\n      return continueWith(floored, decision.output);\n    },\n  });\n}\n\n// =============================================================================\n// Combinators: Conditions\n// =============================================================================\n\n/**\n * Continue while a predicate on the input returns true.\n *\n * @example\n * ```typescript\n * // Retry while the error is transient\n * const retryTransient = Schedule.exponential(Duration.millis(100))\n *   .pipe(Schedule.whileInput((err: Error) => err.message.includes(\"ECONNRESET\")))\n * ```\n */\nexport function whileInput<In, Out>(\n  predicate: (input: In) => boolean\n): (schedule: Schedule<In, Out>) => Schedule<In, Out> {\n  return (schedule) => ({\n    _tag: \"Schedule\",\n    initial: schedule.initial,\n    step: (input, state) => {\n      if (!predicate(input)) return done();\n      return schedule.step(input, state);\n    },\n  });\n}\n\n/**\n * Continue while a predicate on the output returns true.\n *\n * @example\n * ```typescript\n * // Poll until status is \"ready\"\n * const untilReady = Schedule.spaced(Duration.seconds(1))\n *   .pipe(Schedule.whileOutput((status: string) => status !== \"ready\"))\n * ```\n */\nexport function whileOutput<In, Out>(\n  predicate: (output: Out) => boolean\n): (schedule: Schedule<In, Out>) => Schedule<In, Out> {\n  return (schedule) => ({\n    _tag: \"Schedule\",\n    initial: schedule.initial,\n    step: (input, state) => {\n      const decision = schedule.step(input, state);\n      if (decision._tag === \"Done\") return decision;\n      if (!predicate(decision.output)) return done();\n      return decision;\n    },\n  });\n}\n\n/**\n * Continue until a predicate on the input returns true.\n * Opposite of whileInput.\n */\nexport function untilInput<In, Out>(\n  predicate: (input: In) => boolean\n): (schedule: Schedule<In, Out>) => Schedule<In, Out> {\n  return whileInput((input: In) => !predicate(input));\n}\n\n/**\n * Continue until a predicate on the output returns true.\n * Opposite of whileOutput.\n */\nexport function untilOutput<In, Out>(\n  predicate: (output: Out) => boolean\n): (schedule: Schedule<In, Out>) => Schedule<In, Out> {\n  return whileOutput((output: Out) => !predicate(output));\n}\n\n// =============================================================================\n// Combinators: Jitter\n// =============================================================================\n\n/**\n * Add random jitter to delays to prevent thundering herd.\n *\n * @param factor - Jitter factor (0.0 to 1.0). Delay will be multiplied by (1 - factor) to (1 + factor).\n *\n * @example\n * ```typescript\n * // ±20% jitter\n * const jittered = Schedule.exponential(Duration.millis(100))\n *   .pipe(Schedule.jittered(0.2))\n * ```\n */\nexport function jittered<In, Out>(\n  factor: number = 0.2\n): (schedule: Schedule<In, Out>) => Schedule<In, Out> {\n  return (schedule) => ({\n    _tag: \"Schedule\",\n    initial: schedule.initial,\n    step: (input, state) => {\n      const decision = schedule.step(input, state);\n      if (decision._tag === \"Done\") return decision;\n\n      // Random factor between (1 - factor) and (1 + factor)\n      const jitterMultiplier = 1 - factor + Math.random() * factor * 2;\n      const jitteredDelay = millis(toMillis(decision.delay) * jitterMultiplier);\n\n      return continueWith(jitteredDelay, decision.output);\n    },\n  });\n}\n\n/**\n * Add a fixed random delay to each iteration.\n *\n * @example\n * ```typescript\n * // Add 0-500ms random delay\n * const randomized = schedule.pipe(Schedule.addDelay(Duration.millis(500)))\n * ```\n */\nexport function addDelay<In, Out>(\n  maxExtra: DurationType\n): (schedule: Schedule<In, Out>) => Schedule<In, Out> {\n  return (schedule) => ({\n    _tag: \"Schedule\",\n    initial: schedule.initial,\n    step: (input, state) => {\n      const decision = schedule.step(input, state);\n      if (decision._tag === \"Done\") return decision;\n\n      const extra = millis(Math.random() * toMillis(maxExtra));\n      const newDelay = add(decision.delay, extra);\n\n      return continueWith(newDelay, decision.output);\n    },\n  });\n}\n\n// =============================================================================\n// Combinators: Composition\n// =============================================================================\n\n/** Internal metadata for andThen combinator */\ninterface AndThenMeta {\n  readonly inSecondPhase: boolean;\n  readonly firstState: ScheduleState;  // Preserves first schedule's state (including its meta)\n  readonly secondState: ScheduleState;\n}\n\n/**\n * Chain two schedules: run the first until done, then run the second.\n * The second schedule starts with fresh state when it begins.\n *\n * @example\n * ```typescript\n * // 5 exponential retries, then poll every minute\n * const strategy = Schedule.exponential(Duration.millis(100))\n *   .pipe(Schedule.upTo(5))\n *   .pipe(Schedule.andThen(Schedule.spaced(Duration.minutes(1))))\n * ```\n */\nexport function andThen<In, Out1, Out2>(\n  second: Schedule<In, Out2>\n): (first: Schedule<In, Out1>) => Schedule<In, Out1 | Out2> {\n  return (first) => {\n    const initialMeta: AndThenMeta = {\n      inSecondPhase: false,\n      firstState: first.initial,   // Preserve first's initial state (including its meta)\n      secondState: second.initial,\n    };\n\n    return {\n      _tag: \"Schedule\",\n      initial: { ...initialState, meta: initialMeta },\n      step: (input, state) => {\n        const meta = (state.meta as AndThenMeta) ?? initialMeta;\n\n        if (!meta.inSecondPhase) {\n          // Pass first's isolated state (not outer state) to preserve its meta\n          const decision = first.step(input, meta.firstState);\n          if (decision._tag === \"Continue\") {\n            // Update first's state - use nextState if provided, otherwise compute it\n            const nextFirstState = decision.nextState ?? updateState(meta.firstState, decision.delay, input, decision.output);\n            const nextState: ScheduleState = {\n              ...updateState(state, decision.delay, input, decision.output),\n              meta: { ...meta, firstState: nextFirstState },\n            };\n            return { _tag: \"Continue\", delay: decision.delay, output: decision.output as Out1 | Out2, nextState };\n          }\n          // First schedule done, switch to second with fresh state\n          const secondDecision = second.step(input, second.initial);\n          if (secondDecision._tag === \"Done\") return done();\n\n          const nextSecondState = secondDecision.nextState ?? updateState(second.initial, secondDecision.delay, input, secondDecision.output);\n          const nextState: ScheduleState = {\n            ...updateState(state, secondDecision.delay, input, secondDecision.output),\n            meta: { inSecondPhase: true, firstState: meta.firstState, secondState: nextSecondState },\n          };\n          return { _tag: \"Continue\", delay: secondDecision.delay, output: secondDecision.output as Out1 | Out2, nextState };\n        }\n\n        // In second phase - use secondState from meta\n        const decision = second.step(input, meta.secondState);\n        if (decision._tag === \"Done\") return done();\n\n        // Update second's state\n        const nextSecondState = decision.nextState ?? updateState(meta.secondState, decision.delay, input, decision.output);\n        const nextState: ScheduleState = {\n          ...updateState(state, decision.delay, input, decision.output),\n          meta: { ...meta, secondState: nextSecondState },\n        };\n\n        return { _tag: \"Continue\", delay: decision.delay, output: decision.output as Out1 | Out2, nextState };\n      },\n    };\n  };\n}\n\n/** Internal metadata for union/intersect combinators */\ninterface ParallelMeta {\n  readonly firstState: ScheduleState;\n  readonly secondState: ScheduleState;\n}\n\n/**\n * Run two schedules in parallel, using the shorter delay.\n * Both schedules advance their state independently.\n *\n * @example\n * ```typescript\n * // Use whichever delay is shorter\n * const union = Schedule.union(\n *   Schedule.exponential(Duration.millis(100)),\n *   Schedule.spaced(Duration.seconds(1))\n * )\n * ```\n */\nexport function union<In, Out1, Out2>(\n  first: Schedule<In, Out1>,\n  second: Schedule<In, Out2>\n): Schedule<In, [Out1, Out2]> {\n  const initialMeta: ParallelMeta = {\n    firstState: first.initial,\n    secondState: second.initial,\n  };\n\n  return {\n    _tag: \"Schedule\",\n    initial: { ...initialState, meta: initialMeta },\n    step: (input, state) => {\n      const meta = (state.meta as ParallelMeta) ?? initialMeta;\n\n      const firstDecision = first.step(input, meta.firstState);\n      const secondDecision = second.step(input, meta.secondState);\n\n      if (firstDecision._tag === \"Done\" && secondDecision._tag === \"Done\") {\n        return done();\n      }\n\n      // Compute next child states - respect nextState if child provides custom state threading\n      const nextFirstState = firstDecision._tag === \"Continue\"\n        ? (firstDecision.nextState ?? updateState(meta.firstState, firstDecision.delay, input, firstDecision.output))\n        : meta.firstState;\n      const nextSecondState = secondDecision._tag === \"Continue\"\n        ? (secondDecision.nextState ?? updateState(meta.secondState, secondDecision.delay, input, secondDecision.output))\n        : meta.secondState;\n\n      // Take the shorter delay\n      const firstDelay = firstDecision._tag === \"Continue\" ? toMillis(firstDecision.delay) : Infinity;\n      const secondDelay = secondDecision._tag === \"Continue\" ? toMillis(secondDecision.delay) : Infinity;\n\n      const delay = millis(Math.min(firstDelay, secondDelay));\n      const output: [Out1, Out2] = [\n        firstDecision._tag === \"Continue\" ? firstDecision.output : (undefined as Out1),\n        secondDecision._tag === \"Continue\" ? secondDecision.output : (undefined as Out2),\n      ];\n\n      const nextState: ScheduleState = {\n        ...updateState(state, delay, input, output),\n        meta: { firstState: nextFirstState, secondState: nextSecondState },\n      };\n\n      return { _tag: \"Continue\", delay, output, nextState };\n    },\n  };\n}\n\n/**\n * Run two schedules in parallel, using the longer delay.\n * Both schedules advance their state independently. Stops when either schedule stops.\n *\n * @example\n * ```typescript\n * // Use whichever delay is longer\n * const intersect = Schedule.intersect(\n *   Schedule.exponential(Duration.millis(100)),\n *   Schedule.spaced(Duration.seconds(1))\n * )\n * ```\n */\nexport function intersect<In, Out1, Out2>(\n  first: Schedule<In, Out1>,\n  second: Schedule<In, Out2>\n): Schedule<In, [Out1, Out2]> {\n  const initialMeta: ParallelMeta = {\n    firstState: first.initial,\n    secondState: second.initial,\n  };\n\n  return {\n    _tag: \"Schedule\",\n    initial: { ...initialState, meta: initialMeta },\n    step: (input, state) => {\n      const meta = (state.meta as ParallelMeta) ?? initialMeta;\n\n      const firstDecision = first.step(input, meta.firstState);\n      const secondDecision = second.step(input, meta.secondState);\n\n      // Both must continue\n      if (firstDecision._tag === \"Done\" || secondDecision._tag === \"Done\") {\n        return done();\n      }\n\n      // Compute next child states - respect nextState if child provides custom state threading\n      const nextFirstState = firstDecision.nextState ?? updateState(meta.firstState, firstDecision.delay, input, firstDecision.output);\n      const nextSecondState = secondDecision.nextState ?? updateState(meta.secondState, secondDecision.delay, input, secondDecision.output);\n\n      // Take the longer delay\n      const delay = millis(Math.max(toMillis(firstDecision.delay), toMillis(secondDecision.delay)));\n      const output: [Out1, Out2] = [firstDecision.output, secondDecision.output];\n\n      const nextState: ScheduleState = {\n        ...updateState(state, delay, input, output),\n        meta: { firstState: nextFirstState, secondState: nextSecondState },\n      };\n\n      return { _tag: \"Continue\", delay, output, nextState };\n    },\n  };\n}\n\n// =============================================================================\n// Combinators: Transformations\n// =============================================================================\n\n/**\n * Transform the output of a schedule.\n *\n * @example\n * ```typescript\n * const withIteration = Schedule.spaced(Duration.seconds(1))\n *   .pipe(Schedule.map((n) => ({ attempt: n + 1 })))\n * ```\n */\nexport function map<In, Out, NewOut>(\n  fn: (output: Out) => NewOut\n): (schedule: Schedule<In, Out>) => Schedule<In, NewOut> {\n  return (schedule) => ({\n    _tag: \"Schedule\",\n    initial: schedule.initial,\n    step: (input, state) => {\n      const decision = schedule.step(input, state);\n      if (decision._tag === \"Done\") return done();\n      return continueWith(decision.delay, fn(decision.output));\n    },\n  });\n}\n\n/**\n * Perform a side effect on each iteration.\n *\n * @example\n * ```typescript\n * const logged = Schedule.exponential(Duration.millis(100))\n *   .pipe(Schedule.tap((delay) => console.log(`Waiting ${delay}ms`)))\n * ```\n */\nexport function tap<In, Out>(\n  fn: (output: Out, state: ScheduleState) => void\n): (schedule: Schedule<In, Out>) => Schedule<In, Out> {\n  return (schedule) => ({\n    _tag: \"Schedule\",\n    initial: schedule.initial,\n    step: (input, state) => {\n      const decision = schedule.step(input, state);\n      if (decision._tag === \"Continue\") {\n        fn(decision.output, state);\n      }\n      return decision;\n    },\n  });\n}\n\n/**\n * Modify the delay of a schedule.\n *\n * @example\n * ```typescript\n * const doubled = schedule.pipe(Schedule.modifyDelay(d => Duration.multiply(d, 2)))\n * ```\n */\nexport function modifyDelay<In, Out>(\n  fn: (delay: DurationType, output: Out) => DurationType\n): (schedule: Schedule<In, Out>) => Schedule<In, Out> {\n  return (schedule) => ({\n    _tag: \"Schedule\",\n    initial: schedule.initial,\n    step: (input, state) => {\n      const decision = schedule.step(input, state);\n      if (decision._tag === \"Done\") return decision;\n      return continueWith(fn(decision.delay, decision.output), decision.output);\n    },\n  });\n}\n\n// =============================================================================\n// Running Schedules\n// =============================================================================\n\n/**\n * Create an iterator for running a schedule step-by-step.\n *\n * @example\n * ```typescript\n * const runner = Schedule.run(mySchedule)\n *\n * while (true) {\n *   const next = runner.next(lastResult)\n *   if (next.done) break\n *   await sleep(next.value.delay)\n * }\n * ```\n */\nexport function run<In, Out>(\n  schedule: Schedule<In, Out>\n): { next: (input: In) => { done: false; value: { delay: DurationType; output: Out } } | { done: true } } {\n  let state = schedule.initial;\n\n  return {\n    next(input: In) {\n      const decision = schedule.step(input, state);\n      if (decision._tag === \"Done\") {\n        return { done: true as const };\n      }\n\n      // Use combinator-provided nextState if available, otherwise compute standard update\n      state = decision.nextState ?? updateState(state, decision.delay, input, decision.output);\n      return {\n        done: false as const,\n        value: { delay: decision.delay, output: decision.output },\n      };\n    },\n  };\n}\n\n/**\n * Get all delays from a schedule (for testing/visualization).\n * Runs the schedule with undefined input until it completes or reaches maxIterations.\n */\nexport function delays<Out>(\n  schedule: Schedule<undefined, Out>,\n  maxIterations: number = 100\n): DurationType[] {\n  const result: DurationType[] = [];\n  const runner = run(schedule);\n\n  for (let i = 0; i < maxIterations; i++) {\n    const next = runner.next(undefined);\n    if (next.done) break;\n    result.push(next.value.delay);\n  }\n\n  return result;\n}\n\n// =============================================================================\n// Pipe Support\n// =============================================================================\n\n/**\n * Type guard to check if a value is a Schedule.\n */\nfunction isSchedule(value: unknown): value is Schedule<unknown, unknown> {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    \"_tag\" in value &&\n    (value as { _tag: unknown })._tag === \"Schedule\"\n  );\n}\n\n/**\n * A schedule with pipe support for method chaining.\n */\ntype PipedSchedule<In, Out> = Schedule<In, Out> & {\n  pipe: <NewOut>(fn: (s: Schedule<In, Out>) => Schedule<In, NewOut>) => PipedSchedule<In, NewOut>;\n} & {\n  pipe: <R>(fn: (s: Schedule<In, Out>) => R) => R;\n};\n\n/**\n * Create a schedule with pipe support for method chaining.\n */\nfunction withPipe<In, Out>(schedule: Schedule<In, Out>): PipedSchedule<In, Out> {\n  return {\n    ...schedule,\n    pipe(fn: (s: Schedule<In, Out>) => unknown): unknown {\n      const result = fn(schedule);\n      if (isSchedule(result)) {\n        return withPipe(result as Schedule<unknown, unknown>);\n      }\n      return result;\n    },\n  } as PipedSchedule<In, Out>;\n}\n\n// Wrapped versions with pipe support\nconst spacedWithPipe = <In = unknown>(delay: DurationType) => withPipe(spaced<In>(delay));\nconst exponentialWithPipe = <In = unknown>(base: DurationType, factor?: number) => withPipe(exponential<In>(base, factor));\nconst linearWithPipe = <In = unknown>(base: DurationType) => withPipe(linear<In>(base));\nconst fibonacciWithPipe = <In = unknown>(base: DurationType) => withPipe(fibonacci<In>(base));\nconst recursWithPipe = <In = unknown>(n: number) => withPipe(recurs<In>(n));\nconst foreverWithPipe = <In = unknown>() => withPipe(forever<In>());\nconst onceWithPipe = <In = unknown>() => withPipe(once<In>());\nconst unionWithPipe = <In, Out1, Out2>(first: Schedule<In, Out1>, second: Schedule<In, Out2>) => withPipe(union(first, second));\nconst intersectWithPipe = <In, Out1, Out2>(first: Schedule<In, Out1>, second: Schedule<In, Out2>) => withPipe(intersect(first, second));\n\n// =============================================================================\n// Namespace Export\n// =============================================================================\n\n/**\n * Schedule namespace for composable scheduling.\n *\n * @example\n * ```typescript\n * import { Schedule, Duration } from \"awaitly\";\n *\n * // Exponential backoff with jitter, max 5 attempts\n * const retry = Schedule.exponential(Duration.millis(100))\n *   .pipe(Schedule.jittered(0.2))\n *   .pipe(Schedule.upTo(5))\n *   .pipe(Schedule.maxDelay(Duration.seconds(30)))\n *\n * // Then poll every minute forever\n * const poll = Schedule.spaced(Duration.minutes(1))\n *\n * // Chain them\n * const strategy = retry.pipe(Schedule.andThen(poll))\n * ```\n */\nexport const Schedule = {\n  // Base schedules\n  forever: foreverWithPipe,\n  once: onceWithPipe,\n  recurs: recursWithPipe,\n  stop,\n\n  // Delay-based\n  spaced: spacedWithPipe,\n  fixed: spacedWithPipe,\n  exponential: exponentialWithPipe,\n  linear: linearWithPipe,\n  fibonacci: fibonacciWithPipe,\n\n  // Limits\n  upTo,\n  upToElapsed,\n  maxDelay,\n  minDelay,\n\n  // Conditions\n  whileInput,\n  whileOutput,\n  untilInput,\n  untilOutput,\n\n  // Jitter\n  jittered,\n  addDelay,\n\n  // Composition\n  andThen,\n  union: unionWithPipe,\n  intersect: intersectWithPipe,\n\n  // Transformations\n  map,\n  tap,\n  modifyDelay,\n\n  // Running\n  run,\n  delays,\n} as const;\n\nexport type { Schedule as ScheduleType };\n"],"mappings":"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","names":["retry_entry_exports","__export","Duration","Schedule","addDelay","andThen","days","delays","exponential","fibonacci","fixed","forever","hours","intersect","isDuration","jittered","linear","map","maxDelay","millis","minDelay","minutes","modifyDelay","once","recurs","run","seconds","spaced","stop","tap","toDays","toHours","toMillis","toMinutes","toSeconds","union","untilInput","untilOutput","upTo","upToElapsed","whileInput","whileOutput","__toCommonJS","millis","ms","seconds","s","minutes","m","hours","h","days","d","zero","infinity","toMillis","duration","toSeconds","toMinutes","toHours","toDays","add","a","b","subtract","multiply","factor","divide","divisor","lessThan","lessThanOrEqual","greaterThan","greaterThanOrEqual","equals","min","max","clamp","minimum","maximum","isZero","isInfinite","isFinite","isDuration","value","format","parts","parse","input","match","Duration","initialState","Duration","continueWith","delay","output","done","updateState","state","input","add","forever","_input","recurs","n","once","stop","spaced","fixed","exponential","base","factor","multiply","linear","fibonacci","fibNumbers","i","fibIndex","upTo","schedule","upToElapsed","maxElapsed","toMillis","maxDelay","max","decision","capped","minDelay","min","floored","whileInput","predicate","whileOutput","untilInput","untilOutput","jittered","jitterMultiplier","jitteredDelay","millis","addDelay","maxExtra","extra","newDelay","andThen","second","first","initialMeta","meta","nextFirstState","nextState","secondDecision","nextSecondState","union","firstDecision","firstDelay","secondDelay","intersect","map","fn","tap","modifyDelay","run","delays","maxIterations","result","runner","next","isSchedule","value","withPipe","spacedWithPipe","exponentialWithPipe","linearWithPipe","fibonacciWithPipe","recursWithPipe","foreverWithPipe","onceWithPipe","unionWithPipe","intersectWithPipe","Schedule"]}