awaitly 1.34.0 → 2.0.0

package/dist/functional.cjs

@@ -1,2 +0,0 @@
-"use strict";var p=Object.defineProperty;var J=Object.getOwnPropertyDescriptor;var W=Object.getOwnPropertyNames;var Y=Object.prototype.hasOwnProperty;var Z=(e,n)=>{for(var r in n)p(e,r,{get:n[r],enumerable:!0})},q=(e,n,r,t)=>{if(n&&typeof n=="object"||typeof n=="function")for(let o of W(n))!Y.call(e,o)&&o!==r&&p(e,o,{get:()=>n[o],enumerable:!(t=J(n,o))||t.enumerable});return e};var X=e=>q(p({},"__esModule",{value:!0}),e);var $={};Z($,{R:()=>z,all:()=>S,allAsync:()=>U,allSettled:()=>K,allSettledAsync:()=>G,any:()=>M,anyAsync:()=>V,bimap:()=>d,compose:()=>O,flatMap:()=>k,flatMapAsync:()=>F,flow:()=>B,getOrElse:()=>P,getOrElseLazy:()=>h,identity:()=>g,map:()=>R,mapAsync:()=>D,mapError:()=>y,match:()=>A,pipe:()=>b,race:()=>_,recover:()=>m,recoverWith:()=>v,tap:()=>x,tapAsync:()=>j,tapError:()=>w,tapErrorAsync:()=>I,traverse:()=>H,traverseAsync:()=>N,traverseParallel:()=>L});module.exports=X($);var f="PROMISE_REJECTED";function c(e){return{ok:!0,value:e}}function i(e,n){let r=n?.cause;return{ok:!1,error:e,...r!==void 0?{cause:r}:{}}}var s=e=>e.ok,l=e=>!e.ok;function b(e,...n){return n.reduce((r,t)=>t(r),e)}function B(...e){return n=>e.reduce((r,t)=>t(r),n)}function O(...e){return n=>e.reduceRight((r,t)=>t(r),n)}var g=e=>e;function R(e,n){return s(e)?c(n(e.value)):e}function k(e,n){return s(e)?n(e.value):e}function d(e,n,r){return s(e)?c(n(e.value)):i(r(e.error),{cause:e.cause})}function y(e,n){return l(e)?i(n(e.error),{cause:e.cause}):e}function x(e,n){return s(e)&&n(e.value),e}function w(e,n){return l(e)&&n(e.error),e}function A(e,n){return s(e)?n.ok(e.value):n.err(e.error,e.cause)}function m(e,n){return s(e)?e.value:n(e.error)}function v(e,n){return s(e)?e:n(e.error)}function P(e,n){return s(e)?e.value:n}function h(e,n){return s(e)?e.value:n()}async function D(e,n){let r=await e;return s(r)?c(await n(r.value)):r}async function F(e,n){let r=await e;return s(r)?n(r.value):r}async function j(e,n){let r=await e;return s(r)&&await n(r.value),r}async function I(e,n){let r=await e;return l(r)&&await n(r.error),r}function S(e){let n=[];for(let r of e){if(l(r))return r;n.push(r.value)}return c(n)}async function U(e){if(e.length===0)return c([]);let n=new Array(e.length),r=0,t=!1;return new Promise(o=>{e.forEach((T,a)=>{T.then(u=>{t||(l(u)?(t=!0,o(u)):(n[a]=u.value,r++,r===e.length&&(t=!0,o(c(n)))))},u=>{t||(t=!0,o(i({type:f,cause:u},{cause:{type:"PROMISE_REJECTION",reason:u}})))})})})}function K(e){let n=[],r=[];for(let t of e)s(t)?n.push(t.value):r.push(t.error);return{ok:n,err:r}}async function G(e){if(e.length===0)return{ok:[],err:[]};let n=new Array(e.length),r=0;return new Promise(t=>{e.forEach((o,T)=>{o.then(a=>{if(s(a)?n[T]={type:"ok",value:a.value}:n[T]={type:"err",error:a.error},r++,r===e.length){let u=[],E=[];for(let C of n)C.type==="ok"?u.push(C.value):E.push(C.error);t({ok:u,err:E})}},a=>{if(n[T]={type:"err",error:{type:f,cause:a}},r++,r===e.length){let u=[],E=[];for(let C of n)C.type==="ok"?u.push(C.value):E.push(C.error);t({ok:u,err:E})}})})})}function M(e){let n=[];for(let r of e){if(s(r))return r;n.push(r.error)}return i(n)}async function V(e){if(e.length===0)return i([]);let n=new Array(e.length),r=0,t=!1;return new Promise(o=>{e.forEach((T,a)=>{T.then(u=>{t||(s(u)?(t=!0,o(u)):(n[a]=u.error,r++,r===e.length&&(t=!0,o(i(n.filter(E=>E!==void 0))))))},u=>{t||(n[a]={type:f,cause:u},r++,r===e.length&&(t=!0,o(i(n.filter(E=>E!==void 0)))))})})})}async function _(e){return Promise.race(e.map(n=>n.catch(r=>i({type:f,cause:r},{cause:{type:"PROMISE_REJECTION",reason:r}}))))}function H(e,n){let r=[];for(let t=0;t<e.length;t++){let o=n(e[t],t);if(l(o))return o;r.push(o.value)}return c(r)}async function N(e,n){let r=[];for(let t=0;t<e.length;t++){let o=await n(e[t],t);if(l(o))return o;r.push(o.value)}return c(r)}async function L(e,n){return U(e.map((r,t)=>n(r,t)))}var z={map:e=>n=>R(n,e),flatMap:e=>n=>k(n,e),bimap:(e,n)=>r=>d(r,e,n),mapError:e=>n=>y(n,e),tap:e=>n=>x(n,e),tapError:e=>n=>w(n,e),match:e=>n=>A(n,e),recover:e=>n=>m(n,e),recoverWith:e=>n=>v(n,e),getOrElse:e=>n=>P(n,e),getOrElseLazy:e=>n=>h(n,e)};0&&(module.exports={R,all,allAsync,allSettled,allSettledAsync,any,anyAsync,bimap,compose,flatMap,flatMapAsync,flow,getOrElse,getOrElseLazy,identity,map,mapAsync,mapError,match,pipe,race,recover,recoverWith,tap,tapAsync,tapError,tapErrorAsync,traverse,traverseAsync,traverseParallel});
-//# sourceMappingURL=functional.cjs.map

package/dist/functional.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/functional-entry.ts","../src/result/index.ts","../src/functional/index.ts"],"sourcesContent":["/**\n * awaitly/functional\n *\n * Effect-inspired functional utilities for Result types.\n * Provides pipe-based composition with automatic error short-circuiting.\n *\n * @example\n * ```typescript\n * import { pipe, R, map, flatMap, match } from 'awaitly/functional';\n *\n * // Pipe with curried combinators\n * const result = pipe(\n *   fetchUser(id),\n *   R.flatMap(user => fetchPosts(user.id)),\n *   R.map(posts => posts.filter(p => p.published)),\n *   R.match({\n *     ok: posts => `Found ${posts.length} posts`,\n *     err: error => `Failed: ${error}`\n *   })\n * );\n * ```\n */\n\nexport {\n  // Composition\n  pipe,\n  flow,\n  compose,\n  identity,\n\n  // Result combinators (sync)\n  map,\n  flatMap,\n  bimap,\n  mapError,\n  tap,\n  tapError,\n  match,\n  recover,\n  recoverWith,\n  getOrElse,\n  getOrElseLazy,\n\n  // Result combinators (async)\n  mapAsync,\n  flatMapAsync,\n  tapAsync,\n  tapErrorAsync,\n\n  // Collection utilities\n  all,\n  allAsync,\n  allSettled,\n  allSettledAsync,\n  any,\n  anyAsync,\n  race,\n  traverse,\n  traverseAsync,\n  traverseParallel,\n\n  // Pipeable namespace\n  R,\n} from \"./functional\";\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/functional\n *\n * Effect-inspired functional utilities for Result types.\n * Provides pipe-based composition with automatic error short-circuiting.\n */\n\nimport type { Result, AsyncResult, PromiseRejectedError, PromiseRejectionCause } from \"../result\";\nimport { ok, err, isOk, isErr, PROMISE_REJECTED } from \"../result\";\n\n// =============================================================================\n// Composition\n// =============================================================================\n\n/**\n * Pipe a value through a series of functions left-to-right.\n *\n * @example\n * ```typescript\n * const result = pipe(\n *   5,\n *   (x) => x * 2,\n *   (x) => x + 1\n * ); // 11\n * ```\n */\nexport function pipe<A>(a: A): A;\nexport function pipe<A, B>(a: A, ab: (a: A) => B): B;\nexport function pipe<A, B, C>(a: A, ab: (a: A) => B, bc: (b: B) => C): C;\nexport function pipe<A, B, C, D>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;\nexport function pipe<A, B, C, D, E>(\n  a: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E\n): E;\nexport function pipe<A, B, C, D, E, F>(\n  a: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F\n): F;\nexport function pipe<A, B, C, D, E, F, G>(\n  a: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G\n): G;\nexport function pipe<A, B, C, D, E, F, G, H>(\n  a: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H\n): H;\nexport function pipe<A, B, C, D, E, F, G, H, I>(\n  a: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I\n): I;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function pipe(a: unknown, ...fns: Array<(x: any) => any>): unknown {\n  return fns.reduce((acc, fn) => fn(acc), a);\n}\n\n/**\n * Compose functions left-to-right (returns a function).\n *\n * @example\n * ```typescript\n * const double = (x: number) => x * 2;\n * const addOne = (x: number) => x + 1;\n * const transform = flow(double, addOne);\n * transform(5); // 11\n * ```\n */\nexport function flow<A, B>(ab: (a: A) => B): (a: A) => B;\nexport function flow<A, B, C>(ab: (a: A) => B, bc: (b: B) => C): (a: A) => C;\nexport function flow<A, B, C, D>(ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): (a: A) => D;\nexport function flow<A, B, C, D, E>(\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E\n): (a: A) => E;\nexport function flow<A, B, C, D, E, F>(\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F\n): (a: A) => F;\nexport function flow<A, B, C, D, E, F, G>(\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G\n): (a: A) => G;\nexport function flow<A, B, C, D, E, F, G, H>(\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H\n): (a: A) => H;\nexport function flow<A, B, C, D, E, F, G, H, I>(\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I\n): (a: A) => I;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function flow(...fns: Array<(x: any) => any>): (a: unknown) => unknown {\n  return (a: unknown) => fns.reduce((acc, fn) => fn(acc), a);\n}\n\n/**\n * Compose functions right-to-left.\n *\n * @example\n * ```typescript\n * const double = (x: number) => x * 2;\n * const addOne = (x: number) => x + 1;\n * const transform = compose(addOne, double);\n * transform(5); // 11 (double first, then addOne)\n * ```\n */\nexport function compose<A, B>(ab: (a: A) => B): (a: A) => B;\nexport function compose<A, B, C>(bc: (b: B) => C, ab: (a: A) => B): (a: A) => C;\nexport function compose<A, B, C, D>(cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => D;\nexport function compose<A, B, C, D, E>(\n  de: (d: D) => E,\n  cd: (c: C) => D,\n  bc: (b: B) => C,\n  ab: (a: A) => B\n): (a: A) => E;\nexport function compose<A, B, C, D, E, F>(\n  ef: (e: E) => F,\n  de: (d: D) => E,\n  cd: (c: C) => D,\n  bc: (b: B) => C,\n  ab: (a: A) => B\n): (a: A) => F;\nexport function compose<A, B, C, D, E, F, G>(\n  fg: (f: F) => G,\n  ef: (e: E) => F,\n  de: (d: D) => E,\n  cd: (c: C) => D,\n  bc: (b: B) => C,\n  ab: (a: A) => B\n): (a: A) => G;\nexport function compose<A, B, C, D, E, F, G, H>(\n  gh: (g: G) => H,\n  fg: (f: F) => G,\n  ef: (e: E) => F,\n  de: (d: D) => E,\n  cd: (c: C) => D,\n  bc: (b: B) => C,\n  ab: (a: A) => B\n): (a: A) => H;\nexport function compose<A, B, C, D, E, F, G, H, I>(\n  hi: (h: H) => I,\n  gh: (g: G) => H,\n  fg: (f: F) => G,\n  ef: (e: E) => F,\n  de: (d: D) => E,\n  cd: (c: C) => D,\n  bc: (b: B) => C,\n  ab: (a: A) => B\n): (a: A) => I;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function compose(...fns: Array<(x: any) => any>): (a: unknown) => unknown {\n  return (a: unknown) => fns.reduceRight((acc, fn) => fn(acc), a);\n}\n\n/**\n * Identity function - returns its argument unchanged.\n *\n * @example\n * ```typescript\n * identity(42); // 42\n * ```\n */\nexport const identity = <A>(a: A): A => a;\n\n// =============================================================================\n// Result Combinators (sync)\n// =============================================================================\n\n/**\n * Transform the success value of a Result.\n *\n * @example\n * ```typescript\n * const result = Awaitly.ok(5);\n * map(result, (x) => x * 2); // Awaitly.ok(10)\n *\n * const error = Awaitly.err(\"not found\");\n * map(error, (x) => x * 2); // Awaitly.err(\"not found\")\n * ```\n */\nexport function map<T, U, E, C>(result: Result<T, E, C>, fn: (value: T) => U): Result<U, E, C> {\n  if (isOk(result)) {\n    return ok(fn(result.value));\n  }\n  return result as Result<U, E, C>;\n}\n\n/**\n * Transform and flatten (short-circuits on error).\n *\n * @example\n * ```typescript\n * const divide = (a: number, b: number): Result<number, string> =>\n *   b === 0 ? Awaitly.err(\"division by zero\") : Awaitly.ok(a / b);\n *\n * const result = Awaitly.ok(10);\n * flatMap(result, (x) => divide(x, 2)); // Awaitly.ok(5)\n * flatMap(result, (x) => divide(x, 0)); // Awaitly.err(\"division by zero\")\n * ```\n */\nexport function flatMap<T, U, E1, E2, C1, C2>(\n  result: Result<T, E1, C1>,\n  fn: (value: T) => Result<U, E2, C2>\n): Result<U, E1 | E2, C1 | C2> {\n  if (isOk(result)) {\n    return fn(result.value);\n  }\n  return result as Result<U, E1 | E2, C1 | C2>;\n}\n\n/**\n * Transform both success and error values.\n *\n * @example\n * ```typescript\n * const result = Awaitly.ok(5);\n * bimap(result, (x) => x * 2, (e) => `Error: ${e}`); // Awaitly.ok(10)\n *\n * const error = Awaitly.err(\"not found\");\n * bimap(error, (x) => x * 2, (e) => `Error: ${e}`); // Awaitly.err(\"Error: not found\")\n * ```\n */\nexport function bimap<T, U, E1, E2, C>(\n  result: Result<T, E1, C>,\n  onOk: (value: T) => U,\n  onErr: (error: E1) => E2\n): Result<U, E2, C> {\n  if (isOk(result)) {\n    return ok(onOk(result.value));\n  }\n  return err(onErr(result.error), { cause: result.cause }) as Result<U, E2, C>;\n}\n\n/**\n * Transform the error value.\n *\n * @example\n * ```typescript\n * const error = Awaitly.err(\"not found\");\n * mapError(error, (e) => ({ type: \"ERROR\", message: e }));\n * // Awaitly.err({ type: \"ERROR\", message: \"not found\" })\n * ```\n */\nexport function mapError<T, E1, E2, C>(\n  result: Result<T, E1, C>,\n  fn: (error: E1) => E2\n): Result<T, E2, C> {\n  if (isErr(result)) {\n    return err(fn(result.error), { cause: result.cause }) as Result<T, E2, C>;\n  }\n  return result as Result<T, E2, C>;\n}\n\n/**\n * Side effect on success (returns original result).\n *\n * @example\n * ```typescript\n * const result = Awaitly.ok(5);\n * tap(result, (x) => console.log(`Value: ${x}`)); // logs \"Value: 5\", returns Awaitly.ok(5)\n * ```\n */\nexport function tap<T, E, C>(result: Result<T, E, C>, fn: (value: T) => void): Result<T, E, C> {\n  if (isOk(result)) {\n    fn(result.value);\n  }\n  return result;\n}\n\n/**\n * Side effect on error (returns original result).\n *\n * @example\n * ```typescript\n * const error = Awaitly.err(\"not found\");\n * tapError(error, (e) => console.log(`Error: ${e}`)); // logs \"Error: not found\", returns err\n * ```\n */\nexport function tapError<T, E, C>(result: Result<T, E, C>, fn: (error: E) => void): Result<T, E, C> {\n  if (isErr(result)) {\n    fn(result.error);\n  }\n  return result;\n}\n\n/**\n * Pattern match on Result.\n *\n * @example\n * ```typescript\n * const result = Awaitly.ok(5);\n * match(result, {\n *   ok: (x) => `Success: ${x}`,\n *   err: (e) => `Error: ${e}`\n * }); // \"Success: 5\"\n * ```\n */\nexport function match<T, E, U, C>(\n  result: Result<T, E, C>,\n  patterns: { ok: (value: T) => U; err: (error: E, cause?: C) => U }\n): U {\n  if (isOk(result)) {\n    return patterns.ok(result.value);\n  }\n  return patterns.err(result.error, result.cause);\n}\n\n/**\n * Recover from error by providing fallback value.\n *\n * @example\n * ```typescript\n * const error = Awaitly.err(\"not found\");\n * recover(error, () => 0); // 0\n *\n * const success = Awaitly.ok(5);\n * recover(success, () => 0); // 5\n * ```\n */\nexport function recover<T, E, C>(result: Result<T, E, C>, fn: (error: E) => T): T {\n  if (isOk(result)) {\n    return result.value;\n  }\n  return fn(result.error);\n}\n\n/**\n * Recover from error with another Result.\n *\n * @example\n * ```typescript\n * const error = Awaitly.err(\"not found\");\n * recoverWith(error, (e) => ok(0)); // ok(0)\n * recoverWith(error, (e) => err(\"still failed\")); // err(\"still failed\")\n * ```\n */\nexport function recoverWith<T, E1, E2, C1, C2>(\n  result: Result<T, E1, C1>,\n  fn: (error: E1) => Result<T, E2, C2>\n): Result<T, E2, C1 | C2> {\n  if (isOk(result)) {\n    return result as Result<T, E2, C1 | C2>;\n  }\n  return fn(result.error);\n}\n\n/**\n * Get the value or a default.\n *\n * @example\n * ```typescript\n * const error = Awaitly.err(\"not found\");\n * getOrElse(error, 0); // 0\n *\n * const success = Awaitly.ok(5);\n * getOrElse(success, 0); // 5\n * ```\n */\nexport function getOrElse<T, E, C>(result: Result<T, E, C>, defaultValue: T): T {\n  if (isOk(result)) {\n    return result.value;\n  }\n  return defaultValue;\n}\n\n/**\n * Get the value or compute a default lazily.\n *\n * @example\n * ```typescript\n * const error = Awaitly.err(\"not found\");\n * getOrElseLazy(error, () => expensiveComputation()); // calls expensiveComputation()\n *\n * const success = Awaitly.ok(5);\n * getOrElseLazy(success, () => expensiveComputation()); // 5, doesn't call expensiveComputation\n * ```\n */\nexport function getOrElseLazy<T, E, C>(result: Result<T, E, C>, fn: () => T): T {\n  if (isOk(result)) {\n    return result.value;\n  }\n  return fn();\n}\n\n// =============================================================================\n// Result Combinators (async)\n// =============================================================================\n\n/**\n * Transform success value asynchronously.\n *\n * @example\n * ```typescript\n * const result = Awaitly.ok(5);\n * await mapAsync(result, async (x) => x * 2); // ok(10)\n * ```\n */\nexport async function mapAsync<T, U, E, C>(\n  result: Result<T, E, C> | AsyncResult<T, E, C>,\n  fn: (value: T) => Promise<U>\n): AsyncResult<U, E, C> {\n  const resolved = await result;\n  if (isOk(resolved)) {\n    return ok(await fn(resolved.value));\n  }\n  return resolved as Result<U, E, C>;\n}\n\n/**\n * Async flatMap.\n *\n * @example\n * ```typescript\n * const fetchUser = async (id: string): AsyncResult<User, \"NOT_FOUND\"> => { ... };\n * const result = Awaitly.ok(\"user-123\");\n * await flatMapAsync(result, fetchUser); // AsyncResult<User, \"NOT_FOUND\">\n * ```\n */\nexport async function flatMapAsync<T, U, E1, E2, C1, C2>(\n  result: Result<T, E1, C1> | AsyncResult<T, E1, C1>,\n  fn: (value: T) => AsyncResult<U, E2, C2>\n): AsyncResult<U, E1 | E2, C1 | C2> {\n  const resolved = await result;\n  if (isOk(resolved)) {\n    return fn(resolved.value);\n  }\n  return resolved as Result<U, E1 | E2, C1 | C2>;\n}\n\n/**\n * Async tap - side effect on success.\n *\n * @example\n * ```typescript\n * const result = Awaitly.ok(5);\n * await tapAsync(result, async (x) => {\n *   await logToServer(x);\n * }); // ok(5)\n * ```\n */\nexport async function tapAsync<T, E, C>(\n  result: Result<T, E, C> | AsyncResult<T, E, C>,\n  fn: (value: T) => Promise<void>\n): AsyncResult<T, E, C> {\n  const resolved = await result;\n  if (isOk(resolved)) {\n    await fn(resolved.value);\n  }\n  return resolved;\n}\n\n/**\n * Async tapError - side effect on error.\n *\n * @example\n * ```typescript\n * const error = Awaitly.err(\"not found\");\n * await tapErrorAsync(error, async (e) => {\n *   await logErrorToServer(e);\n * }); // err(\"not found\")\n * ```\n */\nexport async function tapErrorAsync<T, E, C>(\n  result: Result<T, E, C> | AsyncResult<T, E, C>,\n  fn: (error: E) => Promise<void>\n): AsyncResult<T, E, C> {\n  const resolved = await result;\n  if (isErr(resolved)) {\n    await fn(resolved.error);\n  }\n  return resolved;\n}\n\n// =============================================================================\n// Collection Utilities (Result-aware)\n// =============================================================================\n\n/**\n * Combine array of Results - fails fast on first error.\n *\n * @example\n * ```typescript\n * all([ok(1), ok(2), ok(3)]); // ok([1, 2, 3])\n * all([ok(1), err(\"fail\"), ok(3)]); // err(\"fail\")\n * ```\n */\nexport function all<T, E, C>(results: Result<T, E, C>[]): Result<T[], E, C> {\n  const values: T[] = [];\n  for (const result of results) {\n    if (isErr(result)) {\n      return result as Result<T[], E, C>;\n    }\n    values.push(result.value);\n  }\n  return ok(values);\n}\n\n/**\n * Combine array of AsyncResults - parallel execution, fails fast.\n *\n * Returns immediately when any result fails, without waiting for\n * pending promises. Only returns all values if every result succeeds.\n *\n * @example\n * ```typescript\n * await allAsync([\n *   fetchUser(\"1\"),\n *   fetchUser(\"2\"),\n *   fetchUser(\"3\")\n * ]); // AsyncResult<User[], \"NOT_FOUND\">\n * ```\n */\nexport async function allAsync<T, E, C>(\n  results: AsyncResult<T, E, C>[]\n): AsyncResult<T[], E | PromiseRejectedError, C | PromiseRejectionCause> {\n  if (results.length === 0) {\n    return ok([]);\n  }\n\n  const values: T[] = new Array(results.length);\n  let settledCount = 0;\n  let done = false;\n\n  return new Promise((resolve) => {\n    results.forEach((resultPromise, index) => {\n      resultPromise.then(\n        (result) => {\n          if (done) return;\n          if (isErr(result)) {\n            done = true;\n            resolve(result as Result<T[], E | PromiseRejectedError, C | PromiseRejectionCause>);\n          } else {\n            values[index] = result.value;\n            settledCount++;\n            if (settledCount === results.length) {\n              done = true;\n              resolve(ok(values));\n            }\n          }\n        },\n        (reason) => {\n          if (done) return;\n          done = true;\n          resolve(\n            err(\n              { type: PROMISE_REJECTED, cause: reason } as PromiseRejectedError,\n              { cause: { type: \"PROMISE_REJECTION\" as const, reason } as PromiseRejectionCause }\n            )\n          );\n        }\n      );\n    });\n  });\n}\n\n/**\n * Collect all results, separating successes and failures.\n *\n * @example\n * ```typescript\n * allSettled([ok(1), err(\"a\"), ok(2), err(\"b\")]);\n * // { ok: [1, 2], err: [\"a\", \"b\"] }\n * ```\n */\nexport function allSettled<T, E, C>(results: Result<T, E, C>[]): { ok: T[]; err: E[] } {\n  const okValues: T[] = [];\n  const errValues: E[] = [];\n  for (const result of results) {\n    if (isOk(result)) {\n      okValues.push(result.value);\n    } else {\n      errValues.push(result.error);\n    }\n  }\n  return { ok: okValues, err: errValues };\n}\n\n/**\n * Async version of allSettled.\n *\n * Handles rejected promises by treating them as errors with\n * type PROMISE_REJECTED.\n *\n * @example\n * ```typescript\n * await allSettledAsync([\n *   fetchUser(\"1\"),\n *   fetchUser(\"2\"),\n *   fetchUser(\"3\")\n * ]); // { ok: [...users], err: [...errors] }\n * ```\n */\nexport async function allSettledAsync<T, E, C>(\n  results: AsyncResult<T, E, C>[]\n): Promise<{ ok: T[]; err: (E | PromiseRejectedError)[] }> {\n  if (results.length === 0) {\n    return { ok: [], err: [] };\n  }\n\n  type Settled = { type: \"ok\"; value: T } | { type: \"err\"; error: E | PromiseRejectedError };\n  const settled: Settled[] = new Array(results.length);\n  let settledCount = 0;\n\n  return new Promise((resolve) => {\n    results.forEach((resultPromise, index) => {\n      resultPromise.then(\n        (result) => {\n          if (isOk(result)) {\n            settled[index] = { type: \"ok\", value: result.value };\n          } else {\n            settled[index] = { type: \"err\", error: result.error };\n          }\n          settledCount++;\n          if (settledCount === results.length) {\n            const okValues: T[] = [];\n            const errValues: (E | PromiseRejectedError)[] = [];\n            for (const s of settled) {\n              if (s.type === \"ok\") {\n                okValues.push(s.value);\n              } else {\n                errValues.push(s.error);\n              }\n            }\n            resolve({ ok: okValues, err: errValues });\n          }\n        },\n        (reason) => {\n          settled[index] = { type: \"err\", error: { type: PROMISE_REJECTED, cause: reason } as PromiseRejectedError };\n          settledCount++;\n          if (settledCount === results.length) {\n            const okValues: T[] = [];\n            const errValues: (E | PromiseRejectedError)[] = [];\n            for (const s of settled) {\n              if (s.type === \"ok\") {\n                okValues.push(s.value);\n              } else {\n                errValues.push(s.error);\n              }\n            }\n            resolve({ ok: okValues, err: errValues });\n          }\n        }\n      );\n    });\n  });\n}\n\n/**\n * Return first success, or all errors if all fail.\n *\n * @example\n * ```typescript\n * any([err(\"a\"), ok(1), err(\"b\")]); // ok(1)\n * any([err(\"a\"), err(\"b\"), err(\"c\")]); // err([\"a\", \"b\", \"c\"])\n * ```\n */\nexport function any<T, E, C>(results: Result<T, E, C>[]): Result<T, E[], C> {\n  const errors: E[] = [];\n  for (const result of results) {\n    if (isOk(result)) {\n      return result as Result<T, E[], C>;\n    }\n    errors.push(result.error);\n  }\n  return err(errors);\n}\n\n/**\n * Async version of any - returns first success immediately.\n *\n * Returns as soon as any result succeeds, without waiting for\n * pending promises. Only returns all errors if every result fails.\n *\n * @example\n * ```typescript\n * await anyAsync([\n *   fetchFromCache(key),\n *   fetchFromDb(key),\n *   fetchFromApi(key)\n * ]); // First successful result\n * ```\n */\nexport async function anyAsync<T, E, C>(\n  results: AsyncResult<T, E, C>[]\n): AsyncResult<T, (E | PromiseRejectedError)[], C | PromiseRejectionCause> {\n  if (results.length === 0) {\n    return err([]);\n  }\n\n  const errors: (E | PromiseRejectedError | undefined)[] = new Array(results.length);\n  let settledCount = 0;\n  let done = false;\n\n  return new Promise((resolve) => {\n    results.forEach((resultPromise, index) => {\n      resultPromise.then(\n        (result) => {\n          if (done) return;\n          if (isOk(result)) {\n            done = true;\n            resolve(result as Result<T, (E | PromiseRejectedError)[], C | PromiseRejectionCause>);\n          } else {\n            errors[index] = result.error;\n            settledCount++;\n            if (settledCount === results.length) {\n              done = true;\n              resolve(err(errors.filter((e): e is E | PromiseRejectedError => e !== undefined)));\n            }\n          }\n        },\n        (reason) => {\n          if (done) return;\n          errors[index] = { type: PROMISE_REJECTED, cause: reason } as PromiseRejectedError;\n          settledCount++;\n          if (settledCount === results.length) {\n            done = true;\n            resolve(err(errors.filter((e): e is E | PromiseRejectedError => e !== undefined)));\n          }\n        }\n      );\n    });\n  });\n}\n\n/**\n * Race async results - first to complete wins.\n *\n * Handles rejected promises by converting them to err() results\n * with type PROMISE_REJECTED.\n *\n * @example\n * ```typescript\n * await race([\n *   fetchFromPrimaryServer(id),\n *   fetchFromBackupServer(id)\n * ]); // Result from whichever server responds first\n * ```\n */\nexport async function race<T, E, C>(\n  results: AsyncResult<T, E, C>[]\n): AsyncResult<T, E | PromiseRejectedError, C | PromiseRejectionCause> {\n  return Promise.race(\n    results.map((p) =>\n      p.catch(\n        (reason) =>\n          err(\n            { type: PROMISE_REJECTED, cause: reason } as PromiseRejectedError,\n            { cause: { type: \"PROMISE_REJECTION\" as const, reason } as PromiseRejectionCause }\n          ) as Result<T, E | PromiseRejectedError, C | PromiseRejectionCause>\n      )\n    )\n  );\n}\n\n/**\n * Sequence an array through a Result-returning function.\n * Stops on first error.\n *\n * @example\n * ```typescript\n * const validate = (x: number): Result<number, string> =>\n *   x > 0 ? ok(x) : err(\"must be positive\");\n *\n * traverse([1, 2, 3], validate); // ok([1, 2, 3])\n * traverse([1, -2, 3], validate); // err(\"must be positive\")\n * ```\n */\nexport function traverse<T, U, E, C>(\n  items: T[],\n  fn: (item: T, index: number) => Result<U, E, C>\n): Result<U[], E, C> {\n  const results: U[] = [];\n  for (let i = 0; i < items.length; i++) {\n    const result = fn(items[i]!, i);\n    if (isErr(result)) {\n      return result as Result<U[], E, C>;\n    }\n    results.push(result.value);\n  }\n  return ok(results);\n}\n\n/**\n * Async version of traverse.\n *\n * @example\n * ```typescript\n * await traverseAsync(userIds, async (id) => fetchUser(id));\n * ```\n */\nexport async function traverseAsync<T, U, E, C>(\n  items: T[],\n  fn: (item: T, index: number) => AsyncResult<U, E, C>\n): AsyncResult<U[], E, C> {\n  const results: U[] = [];\n  for (let i = 0; i < items.length; i++) {\n    const result = await fn(items[i]!, i);\n    if (isErr(result)) {\n      return result as Result<U[], E, C>;\n    }\n    results.push(result.value);\n  }\n  return ok(results);\n}\n\n/**\n * Parallel traverse - executes all in parallel, fails fast.\n *\n * Returns immediately when any result fails, without waiting for\n * pending operations. Only returns all values if every result succeeds.\n *\n * @example\n * ```typescript\n * await traverseParallel(userIds, fetchUser);\n * ```\n */\nexport async function traverseParallel<T, U, E, C>(\n  items: T[],\n  fn: (item: T, index: number) => AsyncResult<U, E, C>\n): AsyncResult<U[], E | PromiseRejectedError, C | PromiseRejectionCause> {\n  return allAsync(items.map((item, index) => fn(item, index)));\n}\n\n// =============================================================================\n// Pipeable Result Functions (R namespace)\n// =============================================================================\n\n/**\n * Curried Result combinators for use in pipe().\n *\n * @example\n * ```typescript\n * import { pipe, R } from 'awaitly/functional';\n *\n * const result = pipe(\n *   fetchUser(id),\n *   R.flatMap(user => fetchPosts(user.id)),\n *   R.map(posts => posts.filter(p => p.published)),\n *   R.tap(posts => console.log(`Found ${posts.length} posts`)),\n *   R.match({\n *     ok: posts => `Found ${posts.length} posts`,\n *     err: error => `Failed: ${error}`\n *   })\n * );\n * ```\n */\nexport const R = {\n  /** Curried map for use in pipe() */\n  map:\n    <T, U, E, C>(fn: (value: T) => U) =>\n    (result: Result<T, E, C>): Result<U, E, C> =>\n      map(result, fn),\n\n  /** Curried flatMap for use in pipe() */\n  flatMap:\n    <T, U, E1, E2, C1, C2>(fn: (value: T) => Result<U, E2, C2>) =>\n    (result: Result<T, E1, C1>): Result<U, E1 | E2, C1 | C2> =>\n      flatMap(result, fn),\n\n  /** Curried bimap for use in pipe() */\n  bimap:\n    <T, U, E1, E2, C>(onOk: (value: T) => U, onErr: (error: E1) => E2) =>\n    (result: Result<T, E1, C>): Result<U, E2, C> =>\n      bimap(result, onOk, onErr),\n\n  /** Curried mapError for use in pipe() */\n  mapError:\n    <T, E1, E2, C>(fn: (error: E1) => E2) =>\n    (result: Result<T, E1, C>): Result<T, E2, C> =>\n      mapError(result, fn),\n\n  /** Curried tap for use in pipe() */\n  tap:\n    <T, E, C>(fn: (value: T) => void) =>\n    (result: Result<T, E, C>): Result<T, E, C> =>\n      tap(result, fn),\n\n  /** Curried tapError for use in pipe() */\n  tapError:\n    <T, E, C>(fn: (error: E) => void) =>\n    (result: Result<T, E, C>): Result<T, E, C> =>\n      tapError(result, fn),\n\n  /** Curried match for use in pipe() */\n  match:\n    <T, E, U, C>(patterns: { ok: (value: T) => U; err: (error: E, cause?: C) => U }) =>\n    (result: Result<T, E, C>): U =>\n      match(result, patterns),\n\n  /** Curried recover for use in pipe() */\n  recover:\n    <T, E, C>(fn: (error: E) => T) =>\n    (result: Result<T, E, C>): T =>\n      recover(result, fn),\n\n  /** Curried recoverWith for use in pipe() */\n  recoverWith:\n    <T, E1, E2, C1, C2>(fn: (error: E1) => Result<T, E2, C2>) =>\n    (result: Result<T, E1, C1>): Result<T, E2, C1 | C2> =>\n      recoverWith(result, fn),\n\n  /** Curried getOrElse for use in pipe() */\n  getOrElse:\n    <T, E, C>(defaultValue: T) =>\n    (result: Result<T, E, C>): T =>\n      getOrElse(result, defaultValue),\n\n  /** Curried getOrElseLazy for use in pipe() */\n  getOrElseLazy:\n    <T, E, C>(fn: () => T) =>\n    (result: Result<T, E, C>): T =>\n      getOrElseLazy(result, fn),\n};\n"],"mappings":"yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,OAAAE,EAAA,QAAAC,EAAA,aAAAC,EAAA,eAAAC,EAAA,oBAAAC,EAAA,QAAAC,EAAA,aAAAC,EAAA,UAAAC,EAAA,YAAAC,EAAA,YAAAC,EAAA,iBAAAC,EAAA,SAAAC,EAAA,cAAAC,EAAA,kBAAAC,EAAA,aAAAC,EAAA,QAAAC,EAAA,aAAAC,EAAA,aAAAC,EAAA,UAAAC,EAAA,SAAAC,EAAA,SAAAC,EAAA,YAAAC,EAAA,gBAAAC,EAAA,QAAAC,EAAA,aAAAC,EAAA,aAAAC,EAAA,kBAAAC,EAAA,aAAAC,EAAA,kBAAAC,EAAA,qBAAAC,IAAA,eAAAC,EAAAhC,GC0CO,IAAMiC,EAAmB,mBAqEzB,SAASC,EAAMC,EAAyB,CAC7C,MAAO,CAAE,GAAI,GAAe,MAAOA,CAAkB,CACvD,CAOO,SAASC,EAAoBC,EAAUC,EAAoC,CAChF,IAAMC,EAAQD,GAAS,MACvB,MAAO,CAAE,GAAI,GAAgB,MAAAD,EAAO,GAAIE,IAAU,OAAY,CAAE,MAAAA,CAAM,EAAI,CAAC,CAAG,CAChF,CAWO,IAAMC,EAAiBC,GAAmCA,EAAE,GAOtDC,EAAkBD,GAAuC,CAACA,EAAE,GCjElE,SAASE,EAAKC,KAAeC,EAAsC,CACxE,OAAOA,EAAI,OAAO,CAACC,EAAKC,IAAOA,EAAGD,CAAG,EAAGF,CAAC,CAC3C,CAyDO,SAASI,KAAQH,EAAsD,CAC5E,OAAQD,GAAeC,EAAI,OAAO,CAACC,EAAKC,IAAOA,EAAGD,CAAG,EAAGF,CAAC,CAC3D,CAyDO,SAASK,KAAWJ,EAAsD,CAC/E,OAAQD,GAAeC,EAAI,YAAY,CAACC,EAAKC,IAAOA,EAAGD,CAAG,EAAGF,CAAC,CAChE,CAUO,IAAMM,EAAeN,GAAYA,EAkBjC,SAASO,EAAgBC,EAAyBL,EAAsC,CAC7F,OAAIM,EAAKD,CAAM,EACNE,EAAGP,EAAGK,EAAO,KAAK,CAAC,EAErBA,CACT,CAeO,SAASG,EACdH,EACAL,EAC6B,CAC7B,OAAIM,EAAKD,CAAM,EACNL,EAAGK,EAAO,KAAK,EAEjBA,CACT,CAcO,SAASI,EACdJ,EACAK,EACAC,EACkB,CAClB,OAAIL,EAAKD,CAAM,EACNE,EAAGG,EAAKL,EAAO,KAAK,CAAC,EAEvBO,EAAID,EAAMN,EAAO,KAAK,EAAG,CAAE,MAAOA,EAAO,KAAM,CAAC,CACzD,CAYO,SAASQ,EACdR,EACAL,EACkB,CAClB,OAAIc,EAAMT,CAAM,EACPO,EAAIZ,EAAGK,EAAO,KAAK,EAAG,CAAE,MAAOA,EAAO,KAAM,CAAC,EAE/CA,CACT,CAWO,SAASU,EAAaV,EAAyBL,EAAyC,CAC7F,OAAIM,EAAKD,CAAM,GACbL,EAAGK,EAAO,KAAK,EAEVA,CACT,CAWO,SAASW,EAAkBX,EAAyBL,EAAyC,CAClG,OAAIc,EAAMT,CAAM,GACdL,EAAGK,EAAO,KAAK,EAEVA,CACT,CAcO,SAASY,EACdZ,EACAa,EACG,CACH,OAAIZ,EAAKD,CAAM,EACNa,EAAS,GAAGb,EAAO,KAAK,EAE1Ba,EAAS,IAAIb,EAAO,MAAOA,EAAO,KAAK,CAChD,CAcO,SAASc,EAAiBd,EAAyBL,EAAwB,CAChF,OAAIM,EAAKD,CAAM,EACNA,EAAO,MAETL,EAAGK,EAAO,KAAK,CACxB,CAYO,SAASe,EACdf,EACAL,EACwB,CACxB,OAAIM,EAAKD,CAAM,EACNA,EAEFL,EAAGK,EAAO,KAAK,CACxB,CAcO,SAASgB,EAAmBhB,EAAyBiB,EAAoB,CAC9E,OAAIhB,EAAKD,CAAM,EACNA,EAAO,MAETiB,CACT,CAcO,SAASC,EAAuBlB,EAAyBL,EAAgB,CAC9E,OAAIM,EAAKD,CAAM,EACNA,EAAO,MAETL,EAAG,CACZ,CAeA,eAAsBwB,EACpBnB,EACAL,EACsB,CACtB,IAAMyB,EAAW,MAAMpB,EACvB,OAAIC,EAAKmB,CAAQ,EACRlB,EAAG,MAAMP,EAAGyB,EAAS,KAAK,CAAC,EAE7BA,CACT,CAYA,eAAsBC,EACpBrB,EACAL,EACkC,CAClC,IAAMyB,EAAW,MAAMpB,EACvB,OAAIC,EAAKmB,CAAQ,EACRzB,EAAGyB,EAAS,KAAK,EAEnBA,CACT,CAaA,eAAsBE,EACpBtB,EACAL,EACsB,CACtB,IAAMyB,EAAW,MAAMpB,EACvB,OAAIC,EAAKmB,CAAQ,GACf,MAAMzB,EAAGyB,EAAS,KAAK,EAElBA,CACT,CAaA,eAAsBG,EACpBvB,EACAL,EACsB,CACtB,IAAMyB,EAAW,MAAMpB,EACvB,OAAIS,EAAMW,CAAQ,GAChB,MAAMzB,EAAGyB,EAAS,KAAK,EAElBA,CACT,CAeO,SAASI,EAAaC,EAA+C,CAC1E,IAAMC,EAAc,CAAC,EACrB,QAAW1B,KAAUyB,EAAS,CAC5B,GAAIhB,EAAMT,CAAM,EACd,OAAOA,EAET0B,EAAO,KAAK1B,EAAO,KAAK,CAC1B,CACA,OAAOE,EAAGwB,CAAM,CAClB,CAiBA,eAAsBC,EACpBF,EACuE,CACvE,GAAIA,EAAQ,SAAW,EACrB,OAAOvB,EAAG,CAAC,CAAC,EAGd,IAAMwB,EAAc,IAAI,MAAMD,EAAQ,MAAM,EACxCG,EAAe,EACfC,EAAO,GAEX,OAAO,IAAI,QAASC,GAAY,CAC9BL,EAAQ,QAAQ,CAACM,EAAeC,IAAU,CACxCD,EAAc,KACX/B,GAAW,CACN6B,IACApB,EAAMT,CAAM,GACd6B,EAAO,GACPC,EAAQ9B,CAA0E,IAElF0B,EAAOM,CAAK,EAAIhC,EAAO,MACvB4B,IACIA,IAAiBH,EAAQ,SAC3BI,EAAO,GACPC,EAAQ5B,EAAGwB,CAAM,CAAC,IAGxB,EACCO,GAAW,CACNJ,IACJA,EAAO,GACPC,EACEvB,EACE,CAAE,KAAM2B,EAAkB,MAAOD,CAAO,EACxC,CAAE,MAAO,CAAE,KAAM,oBAA8B,OAAAA,CAAO,CAA2B,CACnF,CACF,EACF,CACF,CACF,CAAC,CACH,CAAC,CACH,CAWO,SAASE,EAAoBV,EAAmD,CACrF,IAAMW,EAAgB,CAAC,EACjBC,EAAiB,CAAC,EACxB,QAAWrC,KAAUyB,EACfxB,EAAKD,CAAM,EACboC,EAAS,KAAKpC,EAAO,KAAK,EAE1BqC,EAAU,KAAKrC,EAAO,KAAK,EAG/B,MAAO,CAAE,GAAIoC,EAAU,IAAKC,CAAU,CACxC,CAiBA,eAAsBC,EACpBb,EACyD,CACzD,GAAIA,EAAQ,SAAW,EACrB,MAAO,CAAE,GAAI,CAAC,EAAG,IAAK,CAAC,CAAE,EAI3B,IAAMc,EAAqB,IAAI,MAAMd,EAAQ,MAAM,EAC/CG,EAAe,EAEnB,OAAO,IAAI,QAASE,GAAY,CAC9BL,EAAQ,QAAQ,CAACM,EAAeC,IAAU,CACxCD,EAAc,KACX/B,GAAW,CAOV,GANIC,EAAKD,CAAM,EACbuC,EAAQP,CAAK,EAAI,CAAE,KAAM,KAAM,MAAOhC,EAAO,KAAM,EAEnDuC,EAAQP,CAAK,EAAI,CAAE,KAAM,MAAO,MAAOhC,EAAO,KAAM,EAEtD4B,IACIA,IAAiBH,EAAQ,OAAQ,CACnC,IAAMW,EAAgB,CAAC,EACjBC,EAA0C,CAAC,EACjD,QAAWG,KAAKD,EACVC,EAAE,OAAS,KACbJ,EAAS,KAAKI,EAAE,KAAK,EAErBH,EAAU,KAAKG,EAAE,KAAK,EAG1BV,EAAQ,CAAE,GAAIM,EAAU,IAAKC,CAAU,CAAC,CAC1C,CACF,EACCJ,GAAW,CAGV,GAFAM,EAAQP,CAAK,EAAI,CAAE,KAAM,MAAO,MAAO,CAAE,KAAME,EAAkB,MAAOD,CAAO,CAA0B,EACzGL,IACIA,IAAiBH,EAAQ,OAAQ,CACnC,IAAMW,EAAgB,CAAC,EACjBC,EAA0C,CAAC,EACjD,QAAWG,KAAKD,EACVC,EAAE,OAAS,KACbJ,EAAS,KAAKI,EAAE,KAAK,EAErBH,EAAU,KAAKG,EAAE,KAAK,EAG1BV,EAAQ,CAAE,GAAIM,EAAU,IAAKC,CAAU,CAAC,CAC1C,CACF,CACF,CACF,CAAC,CACH,CAAC,CACH,CAWO,SAASI,EAAahB,EAA+C,CAC1E,IAAMiB,EAAc,CAAC,EACrB,QAAW1C,KAAUyB,EAAS,CAC5B,GAAIxB,EAAKD,CAAM,EACb,OAAOA,EAET0C,EAAO,KAAK1C,EAAO,KAAK,CAC1B,CACA,OAAOO,EAAImC,CAAM,CACnB,CAiBA,eAAsBC,EACpBlB,EACyE,CACzE,GAAIA,EAAQ,SAAW,EACrB,OAAOlB,EAAI,CAAC,CAAC,EAGf,IAAMmC,EAAmD,IAAI,MAAMjB,EAAQ,MAAM,EAC7EG,EAAe,EACfC,EAAO,GAEX,OAAO,IAAI,QAASC,GAAY,CAC9BL,EAAQ,QAAQ,CAACM,EAAeC,IAAU,CACxCD,EAAc,KACX/B,GAAW,CACN6B,IACA5B,EAAKD,CAAM,GACb6B,EAAO,GACPC,EAAQ9B,CAA4E,IAEpF0C,EAAOV,CAAK,EAAIhC,EAAO,MACvB4B,IACIA,IAAiBH,EAAQ,SAC3BI,EAAO,GACPC,EAAQvB,EAAImC,EAAO,OAAQE,GAAqCA,IAAM,MAAS,CAAC,CAAC,IAGvF,EACCX,GAAW,CACNJ,IACJa,EAAOV,CAAK,EAAI,CAAE,KAAME,EAAkB,MAAOD,CAAO,EACxDL,IACIA,IAAiBH,EAAQ,SAC3BI,EAAO,GACPC,EAAQvB,EAAImC,EAAO,OAAQE,GAAqCA,IAAM,MAAS,CAAC,CAAC,GAErF,CACF,CACF,CAAC,CACH,CAAC,CACH,CAgBA,eAAsBC,EACpBpB,EACqE,CACrE,OAAO,QAAQ,KACbA,EAAQ,IAAKqB,GACXA,EAAE,MACCb,GACC1B,EACE,CAAE,KAAM2B,EAAkB,MAAOD,CAAO,EACxC,CAAE,MAAO,CAAE,KAAM,oBAA8B,OAAAA,CAAO,CAA2B,CACnF,CACJ,CACF,CACF,CACF,CAeO,SAASc,EACdC,EACArD,EACmB,CACnB,IAAM8B,EAAe,CAAC,EACtB,QAASwB,EAAI,EAAGA,EAAID,EAAM,OAAQC,IAAK,CACrC,IAAMjD,EAASL,EAAGqD,EAAMC,CAAC,EAAIA,CAAC,EAC9B,GAAIxC,EAAMT,CAAM,EACd,OAAOA,EAETyB,EAAQ,KAAKzB,EAAO,KAAK,CAC3B,CACA,OAAOE,EAAGuB,CAAO,CACnB,CAUA,eAAsByB,EACpBF,EACArD,EACwB,CACxB,IAAM8B,EAAe,CAAC,EACtB,QAASwB,EAAI,EAAGA,EAAID,EAAM,OAAQC,IAAK,CACrC,IAAMjD,EAAS,MAAML,EAAGqD,EAAMC,CAAC,EAAIA,CAAC,EACpC,GAAIxC,EAAMT,CAAM,EACd,OAAOA,EAETyB,EAAQ,KAAKzB,EAAO,KAAK,CAC3B,CACA,OAAOE,EAAGuB,CAAO,CACnB,CAaA,eAAsB0B,EACpBH,EACArD,EACuE,CACvE,OAAOgC,EAASqB,EAAM,IAAI,CAACI,EAAMpB,IAAUrC,EAAGyD,EAAMpB,CAAK,CAAC,CAAC,CAC7D,CAyBO,IAAMqB,EAAI,CAEf,IACe1D,GACZK,GACCD,EAAIC,EAAQL,CAAE,EAGlB,QACyBA,GACtBK,GACCG,EAAQH,EAAQL,CAAE,EAGtB,MACE,CAAkBU,EAAuBC,IACxCN,GACCI,EAAMJ,EAAQK,EAAMC,CAAK,EAG7B,SACiBX,GACdK,GACCQ,EAASR,EAAQL,CAAE,EAGvB,IACYA,GACTK,GACCU,EAAIV,EAAQL,CAAE,EAGlB,SACYA,GACTK,GACCW,EAASX,EAAQL,CAAE,EAGvB,MACekB,GACZb,GACCY,EAAMZ,EAAQa,CAAQ,EAG1B,QACYlB,GACTK,GACCc,EAAQd,EAAQL,CAAE,EAGtB,YACsBA,GACnBK,GACCe,EAAYf,EAAQL,CAAE,EAG1B,UACYsB,GACTjB,GACCgB,EAAUhB,EAAQiB,CAAY,EAGlC,cACYtB,GACTK,GACCkB,EAAclB,EAAQL,CAAE,CAC9B","names":["functional_entry_exports","__export","R","all","allAsync","allSettled","allSettledAsync","any","anyAsync","bimap","compose","flatMap","flatMapAsync","flow","getOrElse","getOrElseLazy","identity","map","mapAsync","mapError","match","pipe","race","recover","recoverWith","tap","tapAsync","tapError","tapErrorAsync","traverse","traverseAsync","traverseParallel","__toCommonJS","PROMISE_REJECTED","ok","value","err","error","options","cause","isOk","r","isErr","pipe","a","fns","acc","fn","flow","compose","identity","map","result","isOk","ok","flatMap","bimap","onOk","onErr","err","mapError","isErr","tap","tapError","match","patterns","recover","recoverWith","getOrElse","defaultValue","getOrElseLazy","mapAsync","resolved","flatMapAsync","tapAsync","tapErrorAsync","all","results","values","allAsync","settledCount","done","resolve","resultPromise","index","reason","PROMISE_REJECTED","allSettled","okValues","errValues","allSettledAsync","settled","s","any","errors","anyAsync","e","race","p","traverse","items","i","traverseAsync","traverseParallel","item","R"]}

package/dist/functional.d.cts

@@ -1,444 +0,0 @@
-import { Result, AsyncResult, PromiseRejectedError, PromiseRejectionCause } from './result.cjs';
-import './errors.cjs';
-import './tagged-error.cjs';
-import './slugs.cjs';
-
-/**
- * awaitly/functional
- *
- * Effect-inspired functional utilities for Result types.
- * Provides pipe-based composition with automatic error short-circuiting.
- */
-
-/**
- * Pipe a value through a series of functions left-to-right.
- *
- * @example
- * ```typescript
- * const result = pipe(
- *   5,
- *   (x) => x * 2,
- *   (x) => x + 1
- * ); // 11
- * ```
- */
-declare function pipe<A>(a: A): A;
-declare function pipe<A, B>(a: A, ab: (a: A) => B): B;
-declare function pipe<A, B, C>(a: A, ab: (a: A) => B, bc: (b: B) => C): C;
-declare function pipe<A, B, C, D>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;
-declare function pipe<A, B, C, D, E>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): E;
-declare function pipe<A, B, C, D, E, F>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F): F;
-declare function pipe<A, B, C, D, E, F, G>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G): G;
-declare function pipe<A, B, C, D, E, F, G, H>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H): H;
-declare function pipe<A, B, C, D, E, F, G, H, I>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I): I;
-/**
- * Compose functions left-to-right (returns a function).
- *
- * @example
- * ```typescript
- * const double = (x: number) => x * 2;
- * const addOne = (x: number) => x + 1;
- * const transform = flow(double, addOne);
- * transform(5); // 11
- * ```
- */
-declare function flow<A, B>(ab: (a: A) => B): (a: A) => B;
-declare function flow<A, B, C>(ab: (a: A) => B, bc: (b: B) => C): (a: A) => C;
-declare function flow<A, B, C, D>(ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): (a: A) => D;
-declare function flow<A, B, C, D, E>(ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): (a: A) => E;
-declare function flow<A, B, C, D, E, F>(ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F): (a: A) => F;
-declare function flow<A, B, C, D, E, F, G>(ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G): (a: A) => G;
-declare function flow<A, B, C, D, E, F, G, H>(ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H): (a: A) => H;
-declare function flow<A, B, C, D, E, F, G, H, I>(ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I): (a: A) => I;
-/**
- * Compose functions right-to-left.
- *
- * @example
- * ```typescript
- * const double = (x: number) => x * 2;
- * const addOne = (x: number) => x + 1;
- * const transform = compose(addOne, double);
- * transform(5); // 11 (double first, then addOne)
- * ```
- */
-declare function compose<A, B>(ab: (a: A) => B): (a: A) => B;
-declare function compose<A, B, C>(bc: (b: B) => C, ab: (a: A) => B): (a: A) => C;
-declare function compose<A, B, C, D>(cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => D;
-declare function compose<A, B, C, D, E>(de: (d: D) => E, cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => E;
-declare function compose<A, B, C, D, E, F>(ef: (e: E) => F, de: (d: D) => E, cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => F;
-declare function compose<A, B, C, D, E, F, G>(fg: (f: F) => G, ef: (e: E) => F, de: (d: D) => E, cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => G;
-declare function compose<A, B, C, D, E, F, G, H>(gh: (g: G) => H, fg: (f: F) => G, ef: (e: E) => F, de: (d: D) => E, cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => H;
-declare function compose<A, B, C, D, E, F, G, H, I>(hi: (h: H) => I, gh: (g: G) => H, fg: (f: F) => G, ef: (e: E) => F, de: (d: D) => E, cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => I;
-/**
- * Identity function - returns its argument unchanged.
- *
- * @example
- * ```typescript
- * identity(42); // 42
- * ```
- */
-declare const identity: <A>(a: A) => A;
-/**
- * Transform the success value of a Result.
- *
- * @example
- * ```typescript
- * const result = Awaitly.ok(5);
- * map(result, (x) => x * 2); // Awaitly.ok(10)
- *
- * const error = Awaitly.err("not found");
- * map(error, (x) => x * 2); // Awaitly.err("not found")
- * ```
- */
-declare function map<T, U, E, C>(result: Result<T, E, C>, fn: (value: T) => U): Result<U, E, C>;
-/**
- * Transform and flatten (short-circuits on error).
- *
- * @example
- * ```typescript
- * const divide = (a: number, b: number): Result<number, string> =>
- *   b === 0 ? Awaitly.err("division by zero") : Awaitly.ok(a / b);
- *
- * const result = Awaitly.ok(10);
- * flatMap(result, (x) => divide(x, 2)); // Awaitly.ok(5)
- * flatMap(result, (x) => divide(x, 0)); // Awaitly.err("division by zero")
- * ```
- */
-declare function flatMap<T, U, E1, E2, C1, C2>(result: Result<T, E1, C1>, fn: (value: T) => Result<U, E2, C2>): Result<U, E1 | E2, C1 | C2>;
-/**
- * Transform both success and error values.
- *
- * @example
- * ```typescript
- * const result = Awaitly.ok(5);
- * bimap(result, (x) => x * 2, (e) => `Error: ${e}`); // Awaitly.ok(10)
- *
- * const error = Awaitly.err("not found");
- * bimap(error, (x) => x * 2, (e) => `Error: ${e}`); // Awaitly.err("Error: not found")
- * ```
- */
-declare function bimap<T, U, E1, E2, C>(result: Result<T, E1, C>, onOk: (value: T) => U, onErr: (error: E1) => E2): Result<U, E2, C>;
-/**
- * Transform the error value.
- *
- * @example
- * ```typescript
- * const error = Awaitly.err("not found");
- * mapError(error, (e) => ({ type: "ERROR", message: e }));
- * // Awaitly.err({ type: "ERROR", message: "not found" })
- * ```
- */
-declare function mapError<T, E1, E2, C>(result: Result<T, E1, C>, fn: (error: E1) => E2): Result<T, E2, C>;
-/**
- * Side effect on success (returns original result).
- *
- * @example
- * ```typescript
- * const result = Awaitly.ok(5);
- * tap(result, (x) => console.log(`Value: ${x}`)); // logs "Value: 5", returns Awaitly.ok(5)
- * ```
- */
-declare function tap<T, E, C>(result: Result<T, E, C>, fn: (value: T) => void): Result<T, E, C>;
-/**
- * Side effect on error (returns original result).
- *
- * @example
- * ```typescript
- * const error = Awaitly.err("not found");
- * tapError(error, (e) => console.log(`Error: ${e}`)); // logs "Error: not found", returns err
- * ```
- */
-declare function tapError<T, E, C>(result: Result<T, E, C>, fn: (error: E) => void): Result<T, E, C>;
-/**
- * Pattern match on Result.
- *
- * @example
- * ```typescript
- * const result = Awaitly.ok(5);
- * match(result, {
- *   ok: (x) => `Success: ${x}`,
- *   err: (e) => `Error: ${e}`
- * }); // "Success: 5"
- * ```
- */
-declare function match<T, E, U, C>(result: Result<T, E, C>, patterns: {
-    ok: (value: T) => U;
-    err: (error: E, cause?: C) => U;
-}): U;
-/**
- * Recover from error by providing fallback value.
- *
- * @example
- * ```typescript
- * const error = Awaitly.err("not found");
- * recover(error, () => 0); // 0
- *
- * const success = Awaitly.ok(5);
- * recover(success, () => 0); // 5
- * ```
- */
-declare function recover<T, E, C>(result: Result<T, E, C>, fn: (error: E) => T): T;
-/**
- * Recover from error with another Result.
- *
- * @example
- * ```typescript
- * const error = Awaitly.err("not found");
- * recoverWith(error, (e) => ok(0)); // ok(0)
- * recoverWith(error, (e) => err("still failed")); // err("still failed")
- * ```
- */
-declare function recoverWith<T, E1, E2, C1, C2>(result: Result<T, E1, C1>, fn: (error: E1) => Result<T, E2, C2>): Result<T, E2, C1 | C2>;
-/**
- * Get the value or a default.
- *
- * @example
- * ```typescript
- * const error = Awaitly.err("not found");
- * getOrElse(error, 0); // 0
- *
- * const success = Awaitly.ok(5);
- * getOrElse(success, 0); // 5
- * ```
- */
-declare function getOrElse<T, E, C>(result: Result<T, E, C>, defaultValue: T): T;
-/**
- * Get the value or compute a default lazily.
- *
- * @example
- * ```typescript
- * const error = Awaitly.err("not found");
- * getOrElseLazy(error, () => expensiveComputation()); // calls expensiveComputation()
- *
- * const success = Awaitly.ok(5);
- * getOrElseLazy(success, () => expensiveComputation()); // 5, doesn't call expensiveComputation
- * ```
- */
-declare function getOrElseLazy<T, E, C>(result: Result<T, E, C>, fn: () => T): T;
-/**
- * Transform success value asynchronously.
- *
- * @example
- * ```typescript
- * const result = Awaitly.ok(5);
- * await mapAsync(result, async (x) => x * 2); // ok(10)
- * ```
- */
-declare function mapAsync<T, U, E, C>(result: Result<T, E, C> | AsyncResult<T, E, C>, fn: (value: T) => Promise<U>): AsyncResult<U, E, C>;
-/**
- * Async flatMap.
- *
- * @example
- * ```typescript
- * const fetchUser = async (id: string): AsyncResult<User, "NOT_FOUND"> => { ... };
- * const result = Awaitly.ok("user-123");
- * await flatMapAsync(result, fetchUser); // AsyncResult<User, "NOT_FOUND">
- * ```
- */
-declare function flatMapAsync<T, U, E1, E2, C1, C2>(result: Result<T, E1, C1> | AsyncResult<T, E1, C1>, fn: (value: T) => AsyncResult<U, E2, C2>): AsyncResult<U, E1 | E2, C1 | C2>;
-/**
- * Async tap - side effect on success.
- *
- * @example
- * ```typescript
- * const result = Awaitly.ok(5);
- * await tapAsync(result, async (x) => {
- *   await logToServer(x);
- * }); // ok(5)
- * ```
- */
-declare function tapAsync<T, E, C>(result: Result<T, E, C> | AsyncResult<T, E, C>, fn: (value: T) => Promise<void>): AsyncResult<T, E, C>;
-/**
- * Async tapError - side effect on error.
- *
- * @example
- * ```typescript
- * const error = Awaitly.err("not found");
- * await tapErrorAsync(error, async (e) => {
- *   await logErrorToServer(e);
- * }); // err("not found")
- * ```
- */
-declare function tapErrorAsync<T, E, C>(result: Result<T, E, C> | AsyncResult<T, E, C>, fn: (error: E) => Promise<void>): AsyncResult<T, E, C>;
-/**
- * Combine array of Results - fails fast on first error.
- *
- * @example
- * ```typescript
- * all([ok(1), ok(2), ok(3)]); // ok([1, 2, 3])
- * all([ok(1), err("fail"), ok(3)]); // err("fail")
- * ```
- */
-declare function all<T, E, C>(results: Result<T, E, C>[]): Result<T[], E, C>;
-/**
- * Combine array of AsyncResults - parallel execution, fails fast.
- *
- * Returns immediately when any result fails, without waiting for
- * pending promises. Only returns all values if every result succeeds.
- *
- * @example
- * ```typescript
- * await allAsync([
- *   fetchUser("1"),
- *   fetchUser("2"),
- *   fetchUser("3")
- * ]); // AsyncResult<User[], "NOT_FOUND">
- * ```
- */
-declare function allAsync<T, E, C>(results: AsyncResult<T, E, C>[]): AsyncResult<T[], E | PromiseRejectedError, C | PromiseRejectionCause>;
-/**
- * Collect all results, separating successes and failures.
- *
- * @example
- * ```typescript
- * allSettled([ok(1), err("a"), ok(2), err("b")]);
- * // { ok: [1, 2], err: ["a", "b"] }
- * ```
- */
-declare function allSettled<T, E, C>(results: Result<T, E, C>[]): {
-    ok: T[];
-    err: E[];
-};
-/**
- * Async version of allSettled.
- *
- * Handles rejected promises by treating them as errors with
- * type PROMISE_REJECTED.
- *
- * @example
- * ```typescript
- * await allSettledAsync([
- *   fetchUser("1"),
- *   fetchUser("2"),
- *   fetchUser("3")
- * ]); // { ok: [...users], err: [...errors] }
- * ```
- */
-declare function allSettledAsync<T, E, C>(results: AsyncResult<T, E, C>[]): Promise<{
-    ok: T[];
-    err: (E | PromiseRejectedError)[];
-}>;
-/**
- * Return first success, or all errors if all fail.
- *
- * @example
- * ```typescript
- * any([err("a"), ok(1), err("b")]); // ok(1)
- * any([err("a"), err("b"), err("c")]); // err(["a", "b", "c"])
- * ```
- */
-declare function any<T, E, C>(results: Result<T, E, C>[]): Result<T, E[], C>;
-/**
- * Async version of any - returns first success immediately.
- *
- * Returns as soon as any result succeeds, without waiting for
- * pending promises. Only returns all errors if every result fails.
- *
- * @example
- * ```typescript
- * await anyAsync([
- *   fetchFromCache(key),
- *   fetchFromDb(key),
- *   fetchFromApi(key)
- * ]); // First successful result
- * ```
- */
-declare function anyAsync<T, E, C>(results: AsyncResult<T, E, C>[]): AsyncResult<T, (E | PromiseRejectedError)[], C | PromiseRejectionCause>;
-/**
- * Race async results - first to complete wins.
- *
- * Handles rejected promises by converting them to err() results
- * with type PROMISE_REJECTED.
- *
- * @example
- * ```typescript
- * await race([
- *   fetchFromPrimaryServer(id),
- *   fetchFromBackupServer(id)
- * ]); // Result from whichever server responds first
- * ```
- */
-declare function race<T, E, C>(results: AsyncResult<T, E, C>[]): AsyncResult<T, E | PromiseRejectedError, C | PromiseRejectionCause>;
-/**
- * Sequence an array through a Result-returning function.
- * Stops on first error.
- *
- * @example
- * ```typescript
- * const validate = (x: number): Result<number, string> =>
- *   x > 0 ? ok(x) : err("must be positive");
- *
- * traverse([1, 2, 3], validate); // ok([1, 2, 3])
- * traverse([1, -2, 3], validate); // err("must be positive")
- * ```
- */
-declare function traverse<T, U, E, C>(items: T[], fn: (item: T, index: number) => Result<U, E, C>): Result<U[], E, C>;
-/**
- * Async version of traverse.
- *
- * @example
- * ```typescript
- * await traverseAsync(userIds, async (id) => fetchUser(id));
- * ```
- */
-declare function traverseAsync<T, U, E, C>(items: T[], fn: (item: T, index: number) => AsyncResult<U, E, C>): AsyncResult<U[], E, C>;
-/**
- * Parallel traverse - executes all in parallel, fails fast.
- *
- * Returns immediately when any result fails, without waiting for
- * pending operations. Only returns all values if every result succeeds.
- *
- * @example
- * ```typescript
- * await traverseParallel(userIds, fetchUser);
- * ```
- */
-declare function traverseParallel<T, U, E, C>(items: T[], fn: (item: T, index: number) => AsyncResult<U, E, C>): AsyncResult<U[], E | PromiseRejectedError, C | PromiseRejectionCause>;
-/**
- * Curried Result combinators for use in pipe().
- *
- * @example
- * ```typescript
- * import { pipe, R } from 'awaitly/functional';
- *
- * const result = pipe(
- *   fetchUser(id),
- *   R.flatMap(user => fetchPosts(user.id)),
- *   R.map(posts => posts.filter(p => p.published)),
- *   R.tap(posts => console.log(`Found ${posts.length} posts`)),
- *   R.match({
- *     ok: posts => `Found ${posts.length} posts`,
- *     err: error => `Failed: ${error}`
- *   })
- * );
- * ```
- */
-declare const R: {
-    /** Curried map for use in pipe() */
-    map: <T, U, E, C>(fn: (value: T) => U) => (result: Result<T, E, C>) => Result<U, E, C>;
-    /** Curried flatMap for use in pipe() */
-    flatMap: <T, U, E1, E2, C1, C2>(fn: (value: T) => Result<U, E2, C2>) => (result: Result<T, E1, C1>) => Result<U, E1 | E2, C1 | C2>;
-    /** Curried bimap for use in pipe() */
-    bimap: <T, U, E1, E2, C>(onOk: (value: T) => U, onErr: (error: E1) => E2) => (result: Result<T, E1, C>) => Result<U, E2, C>;
-    /** Curried mapError for use in pipe() */
-    mapError: <T, E1, E2, C>(fn: (error: E1) => E2) => (result: Result<T, E1, C>) => Result<T, E2, C>;
-    /** Curried tap for use in pipe() */
-    tap: <T, E, C>(fn: (value: T) => void) => (result: Result<T, E, C>) => Result<T, E, C>;
-    /** Curried tapError for use in pipe() */
-    tapError: <T, E, C>(fn: (error: E) => void) => (result: Result<T, E, C>) => Result<T, E, C>;
-    /** Curried match for use in pipe() */
-    match: <T, E, U, C>(patterns: {
-        ok: (value: T) => U;
-        err: (error: E, cause?: C) => U;
-    }) => (result: Result<T, E, C>) => U;
-    /** Curried recover for use in pipe() */
-    recover: <T, E, C>(fn: (error: E) => T) => (result: Result<T, E, C>) => T;
-    /** Curried recoverWith for use in pipe() */
-    recoverWith: <T, E1, E2, C1, C2>(fn: (error: E1) => Result<T, E2, C2>) => (result: Result<T, E1, C1>) => Result<T, E2, C1 | C2>;
-    /** Curried getOrElse for use in pipe() */
-    getOrElse: <T, E, C>(defaultValue: T) => (result: Result<T, E, C>) => T;
-    /** Curried getOrElseLazy for use in pipe() */
-    getOrElseLazy: <T, E, C>(fn: () => T) => (result: Result<T, E, C>) => T;
-};
-
-export { R, all, allAsync, allSettled, allSettledAsync, any, anyAsync, bimap, compose, flatMap, flatMapAsync, flow, getOrElse, getOrElseLazy, identity, map, mapAsync, mapError, match, pipe, race, recover, recoverWith, tap, tapAsync, tapError, tapErrorAsync, traverse, traverseAsync, traverseParallel };