resultar 3.5.1 → 3.6.0

package/dist/index.d.ts

@@ -7,21 +7,21 @@ interface ErrorConfig {
 type PipeFn<Input, Output> = (input: Input) => Output;
 declare abstract class Pipeable {
   /**
-  * Passes this value through one or more transformation functions.
-  *
-  * Use `pipe` to package reusable Result or ResultAsync combinators without hiding the underlying
-  * type.
-  */
+   * Passes this value through one or more transformation functions.
+   *
+   * Use `pipe` to package reusable Result or ResultAsync combinators without hiding the underlying
+   * type.
+   */
   pipe<A>(ab: PipeFn<this, A>): A;
   pipe<A, B>(ab: PipeFn<this, A>, bc: PipeFn<A, B>): B;
   pipe<A, B, C>(ab: PipeFn<this, A>, bc: PipeFn<A, B>, cd: PipeFn<B, C>): C;
 }
 //#endregion
 //#region src/utils.d.ts
-type ExtractOkTypes<T extends readonly Result<unknown, unknown>[]> = { [idx in keyof T]: T[idx] extends Result<infer U, unknown> ? U : never };
-type ExtractOkAsyncTypes<T extends readonly ResultAsync<unknown, unknown>[]> = { [idx in keyof T]: T[idx] extends ResultAsync<infer U, unknown> ? U : never };
-type ExtractErrTypes<T extends readonly Result<unknown, unknown>[]> = { [idx in keyof T]: T[idx] extends Result<unknown, infer E> ? E : never };
-type ExtractErrAsyncTypes<T extends readonly ResultAsync<unknown, unknown>[]> = { [idx in keyof T]: T[idx] extends ResultAsync<unknown, infer E> ? E : never };
+type ExtractOkTypes<T extends readonly Result<unknown, unknown>[]> = { [idx in keyof T]: T[idx] extends Result<infer U, unknown> ? U : never; };
+type ExtractOkAsyncTypes<T extends readonly ResultAsync<unknown, unknown>[]> = { [idx in keyof T]: T[idx] extends ResultAsync<infer U, unknown> ? U : never; };
+type ExtractErrTypes<T extends readonly Result<unknown, unknown>[]> = { [idx in keyof T]: T[idx] extends Result<unknown, infer E> ? E : never; };
+type ExtractErrAsyncTypes<T extends readonly ResultAsync<unknown, unknown>[]> = { [idx in keyof T]: T[idx] extends ResultAsync<unknown, infer E> ? E : never; };
 type InferOkTypes<R> = R extends Result<infer T, unknown> ? T : never;
 type InferErrTypes<R> = R extends Result<unknown, infer E> ? E : never;
 type InferAsyncOkTypes<R> = R extends ResultAsync<infer T, unknown> ? T : never;
@@ -61,21 +61,21 @@ type ExcludeReasonTag<E, ErrorTag extends string, ReasonTag extends string> = Ex
 }> | ErrorWithRemainingReason<ErrorForTag$1<E, ErrorTag>, Exclude<ReasonsOf<E, ErrorTag>, {
   readonly _tag: ReasonTag;
 }>>;
-type CatchTagHandlerResult<Handlers> = { readonly [Key in keyof Handlers]: Handlers[Key] extends ((...args: infer _Args) => infer R) ? R : never }[keyof Handlers];
-type CatchReasonHandlerResult<Handlers> = { readonly [Key in keyof Handlers]: Handlers[Key] extends ((...args: infer _Args) => infer R) ? R : never }[keyof Handlers];
-type MatchTagHandlerResult<Handlers> = { readonly [Key in keyof Handlers]: Handlers[Key] extends ((...args: infer _Args) => infer R) ? R : never }[keyof Handlers];
-type CatchTagHandlers<E, Handlers, R> = { readonly [Tag in keyof Handlers]: Tag extends TagsOf<E> ? (error: ErrorForTag$1<E, Tag & string>) => R : never };
+type CatchTagHandlerResult<Handlers> = { readonly [Key in keyof Handlers]: Handlers[Key] extends ((...args: infer _Args) => infer R) ? R : never; }[keyof Handlers];
+type CatchReasonHandlerResult<Handlers> = { readonly [Key in keyof Handlers]: Handlers[Key] extends ((...args: infer _Args) => infer R) ? R : never; }[keyof Handlers];
+type MatchTagHandlerResult<Handlers> = { readonly [Key in keyof Handlers]: Handlers[Key] extends ((...args: infer _Args) => infer R) ? R : never; }[keyof Handlers];
+type CatchTagHandlers<E, Handlers, R> = { readonly [Tag in keyof Handlers]: Tag extends TagsOf<E> ? (error: ErrorForTag$1<E, Tag & string>) => R : never; };
 type ResultCatchTagHandlers<E, Handlers> = CatchTagHandlers<E, Handlers, Result<unknown, unknown>>;
 type ResultAsyncCatchTagHandlers<E, Handlers> = CatchTagHandlers<E, Handlers, Result<unknown, unknown> | ResultAsync<unknown, unknown>>;
-type CatchReasonHandlers<E, ErrorTag extends string, Handlers, R> = { readonly [ReasonTag in keyof Handlers]: ReasonTag extends ReasonTagsOf<E, ErrorTag> ? (reason: ReasonForTag<E, ErrorTag, ReasonTag & string>, error: ErrorForTag$1<E, ErrorTag>) => R : never };
+type CatchReasonHandlers<E, ErrorTag extends string, Handlers, R> = { readonly [ReasonTag in keyof Handlers]: ReasonTag extends ReasonTagsOf<E, ErrorTag> ? (reason: ReasonForTag<E, ErrorTag, ReasonTag & string>, error: ErrorForTag$1<E, ErrorTag>) => R : never; };
 type ResultCatchReasonHandlers<E, ErrorTag extends string, Handlers> = CatchReasonHandlers<E, ErrorTag, Handlers, Result<unknown, unknown>>;
 type ResultAsyncCatchReasonHandlers<E, ErrorTag extends string, Handlers> = CatchReasonHandlers<E, ErrorTag, Handlers, Result<unknown, unknown> | ResultAsync<unknown, unknown>>;
-type MatchTagHandlers<E, Handlers> = { readonly [Tag in ErrorTagsOf<E>]: (error: ErrorForTag$1<E, Tag>) => unknown } & ([UntaggedError$1<E>] extends [never] ? {
+type MatchTagHandlers<E, Handlers> = { readonly [Tag in ErrorTagsOf<E>]: (error: ErrorForTag$1<E, Tag>) => unknown; } & ([UntaggedError$1<E>] extends [never] ? {
   readonly Error?: (error: Error) => unknown;
 } : {
   readonly Error: (error: UntaggedError$1<E>) => unknown;
-}) & { readonly [Tag in keyof Handlers]: Tag extends ErrorTagsOf<E> | "Error" ? Handlers[Tag] : never };
-type PartialMatchTagHandlers<E, Handlers> = { readonly [Tag in keyof Handlers]: Tag extends ErrorTagsOf<E> ? (error: ErrorForTag$1<E, Tag & string>) => unknown : Tag extends "Error" ? (error: Extract<E, Error>) => unknown : never };
+}) & { readonly [Tag in keyof Handlers]: Tag extends ErrorTagsOf<E> | "Error" ? Handlers[Tag] : never; };
+type PartialMatchTagHandlers<E, Handlers> = { readonly [Tag in keyof Handlers]: Tag extends ErrorTagsOf<E> ? (error: ErrorForTag$1<E, Tag & string>) => unknown : Tag extends "Error" ? (error: Extract<E, Error>) => unknown : never; };
 //#endregion
 //#region src/result.d.ts
 type ResultFinalizer<T, E> = (value: T | undefined, error: E | undefined) => void;
@@ -83,8 +83,8 @@ type MatchOkHandler<T, A> = (value: T) => A;
 type MatchErrorHandler<E, B> = (error: E) => B;
 type ResultCandidate = () => Result<unknown, unknown>;
 type ResultRecord = Readonly<Record<string, Result<unknown, unknown>>>;
-type CombineResultsRecord<T extends ResultRecord> = Result<{ readonly [Key in keyof T]: InferOkTypes<T[Key]> }, InferErrTypes<T[keyof T]>>;
-type CombineResultsRecordWithAllErrors<T extends ResultRecord> = Result<{ readonly [Key in keyof T]: InferOkTypes<T[Key]> }, InferErrTypes<T[keyof T]>[]>;
+type CombineResultsRecord<T extends ResultRecord> = Result<{ readonly [Key in keyof T]: InferOkTypes<T[Key]>; }, InferErrTypes<T[keyof T]>>;
+type CombineResultsRecordWithAllErrors<T extends ResultRecord> = Result<{ readonly [Key in keyof T]: InferOkTypes<T[Key]>; }, InferErrTypes<T[keyof T]>[]>;
 type CombineResultsIterable<R extends Result<unknown, unknown>> = Result<readonly InferOkTypes<R>[], InferErrTypes<R>>;
 type CombineResultsIterableWithAllErrors<R extends Result<unknown, unknown>> = Result<readonly InferOkTypes<R>[], InferErrTypes<R>[]>;
 type ResultLoopCollected<R extends Result<unknown, unknown>> = Result<readonly InferOkTypes<R>[], InferErrTypes<R>>;
@@ -148,298 +148,309 @@ interface ResultIfOptions<OnTrue extends Result<unknown, unknown>, OnFalse exten
   readonly onTrue: () => OnTrue;
 }
 /**
-* A Result interface that is used to define the methods that are available on a
-* `Result` object.
-*
-* The immutability of the `Result` object is maintained by the interface.
-*/
+ * A Result interface that is used to define the methods that are available on a
+ * `Result` object.
+ *
+ * The immutability of the `Result` object is maintained by the interface.
+ */
 interface Resultable<T, E> {
   get value(): T;
   get error(): E;
   /**
-  * Used to check if a `Result` is an `OK`
-  *
-  * @returns `true` if the result is an `OK` variant of Result
-  */
+   * Used to check if a `Result` is an `OK`
+   *
+   * @returns `true` if the result is an `OK` variant of Result
+   */
   isOk: () => boolean;
   /**
-  * Used to check if a `Result` is an `Err`
-  *
-  * @returns `true` if the result is an `Err` variant of Result
-  */
+   * Used to check if a `Result` is an `Err`
+   *
+   * @returns `true` if the result is an `Err` variant of Result
+   */
   isErr: () => boolean;
   /**
-  * Unwrap the `Ok` value, or return the default if there is an `Err`
-  *
-  * @param v the default value to return if there is an `Err`
-  */
+   * Unwrap the `Ok` value, or return the default if there is an `Err`
+   *
+   * @param v the default value to return if there is an `Err`
+   */
   unwrapOr: <A>(defaultValue: A) => T | A;
   /**
-  * **This method is unsafe, and should only be used in a test environments**
-  *
-  * Takes a `Result<T, E>` and returns a `T` when the result is an `Ok`, otherwise it throws a custom object.
-  *
-  * @param config
-  */
+   * **This method is unsafe, and should only be used in a test environments**
+   *
+   * Takes a `Result<T, E>` and returns a `T` when the result is an `Ok`, otherwise it throws a custom object.
+   *
+   * @param config
+   */
   _unsafeUnwrap: (config?: ErrorConfig) => T;
   /**
-  * **This method is unsafe, and should only be used in a test environments**
-  *
-  * takes a `Result<T, E>` and returns a `E` when the result is an `Err`,
-  * otherwise it throws a custom object.
-  *
-  * @param config
-  */
+   * **This method is unsafe, and should only be used in a test environments**
+   *
+   * takes a `Result<T, E>` and returns a `E` when the result is an `Err`,
+   * otherwise it throws a custom object.
+   *
+   * @param config
+   */
   _unsafeUnwrapErr: (config?: ErrorConfig) => E;
 }
+/** Operations shared by the Ok and Err variants of `Result<T, E>`. */
 interface ResultOperations<T, E> {
   /**
-  * Narrows this result to the Ok variant.
-  */
+   * Narrows this result to the Ok variant.
+   */
   isOk: () => this is OkResult<T, E>;
   /**
-  * Narrows this result to the Err variant.
-  */
+   * Narrows this result to the Err variant.
+   */
   isErr: () => this is ErrResult<T, E>;
   /**
-  * Returns the Ok value, or `defaultValue` when this result is Err.
-  */
+   * Returns the Ok value, or `defaultValue` when this result is Err.
+   */
   unwrapOr: <A>(defaultValue: A) => T | A;
   /**
-  * Returns the Ok value or throws a Resultar diagnostic error when this result is Err.
-  *
-  * Prefer `match`, `unwrapOr`, or explicit error handling in application code. This helper is
-  * intended for tests and trusted final boundaries.
-  */
+   * Returns the Ok value or throws a Resultar diagnostic error when this result is Err.
+   *
+   * Prefer `match`, `unwrapOr`, or explicit error handling in application code. This helper is
+   * intended for tests and trusted final boundaries.
+   */
   _unsafeUnwrap: (config?: ErrorConfig) => T;
   /**
-  * Returns the Err value or throws a Resultar diagnostic error when this result is Ok.
-  *
-  * Prefer `match`, `isErr`, or explicit error handling in application code. This helper is intended
-  * for tests.
-  */
+   * Returns the Err value or throws a Resultar diagnostic error when this result is Ok.
+   *
+   * Prefer `match`, `isErr`, or explicit error handling in application code. This helper is intended
+   * for tests.
+   */
   _unsafeUnwrapErr: (config?: ErrorConfig) => E;
   /**
-  * Maps the Ok value while preserving the error channel.
-  */
+   * Maps the Ok value while preserving the error channel.
+   */
   map: <X>(f: (t: T) => X) => Result<X, E>;
   /**
-  * Replaces the Ok value with a constant while preserving the error channel.
-  */
+   * Replaces the Ok value with a constant while preserving the error channel.
+   */
   as: <X>(value: X) => Result<X, E>;
   /**
-  * Keeps the Ok value only when the predicate passes; otherwise returns an Err from `onFalse`.
-  */
+   * Keeps the Ok value only when the predicate passes; otherwise returns an Err from `onFalse`.
+   */
   filterOrElse: {
     <U extends T, F>(predicate: (value: T) => value is U, onFalse: (value: T) => F): Result<U, E | F>;
     <F>(predicate: (value: T) => boolean, onFalse: (value: T) => F): Result<T, E | F>;
   };
   /**
-  * Maps the Err value while preserving the Ok value.
-  */
+   * Maps the Err value while preserving the Ok value.
+   */
   mapErr: <X>(fn: (t: E) => X) => Result<T, X>;
   /**
-  * Chains another fallible operation from the Ok value.
-  *
-  * Use this instead of `map` when the callback returns another `Result`.
-  */
+   * Chains another fallible operation from the Ok value.
+   *
+   * Use this instead of `map` when the callback returns another `Result`.
+   */
   andThen: <X, Y>(f: (t: T) => Result<X, Y>) => Result<X, E | Y>;
   /**
-  * Branches from the Ok value into one of two fallible Result branches.
-  */
+   * Branches from the Ok value into one of two fallible Result branches.
+   */
   if: (fCondition: (t: T) => boolean) => {
     true: <X1, Y1>(fTrue: (t: T) => Result<X1, Y1>) => {
       false: <X2, Y2>(fFalse: (t: T) => Result<X2, Y2>) => Result<X1 | X2, Y1 | Y2 | E>;
     };
   };
   /**
-  * Recovers from Err with another Result.
-  */
+   * Recovers from Err with another Result.
+   */
   orElse: <R extends Result<unknown, unknown>>(f: (e: E) => R) => Result<InferOkTypes<R> | T, InferErrTypes<R>>;
   /**
-  * Recovers from a specific tagged error by `_tag`.
-  */
+   * Recovers from a specific tagged error by `_tag`.
+   */
   catchTag: <const Tag extends TagsOf<E>, R extends Result<unknown, unknown>>(tag: Tag, f: (error: ErrorForTag$1<E, Tag>) => R) => Result<T | InferOkTypes<R>, ExcludeTag<E, Tag> | InferErrTypes<R>>;
   /**
-  * Recovers from multiple tagged errors by `_tag`.
-  */
+   * Recovers from multiple tagged errors by `_tag`.
+   */
   catchTags: <const Handlers extends object>(handlers: Handlers & ResultCatchTagHandlers<E, Handlers>) => Result<T | InferOkTypes<CatchTagHandlerResult<Handlers>>, ExcludeTag<E, keyof Handlers & string> | InferErrTypes<CatchTagHandlerResult<Handlers>>>;
   /**
-  * Recovers from a nested tagged `reason` on a specific tagged error.
-  */
+   * Recovers from a nested tagged `reason` on a specific tagged error.
+   */
   catchReason: <const ErrorTag extends TagsWithReasonOf<E>, const ReasonTag extends ReasonTagsOf<E, ErrorTag>, R extends Result<unknown, unknown>>(errorTag: ErrorTag, reasonTag: ReasonTag, f: (reason: ReasonForTag<E, ErrorTag, ReasonTag>, error: ErrorForTag$1<E, ErrorTag>) => R) => Result<T | InferOkTypes<R>, ExcludeReasonTag<E, ErrorTag, ReasonTag> | InferErrTypes<R>>;
   /**
-  * Recovers from multiple nested tagged `reason` variants on a specific tagged error.
-  */
+   * Recovers from multiple nested tagged `reason` variants on a specific tagged error.
+   */
   catchReasons: <const ErrorTag extends TagsWithReasonOf<E>, const Handlers extends object>(errorTag: ErrorTag, handlers: Handlers & ResultCatchReasonHandlers<E, ErrorTag, Handlers>) => Result<T | InferOkTypes<CatchReasonHandlerResult<Handlers>>, ExcludeReasonTag<E, ErrorTag, keyof Handlers & string> | InferErrTypes<CatchReasonHandlerResult<Handlers>>>;
   /**
-  * Moves the nested `reason` of a tagged error into the Result error channel.
-  */
+   * Moves the nested `reason` of a tagged error into the Result error channel.
+   */
   unwrapReason: <const ErrorTag extends TagsWithReasonOf<E>>(errorTag: ErrorTag) => Result<T, ExcludeTag<E, ErrorTag> | ReasonsOf<E, ErrorTag>>;
   /**
-  * Chains an async fallible operation from the Ok value.
-  */
+   * Chains an async fallible operation from the Ok value.
+   */
   asyncAndThen: <X, Y>(f: (t: T) => ResultAsync<X, Y>) => ResultAsync<X, E | Y>;
   /**
-  * Maps the Ok value with an async function and returns a `ResultAsync`.
-  */
+   * Maps the Ok value with an async function and returns a `ResultAsync`.
+   */
   asyncMap: <X>(f: (t: T) => Promise<X>) => ResultAsync<X, E>;
   /**
-  * Converts this Result into a plain value by handling both Ok and Err.
-  */
+   * Converts this Result into a plain value by handling both Ok and Err.
+   */
   match: {
     <A, B = A>(handlers: MatchHandlers$1<T, E, A, B>): A | B;
     <A, B = A>(fnOk: MatchOkHandler<T, A>, fnErr: MatchErrorHandler<E, B>): A | B;
   };
   /**
-  * Converts this Result into a plain value with exhaustive tagged-error handlers.
-  */
+   * Converts this Result into a plain value with exhaustive tagged-error handlers.
+   */
   matchTags: <A, const Handlers extends object>(fnOk: (t: T) => A, handlers: Handlers & MatchTagHandlers<E, Handlers>) => A | MatchTagHandlerResult<Handlers>;
   /**
-  * Converts this Result into a plain value with partial tagged-error handlers and a fallback.
-  */
+   * Converts this Result into a plain value with partial tagged-error handlers and a fallback.
+   */
   matchTagsPartial: <A, B, const Handlers extends object>(fnOk: (t: T) => A, handlers: Handlers & PartialMatchTagHandlers<E, Handlers>, fallback: (error: E) => B) => A | MatchTagHandlerResult<Handlers> | B;
   /**
-  * Pipes this Result through reusable transformation functions.
-  */
+   * Pipes this Result through reusable transformation functions.
+   */
   pipe: {
     <A>(ab: PipeFn<Result<T, E>, A>): A;
     <A, B>(ab: PipeFn<Result<T, E>, A>, bc: PipeFn<A, B>): B;
     <A, B, C>(ab: PipeFn<Result<T, E>, A>, bc: PipeFn<A, B>, cd: PipeFn<B, C>): C;
   };
   /**
-  * Runs a side effect with the Ok or Err value and returns this same Result.
-  *
-  * Exceptions thrown by the side effect are swallowed.
-  */
+   * Runs a side effect with the Ok or Err value and returns this same Result.
+   *
+   * Exceptions thrown by the side effect are swallowed.
+   */
   log: (fn: (t?: T, e?: E) => void) => this;
   /**
-  * Runs a side effect only when this result is Ok and returns this same Result.
-  *
-  * Exceptions thrown by the side effect are swallowed.
-  */
+   * Runs a side effect only when this result is Ok and returns this same Result.
+   *
+   * Exceptions thrown by the side effect are swallowed.
+   */
   tap: (fn: (t: T) => void) => this;
   /**
-  * Runs a side effect only when this result is Err and returns this same Result.
-  *
-  * Exceptions thrown by the side effect are swallowed.
-  */
+   * Runs a side effect only when this result is Err and returns this same Result.
+   *
+   * Exceptions thrown by the side effect are swallowed.
+   */
   tapError: (fn: (e: E) => void) => this;
   /**
-  * Attaches a synchronous disposal finalizer to this Result.
-  */
+   * Attaches a synchronous disposal finalizer to this Result.
+   */
   toDisposable: (f: ResultFinalizer<T, E>) => DisposableResult<T, E>;
   /**
-  * Returns the Ok value or throws the Err value.
-  *
-  * Use this at final application boundaries after the error channel has been modeled.
-  */
+   * Returns the Ok value or throws the Err value.
+   *
+   * Use this at final application boundaries after the error channel has been modeled.
+   */
   unwrapOrThrow: () => T;
   /**
-  * Enables `yield* result` inside `safeTry` generators.
-  */
+   * Enables `yield* result` inside `safeTry` generators.
+   */
   [Symbol.iterator]: () => Generator<Result<never, E>, T>;
   /**
-  * Compatibility generator for `safeTry`. Prefer `yield* result` in new code.
-  */
+   * Compatibility generator for `safeTry`. Prefer `yield* result` in new code.
+   */
   safeUnwrap: () => Generator<Result<never, E>, T>;
 }
+/** Successful `Result` variant carrying a value of type `T`. */
 interface OkResult<T, E> extends ResultOperations<T, E> {
   /**
-  * Ok value carried by this result.
-  */
+   * Ok value carried by this result.
+   */
   readonly value: T;
 }
+/** Failed `Result` variant carrying an error of type `E`. */
 interface ErrResult<T, E> extends ResultOperations<T, E> {
   /**
-  * Err value carried by this result.
-  */
+   * Err value carried by this result.
+   */
   readonly error: E;
 }
+/** Success-or-failure value with explicit Ok and Err channels. */
 type Result<T, E> = OkResult<T, E> | ErrResult<T, E>;
+/** `Result` convention that restricts the error channel to real `Error` instances. */
 type StrictResult<T, E extends Error = Error> = Result<T, E>;
 /**
-* Object form accepted by `tryResult`.
-*
-* Use this form when named `try` and `catch` fields make a synchronous boundary easier to read.
-*/
+ * Object form accepted by `tryResult`.
+ *
+ * Use this form when named `try` and `catch` fields make a synchronous boundary easier to read.
+ */
 interface TryResultOptions<T, E = unknown> {
   /**
-  * Runs the synchronous work whose thrown value should become `Err<E>`.
-  */
+   * Runs the synchronous work whose thrown value should become `Err<E>`.
+   */
   readonly try: () => Exclude<T, Promise<unknown>>;
   /**
-  * Converts a thrown `unknown` cause into the typed Resultar error channel.
-  *
-  * If omitted, the error channel is `unknown`.
-  */
+   * Converts a thrown `unknown` cause into the typed Resultar error channel.
+   *
+   * If omitted, the error channel is `unknown`.
+   */
   readonly catch?: (e: unknown) => E;
 }
+/** Object-form synchronous generator workflow accepted by `safeTry`. */
 interface SafeTryOptions<YieldErr extends Result<never, unknown>, GeneratorReturnResult extends Result<unknown, unknown>, CatchErr = never> {
   /**
-  * Generator body evaluated by `safeTry`.
-  *
-  * Use `yield* result` to unwrap Resultar values and short-circuit on Err.
-  */
+   * Generator body evaluated by `safeTry`.
+   *
+   * Use `yield* result` to unwrap Resultar values and short-circuit on Err.
+   */
   readonly try: () => Generator<YieldErr, GeneratorReturnResult>;
   /**
-  * Converts synchronous throws from the generator setup into the Result error channel.
-  */
+   * Converts synchronous throws from the generator setup into the Result error channel.
+   */
   readonly catch?: (e: unknown) => CatchErr;
 }
+/** Object-form asynchronous generator workflow accepted by `safeTry`. */
 interface SafeTryAsyncOptions<YieldErr extends Result<never, unknown>, GeneratorReturnResult extends Result<unknown, unknown>, CatchErr = never> {
   /**
-  * Async generator body evaluated by `safeTry`.
-  *
-  * Use `yield* result` or `yield* resultAsync` to unwrap Resultar values and short-circuit on Err.
-  */
+   * Async generator body evaluated by `safeTry`.
+   *
+   * Use `yield* result` or `yield* resultAsync` to unwrap Resultar values and short-circuit on Err.
+   */
   readonly try: () => AsyncGenerator<YieldErr, GeneratorReturnResult>;
   /**
-  * Converts synchronous throws or async rejections from the generator setup into the ResultAsync
-  * error channel.
-  */
+   * Converts synchronous throws or async rejections from the generator setup into the ResultAsync
+   * error channel.
+   */
   readonly catch?: (e: unknown) => CatchErr;
 }
 interface ResultStatic {
   /**
-  * Runtime `instanceof Result` support for Ok and Err values.
-  */
+   * Runtime `instanceof Result` support for Ok and Err values.
+   */
   [Symbol.hasInstance]: (value: unknown) => boolean;
   /**
-  * Runs synchronous work and captures thrown values into a Result.
-  *
-  * Compatibility alias. Prefer the top-level `tryResult` helper in new code.
-  */
+   * Alias for `safeTry`, providing the same generator vocabulary as `ResultTask.gen`.
+   */
+  gen: typeof safeTry;
+  /**
+   * Runs synchronous work and captures thrown values into a Result.
+   *
+   * Compatibility alias. Prefer the top-level `tryResult` helper in new code.
+   */
   tryCatch: <T, E>(this: void, fn: () => Exclude<T, Promise<unknown>>, errorFn?: (e: unknown) => E) => Result<T, E>;
   /**
-  * Wraps a throwing synchronous function so every later call returns a Result.
-  */
+   * Wraps a throwing synchronous function so every later call returns a Result.
+   */
   fromThrowable: <Fn extends (...args: readonly any[]) => unknown, E>(this: void, fn: Fn, errorFn?: (e: any) => E) => (...args: Parameters<Fn>) => Result<ReturnType<Fn>, E>;
   /**
-  * Creates an Ok result.
-  */
+   * Creates an Ok result.
+   */
   ok: {
     <T, E = never>(this: void, value: T): OkResult<T, E>;
     <E = never>(this: void, value: void): OkResult<void, E>;
   };
   /**
-  * Creates an Ok result with `undefined`.
-  */
+   * Creates an Ok result with `undefined`.
+   */
   unit: <E = never>(this: void) => Result<undefined, E>;
   /**
-  * Creates an Err result.
-  */
+   * Creates an Err result.
+   */
   err: {
     <T = never, E extends string = string>(this: void, err: E): ErrResult<T, E>;
     <T = never, E = unknown>(this: void, err: E): ErrResult<T, E>;
     <T = never>(this: void, err: void): ErrResult<T, void>;
   };
   /**
-  * Combines many Result values and stops at the first Err.
-  *
-  * Arrays return an Ok array, records return an Ok record with the same keys, and iterables return
-  * an Ok readonly array.
-  */
+   * Combines many Result values and stops at the first Err.
+   *
+   * Arrays return an Ok array, records return an Ok record with the same keys, and iterables return
+   * an Ok readonly array.
+   */
   combine: {
     <T extends readonly [Result<unknown, unknown>, ...Result<unknown, unknown>[]]>(this: void, resultList: T): CombineResults<T>;
     <T extends readonly Result<unknown, unknown>[]>(this: void, resultList: T): CombineResults<T>;
@@ -447,8 +458,8 @@ interface ResultStatic {
     <R extends Result<unknown, unknown>>(this: void, results: Iterable<R>): CombineResultsIterable<R>;
   };
   /**
-  * Combines many Result values and collects every Err instead of stopping at the first one.
-  */
+   * Combines many Result values and collects every Err instead of stopping at the first one.
+   */
   combineWithAllErrors: {
     <T extends readonly [Result<unknown, unknown>, ...Result<unknown, unknown>[]]>(this: void, resultList: T): CombineResultsWithAllErrorsArray<T>;
     <T extends readonly Result<unknown, unknown>[]>(this: void, resultList: T): CombineResultsWithAllErrorsArray<T>;
@@ -456,51 +467,51 @@ interface ResultStatic {
     <R extends Result<unknown, unknown>>(this: void, results: Iterable<R>): CombineResultsIterableWithAllErrors<R>;
   };
   /**
-  * Validates many Result values and collects every Err.
-  *
-  * When passed items plus a mapper, the mapper must return a Result for each item.
-  */
+   * Validates many Result values and collects every Err.
+   *
+   * When passed items plus a mapper, the mapper must return a Result for each item.
+   */
   validateAll: {
     <T extends readonly [Result<unknown, unknown>, ...Result<unknown, unknown>[]]>(this: void, resultList: T): CombineResultsWithAllErrorsArray<T>;
     <T extends readonly Result<unknown, unknown>[]>(this: void, resultList: T): CombineResultsWithAllErrorsArray<T>;
     <Item, R extends Result<unknown, unknown>>(this: void, items: Iterable<Item>, f: (value: Item, index: number) => R): ResultValidatedAll<R>;
   };
   /**
-  * Combines exactly two Result values into an Ok tuple or the first Err.
-  */
+   * Combines exactly two Result values into an Ok tuple or the first Err.
+   */
   zip: <Left extends Result<unknown, unknown>, Right extends Result<unknown, unknown>>(this: void, left: Left, right: Right) => ResultZipped<Left, Right>;
   /**
-  * Runs candidates until the first Ok and returns the last Err if every candidate fails.
-  */
+   * Runs candidates until the first Ok and returns the last Err if every candidate fails.
+   */
   firstSuccessOf: <Candidates extends Iterable<ResultCandidate>>(this: void, candidates: Candidates) => FirstSuccessOf<Candidates>;
   /**
-  * Chooses one of two Result branches from a boolean or Result boolean condition.
-  */
+   * Chooses one of two Result branches from a boolean or Result boolean condition.
+   */
   if: {
     <OnTrue extends Result<unknown, unknown>, OnFalse extends Result<unknown, unknown>>(this: void, condition: ResultBooleanCondition, options: ResultIfOptions<OnTrue, OnFalse>): ResultIf<never, OnTrue, OnFalse>;
     <Condition extends Result<boolean, unknown>, OnTrue extends Result<unknown, unknown>, OnFalse extends Result<unknown, unknown>>(this: void, condition: Condition, options: ResultIfOptions<OnTrue, OnFalse>): ResultIf<InferErrTypes<Condition>, OnTrue, OnFalse>;
   };
   /**
-  * Runs `body` only when the condition is true; otherwise returns Ok(undefined).
-  */
+   * Runs `body` only when the condition is true; otherwise returns Ok(undefined).
+   */
   when: <R extends Result<unknown, unknown>>(this: void, condition: ResultBooleanCondition, body: () => R) => ResultWhen<R>;
   /**
-  * Runs `body` only when a Result boolean condition is Ok(true).
-  */
+   * Runs `body` only when a Result boolean condition is Ok(true).
+   */
   whenResult: <Condition extends Result<boolean, unknown>, R extends Result<unknown, unknown>>(this: void, condition: Condition, body: () => R) => ResultWhenWithCondition<Condition, R>;
   /**
-  * Runs `body` only when the condition is false; otherwise returns Ok(undefined).
-  */
+   * Runs `body` only when the condition is false; otherwise returns Ok(undefined).
+   */
   unless: <R extends Result<unknown, unknown>>(this: void, condition: ResultBooleanCondition, body: () => R) => ResultWhen<R>;
   /**
-  * Runs `body` only when a Result boolean condition is Ok(false).
-  */
+   * Runs `body` only when a Result boolean condition is Ok(false).
+   */
   unlessResult: <Condition extends Result<boolean, unknown>, R extends Result<unknown, unknown>>(this: void, condition: Condition, body: () => R) => ResultWhenWithCondition<Condition, R>;
   /**
-  * Repeats a Result-producing body while a condition holds.
-  *
-  * Use `discard: true` when only failure matters and collected Ok values are not needed.
-  */
+   * Repeats a Result-producing body while a condition holds.
+   *
+   * Use `discard: true` when only failure matters and collected Ok values are not needed.
+   */
   loop: {
     <State, BodyState extends State, R extends Result<unknown, unknown>>(this: void, initial: State, options: ResultLoopOptions<State, BodyState, R>): ResultLoopCollected<R>;
     <State, R extends Result<unknown, unknown>>(this: void, initial: State, options: ResultLoopBooleanOptions<State, R>): ResultLoopCollected<R>;
@@ -508,79 +519,80 @@ interface ResultStatic {
     <State, R extends Result<unknown, unknown>>(this: void, initial: State, options: ResultLoopBooleanDiscardOptions<State, R>): ResultLoopDiscarded<R>;
   };
   /**
-  * Repeatedly transforms state with a Result-producing body until the condition fails.
-  */
+   * Repeatedly transforms state with a Result-producing body until the condition fails.
+   */
   iterate: {
     <State, BodyState extends WidenLiteral$1<State>, R extends Result<WidenLiteral$1<State>, unknown>>(this: void, initial: State, options: ResultIterateOptions<WidenLiteral$1<State>, BodyState, R>): ResultIterated<WidenLiteral$1<State>, R>;
     <State, R extends Result<WidenLiteral$1<State>, unknown>>(this: void, initial: State, options: ResultIterateBooleanOptions<WidenLiteral$1<State>, R>): ResultIterated<WidenLiteral$1<State>, R>;
   };
   /**
-  * Runs a Result-producing mapper for each item.
-  *
-  * Use `discard: true` when only failure matters and collected Ok values are not needed.
-  */
+   * Runs a Result-producing mapper for each item.
+   *
+   * Use `discard: true` when only failure matters and collected Ok values are not needed.
+   */
   forEach: {
     <Item, R extends Result<unknown, unknown>>(this: void, items: Iterable<Item>, f: (value: Item, index: number) => R, options?: ResultForEachOptions): ResultForEachCollected<R>;
     <Item, R extends Result<unknown, unknown>>(this: void, items: Iterable<Item>, f: (value: Item, index: number) => R, options: ResultForEachDiscardOptions): ResultForEachDiscarded<R>;
   };
 }
+/** Static helpers for creating, combining, and iterating over Result values. */
 declare const Result: ResultStatic;
 /**
-* A `Disposable` is an object that has a `dispose` method that can be used to
-* clean up resources.
-*/
+ * A `Disposable` is an object that has a `dispose` method that can be used to
+ * clean up resources.
+ */
 declare class DisposableResult<T, E> implements Resultable<T, E>, Disposable {
   private disposed;
   private readonly finalizer;
   /**
-  * Wrapped Result value.
-  */
+   * Wrapped Result value.
+   */
   readonly result: Result<T, E>;
   /**
-  * Creates a disposable wrapper around a Result.
-  */
+   * Creates a disposable wrapper around a Result.
+   */
   constructor(result: Result<T, E>, finalizer: ResultFinalizer<T, E>);
   /**
-  * Ok value when present, otherwise undefined cast to `T` for compatibility.
-  */
+   * Ok value when present, otherwise undefined cast to `T` for compatibility.
+   */
   get value(): T;
   /**
-  * Err value when present, otherwise undefined cast to `E` for compatibility.
-  */
+   * Err value when present, otherwise undefined cast to `E` for compatibility.
+   */
   get error(): E;
   /**
-  * Delegates to the wrapped Result `_unsafeUnwrap`.
-  */
+   * Delegates to the wrapped Result `_unsafeUnwrap`.
+   */
   _unsafeUnwrap(config?: ErrorConfig): T;
   /**
-  * Delegates to the wrapped Result `_unsafeUnwrapErr`.
-  */
+   * Delegates to the wrapped Result `_unsafeUnwrapErr`.
+   */
   _unsafeUnwrapErr(config?: ErrorConfig): E;
   /**
-  * Returns whether the wrapped Result is Ok.
-  */
+   * Returns whether the wrapped Result is Ok.
+   */
   isOk(): boolean;
   /**
-  * Returns whether the wrapped Result is Err.
-  */
+   * Returns whether the wrapped Result is Err.
+   */
   isErr(): boolean;
   /**
-  * Returns the wrapped Ok value, or `defaultValue` when Err.
-  */
+   * Returns the wrapped Ok value, or `defaultValue` when Err.
+   */
   unwrapOr<A>(defaultValue: A): T | A;
   /**
-  * Runs the finalizer once.
-  *
-  * Finalizer exceptions are intentionally swallowed.
-  */
+   * Runs the finalizer once.
+   *
+   * Finalizer exceptions are intentionally swallowed.
+   */
   [Symbol.dispose](): void;
 }
 /**
-* Evaluates a synchronous generator and returns the first yielded Err or returned Result.
-*
-* Inside the generator, use `yield* result` to unwrap Ok values and short-circuit on Err. The object
-* form can map thrown setup errors into the Result error channel.
-*/
+ * Evaluates a synchronous generator and returns the first yielded Err or returned Result.
+ *
+ * Inside the generator, use `yield* result` to unwrap Ok values and short-circuit on Err. The object
+ * form can map thrown setup errors into the Result error channel.
+ */
 declare function safeTry<T, E, CatchErr = E>(input: SafeTryOptions<Result<never, E>, Result<T, E>, CatchErr> & {
   readonly catch: (e: unknown) => CatchErr;
 }): Result<T, E | CatchErr>;
@@ -590,13 +602,13 @@ declare function safeTry<YieldErr extends Result<never, unknown>, GeneratorRetur
 }): Result<InferOkTypes<GeneratorReturnResult>, InferErrTypes<YieldErr> | InferErrTypes<GeneratorReturnResult> | CatchErr>;
 declare function safeTry<YieldErr extends Result<never, unknown>, GeneratorReturnResult extends Result<unknown, unknown>>(input: (() => Generator<YieldErr, GeneratorReturnResult>) | SafeTryOptions<YieldErr, GeneratorReturnResult>): Result<InferOkTypes<GeneratorReturnResult>, InferErrTypes<YieldErr> | InferErrTypes<GeneratorReturnResult>>;
 /**
-* Evaluates an async generator and returns a ResultAsync for the first yielded Err or returned
-* Result.
-*
-* Inside the generator, use `yield* result` or `yield* resultAsync` to unwrap Ok values and
-* short-circuit on Err. The object form can map thrown or rejected setup errors into the ResultAsync
-* error channel.
-*/
+ * Evaluates an async generator and returns a ResultAsync for the first yielded Err or returned
+ * Result.
+ *
+ * Inside the generator, use `yield* result` or `yield* resultAsync` to unwrap Ok values and
+ * short-circuit on Err. The object form can map thrown or rejected setup errors into the ResultAsync
+ * error channel.
+ */
 declare function safeTry<T, E, CatchErr = E>(input: SafeTryAsyncOptions<Result<never, E>, Result<T, E>, CatchErr> & {
   readonly catch: (e: unknown) => CatchErr;
 }): ResultAsync<T, E | CatchErr>;
@@ -606,64 +618,64 @@ declare function safeTry<YieldErr extends Result<never, unknown>, GeneratorRetur
 }): ResultAsync<InferOkTypes<GeneratorReturnResult>, InferErrTypes<YieldErr> | InferErrTypes<GeneratorReturnResult> | CatchErr>;
 declare function safeTry<YieldErr extends Result<never, unknown>, GeneratorReturnResult extends Result<unknown, unknown>>(input: (() => AsyncGenerator<YieldErr, GeneratorReturnResult>) | SafeTryAsyncOptions<YieldErr, GeneratorReturnResult>): ResultAsync<InferOkTypes<GeneratorReturnResult>, InferErrTypes<YieldErr> | InferErrTypes<GeneratorReturnResult>>;
 /**
-* Creates an Ok result.
-*/
+ * Creates an Ok result.
+ */
 declare function ok<T, E = never>(value: T): OkResult<T, E>;
 declare function ok<E = never>(value: void): OkResult<void, E>;
 /**
-* Creates an Err result.
-*/
+ * Creates an Err result.
+ */
 declare function err<T = never, E extends string = string>(err: E): ErrResult<T, E>;
 declare function err<T = never, E = unknown>(err: E): ErrResult<T, E>;
 declare function err<T = never>(err: void): ErrResult<T, void>;
 /**
-* Wraps a throwing synchronous function so every later call returns a Result.
-*
-* Prefer `tryResult` when you want to run the operation immediately.
-*/
+ * Wraps a throwing synchronous function so every later call returns a Result.
+ *
+ * Prefer `tryResult` when you want to run the operation immediately.
+ */
 declare const fromThrowable: typeof Result.fromThrowable;
 /**
-* Runs synchronous work and captures thrown values into `Result<T, E>`.
-*
-* Use `tryResult` at the edge of uncontrolled synchronous code: JSON parsing, environment parsing,
-* platform APIs, or third-party functions that may throw. The mapper receives the thrown `unknown`
-* cause and returns the typed error for the Resultar channel.
-*
-* @example
-* ```ts
-* const config = tryResult(
-*   () => JSON.parse(input) as Config,
-*   (cause) => new ParseConfigError({ cause }),
-* )
-* ```
-*/
+ * Runs synchronous work and captures thrown values into `Result<T, E>`.
+ *
+ * Use `tryResult` at the edge of uncontrolled synchronous code: JSON parsing, environment parsing,
+ * platform APIs, or third-party functions that may throw. The mapper receives the thrown `unknown`
+ * cause and returns the typed error for the Resultar channel.
+ *
+ * @example
+ * ```ts
+ * const config = tryResult(
+ *   () => JSON.parse(input) as Config,
+ *   (cause) => new ParseConfigError({ cause }),
+ * )
+ * ```
+ */
 declare function tryResult<T, E>(fn: () => Exclude<T, Promise<unknown>>, errorFn: (e: unknown) => E): Result<T, E>;
 /**
-* Captures a synchronous boundary with named `try` and `catch` fields.
-*
-* This is equivalent to `tryResult(() => ..., toError)`, but it reads better when the boundary has
-* a clear domain name or label.
-*/
+ * Captures a synchronous boundary with named `try` and `catch` fields.
+ *
+ * This is equivalent to `tryResult(() => ..., toError)`, but it reads better when the boundary has
+ * a clear domain name or label.
+ */
 declare function tryResult<T, E>(options: TryResultOptions<T, E> & {
   readonly catch: (e: unknown) => E;
 }): Result<T, E>;
 /**
-* Runs synchronous work and captures thrown values into `Result<T, unknown>`.
-*
-* Prefer the overload with a catch mapper in application code so the error channel stays documented.
-* This overload is useful while adapting unknown external failures or during migration.
-*/
+ * Runs synchronous work and captures thrown values into `Result<T, unknown>`.
+ *
+ * Prefer the overload with a catch mapper in application code so the error channel stays documented.
+ * This overload is useful while adapting unknown external failures or during migration.
+ */
 declare function tryResult<T>(input: (() => Exclude<T, Promise<unknown>>) | TryResultOptions<T>): Result<T, unknown>;
 /**
-* Creates an Ok result with `undefined`.
-*/
+ * Creates an Ok result with `undefined`.
+ */
 declare function unit<E = never>(): OkResult<undefined, E>;
 /**
-* Runs a `Result` at an application boundary and returns the success value.
-*
-* If the result is `Err`, this throws the error. Use it at final framework, CLI, test, or bootstrap
-* boundaries after the error channel has already been modeled with Resultar.
-*/
+ * Runs a `Result` at an application boundary and returns the success value.
+ *
+ * If the result is `Err`, this throws the error. Use it at final framework, CLI, test, or bootstrap
+ * boundaries after the error channel has already been modeled with Resultar.
+ */
 declare const runSync: <T, E>(result: Result<T, E>) => T;
 /** Compatibility alias. Prefer `tryResult` in new code. */
 declare const tryCatch: typeof tryResult;
@@ -672,7 +684,7 @@ type CollectResults<T, Collected extends unknown[] = [], Depth extends number =
 type Transpose<A, Transposed extends unknown[][] = [], Depth extends number = 10> = A extends [infer T, ...infer Rest] ? T extends [infer L, infer R] ? Transposed extends [infer PL, infer PR] ? PL extends unknown[] ? PR extends unknown[] ? Transpose<Rest, [[...PL, L], [...PR, R]], Prev[Depth]> : never : never : Transpose<Rest, [[L], [R]], Prev[Depth]> : Transposed : Transposed;
 type Combine<T, Depth extends number = 5> = Transpose<CollectResults<T>, [], Depth> extends [infer L, infer R] ? [UnknownMembersToNever<L>, UnknownMembersToNever<R>] : Transpose<CollectResults<T>, [], Depth> extends [] ? [[], []] : never;
 type Dedup<T> = T extends Result<infer RL, infer RR> ? Result<RL, RR> : T;
-type MemberListOf<T> = ((T extends unknown ? (t: T) => T : never) extends infer U ? (U extends unknown ? (u: U) => unknown : never) extends ((v: infer V) => unknown) ? V : never : never) extends ((_: unknown) => infer W) ? [...MemberListOf<Exclude<T, W>>, W] : [];
+type MemberListOf<T> = ((T extends unknown ? (t: T) => T : never) extends (infer U) ? (U extends unknown ? (u: U) => unknown : never) extends ((v: infer V) => unknown) ? V : never : never) extends ((_: unknown) => infer W) ? [...MemberListOf<Exclude<T, W>>, W] : [];
 type EmptyArrayToNever<T, NeverArrayToNever extends number = 0> = T extends [] ? never : NeverArrayToNever extends 1 ? T extends [never, ...infer Rest] ? [EmptyArrayToNever<Rest>] extends [never] ? never : T : T : T;
 type UnknownMembersToNever<T> = T extends [infer H, ...infer R] ? [[unknown] extends [H] ? never : H, ...UnknownMembersToNever<R>] : T;
 type MembersToUnion<T> = T extends unknown[] ? T[number] : never;
@@ -686,263 +698,266 @@ type CombineResultsWithAllErrorsArray<T extends readonly Result<unknown, unknown
 //#endregion
 //#region src/abort-error.d.ts
 /**
-* Standard cancellation error used by ResultAsync retry, race, timeout, and resource helpers.
-*/
+ * Standard cancellation error used by ResultAsync retry, race, timeout, and resource helpers.
+ */
 declare class AbortError extends Error {
   /**
-  * Creates an AbortError.
-  */
+   * Creates an AbortError.
+   */
   constructor(message?: string, options?: ErrorOptions);
 }
 /**
-* Checks whether a value is an AbortError or abort-shaped platform error.
-*/
+ * Checks whether a value is an AbortError or abort-shaped platform error.
+ */
 declare const isAbortError: (value: unknown) => value is AbortError;
 //#endregion
 //#region src/result-async.d.ts
 type ResultAsyncFinalizer<T, E> = (value: T | undefined, error: E | undefined) => void | Promise<void>;
 /**
-* Object form accepted by `tryResultAsync`.
-*
-* Use this form when named `try` and `catch` fields make an async boundary easier to read, or when
-* you want the mapper next to the promise factory.
-*/
+ * Object form accepted by `tryResultAsync`.
+ *
+ * Use this form when named `try` and `catch` fields make an async boundary easier to read, or when
+ * you want the mapper next to the promise factory.
+ */
 interface TryResultAsyncOptions<T, E = unknown> {
   /**
-  * Creates the promise whose rejection should become `Err<E>`.
-  *
-  * Synchronous throws from this function are also captured.
-  */
+   * Creates the promise whose rejection should become `Err<E>`.
+   *
+   * Synchronous throws from this function are also captured.
+   */
   readonly try: () => Promise<T>;
   /**
-  * Converts a rejected or thrown `unknown` cause into the typed Resultar error channel.
-  *
-  * If omitted, the error channel is `unknown`.
-  */
+   * Converts a rejected or thrown `unknown` cause into the typed Resultar error channel.
+   *
+   * If omitted, the error channel is `unknown`.
+   */
   readonly catch?: (e: unknown) => E;
 }
+/** Minimal abort-signal contract used by cancellable Resultar operations. */
 interface ResultAsyncAbortSignal {
   /**
-  * Whether the cooperative async operation has been aborted.
-  */
+   * Whether the cooperative async operation has been aborted.
+   */
   readonly aborted: boolean;
   /**
-  * Optional abort cause provided by the losing race, timeout, or caller.
-  */
+   * Optional abort cause provided by the losing race, timeout, or caller.
+   */
   readonly reason?: unknown;
   /**
-  * Registers an abort listener.
-  */
+   * Registers an abort listener.
+   */
   addEventListener: (type: "abort", listener: () => void, options?: {
     readonly once?: boolean;
   }) => void;
   /**
-  * Removes an abort listener.
-  */
+   * Removes an abort listener.
+   */
   removeEventListener: (type: "abort", listener: () => void) => void;
 }
 /**
-* Context passed to `ResultAsync.fromCallback` subscriptions.
-*/
+ * Context passed to `ResultAsync.fromCallback` subscriptions.
+ */
 interface ResultAsyncCallbackContext<T> {
   /**
-  * Completes the operation with `Ok(value)`.
-  */
+   * Completes the operation with `Ok(value)`.
+   */
   readonly resolve: (value: T) => void;
   /**
-  * Completes the operation with a cause mapped by the subscription's `catch` function.
-  */
+   * Completes the operation with a cause mapped by the subscription's `catch` function.
+   */
   readonly reject: (cause: unknown) => void;
   /**
-  * Cooperative cancellation signal for the subscription.
-  */
+   * Cooperative cancellation signal for the subscription.
+   */
   readonly signal: ResultAsyncAbortSignal;
 }
 /**
-* Synchronous cleanup returned by a `ResultAsync.fromCallback` subscription.
-*/
+ * Synchronous cleanup returned by a `ResultAsync.fromCallback` subscription.
+ */
 type ResultAsyncCallbackCleanup = () => void;
 /**
-* Options for adapting a callback or subscription API into `ResultAsync`.
-*/
+ * Options for adapting a callback or subscription API into `ResultAsync`.
+ */
 interface ResultAsyncFromCallbackOptions<T, E> {
   /**
-  * Maps callback failures and synchronous subscription throws into the typed error channel.
-  */
+   * Maps callback failures and synchronous subscription throws into the typed error channel.
+   */
   readonly catch: (cause: unknown) => E;
   /**
-  * Optional external signal that cancels the subscription with `AbortError`.
-  */
+   * Optional external signal that cancels the subscription with `AbortError`.
+   */
   readonly signal?: ResultAsyncAbortSignal;
   /**
-  * Registers the callback source and optionally returns a synchronous unsubscribe function.
-  */
+   * Registers the callback source and optionally returns a synchronous unsubscribe function.
+   */
   readonly subscribe: (context: ResultAsyncCallbackContext<T>) => ResultAsyncCallbackCleanup | void;
 }
 /**
-* Concurrency setting for async collection helpers.
-*
-* Use a number for bounded parallelism or `'unbounded'` when every task may start immediately.
-*/
+ * Concurrency setting for async collection helpers.
+ *
+ * Use a number for bounded parallelism or `'unbounded'` when every task may start immediately.
+ */
 type ResultAsyncConcurrency = number | "unbounded";
 type HandlerOk<R> = InferOkTypes<R> | InferAsyncOkTypes<R>;
 type HandlerErr<R> = InferErrTypes<R> | InferAsyncErrTypes<R>;
 type IterableElement<T> = T extends Iterable<infer Element> ? Element : never;
 /**
-* Candidate used by `ResultAsync.firstSuccessOf`.
-*/
+ * Candidate used by `ResultAsync.firstSuccessOf`.
+ */
 type ResultAsyncCandidate = () => ResultAsync<unknown, unknown>;
 type ResultAsyncRecord = Readonly<Record<string, ResultAsync<unknown, unknown>>>;
-type CombineResultAsyncsRecord<T extends ResultAsyncRecord> = ResultAsync<{ readonly [Key in keyof T]: InferAsyncOkTypes<T[Key]> }, InferAsyncErrTypes<T[keyof T]>>;
-type CombineResultAsyncsRecordWithAllErrors<T extends ResultAsyncRecord> = ResultAsync<{ readonly [Key in keyof T]: InferAsyncOkTypes<T[Key]> }, InferAsyncErrTypes<T[keyof T]>[]>;
+type CombineResultAsyncsRecord<T extends ResultAsyncRecord> = ResultAsync<{ readonly [Key in keyof T]: InferAsyncOkTypes<T[Key]>; }, InferAsyncErrTypes<T[keyof T]>>;
+type CombineResultAsyncsRecordWithAllErrors<T extends ResultAsyncRecord> = ResultAsync<{ readonly [Key in keyof T]: InferAsyncOkTypes<T[Key]>; }, InferAsyncErrTypes<T[keyof T]>[]>;
 type CombineResultAsyncsIterable<R extends ResultAsync<unknown, unknown>> = ResultAsync<readonly InferAsyncOkTypes<R>[], InferAsyncErrTypes<R>>;
 type CombineResultAsyncsIterableWithAllErrors<R extends ResultAsync<unknown, unknown>> = ResultAsync<readonly InferAsyncOkTypes<R>[], InferAsyncErrTypes<R>[]>;
 /**
-* Task used by race, timeout, and retry helpers.
-*
-* The signal lets the task cooperate with cancellation when another task wins or a timeout fires.
-*/
+ * Task used by race, timeout, and retry helpers.
+ *
+ * The signal lets the task cooperate with cancellation when another task wins or a timeout fires.
+ */
 type ResultAsyncRaceTask<T, E> = (signal: ResultAsyncAbortSignal) => ResultAsync<T, E>;
 type ResultAsyncRaceTaskOk<Task> = Task extends ResultAsyncRaceTask<infer T, unknown> ? T : never;
 type ResultAsyncRaceTaskErr<Task> = Task extends ResultAsyncRaceTask<unknown, infer E> ? E : never;
 type ResultAsyncRaceTasksOk<Tasks extends readonly ResultAsyncRaceTask<unknown, unknown>[]> = ResultAsyncRaceTaskOk<Tasks[number]>;
 type ResultAsyncRaceTasksErr<Tasks extends readonly ResultAsyncRaceTask<unknown, unknown>[]> = ResultAsyncRaceTaskErr<Tasks[number]>;
+/** Running cancellable task returned by Resultar race helpers. */
 interface ResultAsyncRaceHandle<T, E> {
   /**
-  * Abort signal associated with the running task.
-  */
+   * Abort signal associated with the running task.
+   */
   readonly signal: ResultAsyncAbortSignal;
   /**
-  * Aborts the running task with an optional reason.
-  */
+   * Aborts the running task with an optional reason.
+   */
   abort: (reason?: unknown) => void;
   /**
-  * Waits for the task to settle as a ResultAsync.
-  */
+   * Waits for the task to settle as a ResultAsync.
+   */
   wait: () => ResultAsync<T, E>;
 }
 /**
-* Options for `ResultAsync.timeout`.
-*/
+ * Options for `ResultAsync.timeout`.
+ */
 interface ResultAsyncTimeoutOptions<E> {
   /**
-  * Creates the typed timeout error when the timeout wins.
-  */
+   * Creates the typed timeout error when the timeout wins.
+   */
   readonly onTimeout: () => E;
   /**
-  * Timeout duration in milliseconds.
-  */
+   * Timeout duration in milliseconds.
+   */
   readonly timeoutMs: number;
 }
 /**
-* Metadata passed to retry predicates, delays, callbacks, and fallback handlers.
-*/
+ * Metadata passed to retry predicates, delays, callbacks, and fallback handlers.
+ */
 interface ResultAsyncRetryContext {
   /**
-  * Current attempt number, starting at 1.
-  */
+   * Current attempt number, starting at 0.
+   */
   readonly attempt: number;
   /**
-  * Next attempt number if another retry is scheduled.
-  */
+   * Next attempt number if another retry is scheduled.
+   */
   readonly nextAttempt: number;
   /**
-  * Number of retries still available after the current failure.
-  */
+   * Number of retries still available after the current failure.
+   */
   readonly retriesRemaining: number;
 }
 /**
-* Task used by `ResultAsync.retry` and `ResultAsync.retryOrElse`.
-*/
+ * Task used by `ResultAsync.retry` and `ResultAsync.retryOrElse`.
+ */
 type ResultAsyncRetryTask<T, E> = (attempt: number, signal: ResultAsyncAbortSignal) => ResultAsync<T, E>;
 type ResultAsyncRetryTaskOk<Task> = Task extends ResultAsyncRetryTask<infer T, unknown> ? T : never;
 type ResultAsyncRetryTaskErr<Task> = Task extends ResultAsyncRetryTask<unknown, infer E> ? E : never;
 type ResultAsyncRetryDelay = number | ((context: ResultAsyncRetryContext) => number);
+/** Retry policy for `ResultAsync.retry` and related helpers. */
 interface ResultAsyncRetryOptions<E> {
   /**
-  * Delay in milliseconds before retrying. Functions receive retry context.
-  */
+   * Delay in milliseconds before retrying. Functions receive retry context.
+   */
   readonly delayMs?: ResultAsyncRetryDelay;
   /**
-  * Randomizes the computed delay by this percentage factor.
-  *
-  * For example, `0.5` means 50% below to 50% above the computed delay.
-  */
+   * Randomizes the computed delay by this percentage factor.
+   *
+   * For example, `0.5` means 50% below to 50% above the computed delay.
+   */
   readonly jittered?: number;
   /**
-  * Side effect called after a failed attempt that will be retried.
-  */
+   * Side effect called after a failed attempt that will be retried.
+   */
   readonly onRetry?: (error: E, context: ResultAsyncRetryContext) => void | Promise<void>;
   /**
-  * Optional external abort signal for the retry loop.
-  */
+   * Optional external abort signal for the retry loop.
+   */
   readonly signal?: ResultAsyncAbortSignal;
   /**
-  * Maximum number of retries after the initial attempt.
-  */
+   * Maximum number of retries after the initial attempt.
+   */
   readonly times: number;
   /**
-  * Predicate deciding whether a failure is retryable.
-  */
+   * Predicate deciding whether a failure is retryable.
+   */
   readonly while?: (error: E, context: ResultAsyncRetryContext) => boolean | Promise<boolean>;
 }
 /**
-* Options for `ResultAsync.retryOrElse`.
-*/
+ * Options for `ResultAsync.retryOrElse`.
+ */
 interface ResultAsyncRetryOrElseOptions<E, F, U> extends ResultAsyncRetryOptions<E> {
   /**
-  * Fallback Resultar operation used after retry exhaustion.
-  */
+   * Fallback Resultar operation used after retry exhaustion.
+   */
   readonly orElse: (error: E, context: ResultAsyncRetryContext) => Result<U, F> | ResultAsync<U, F>;
 }
 /**
-* Acquires a resource for `ResultAsync.withResource`.
-*/
+ * Acquires a resource for `ResultAsync.withResource`.
+ */
 type ResultAsyncResourceAcquire<Resource, E> = (signal: ResultAsyncAbortSignal) => ResultAsync<Resource, E>;
 /**
-* Operation accepted by `ResultAsync.withResource` use/release callbacks.
-*/
+ * Operation accepted by `ResultAsync.withResource` use/release callbacks.
+ */
 type ResultAsyncResourceEffect<T, E> = Result<T, E> | ResultAsync<T, E>;
 /**
-* Uses an acquired resource inside `ResultAsync.withResource`.
-*/
+ * Uses an acquired resource inside `ResultAsync.withResource`.
+ */
 type ResultAsyncResourceUse<Resource, T, E> = (resource: Resource, signal: ResultAsyncAbortSignal) => ResultAsyncResourceEffect<T, E>;
 /**
-* Context passed to resource release callbacks.
-*/
+ * Context passed to resource release callbacks.
+ */
 interface ResultAsyncResourceReleaseContext {
   /**
-  * Result produced by the use phase, or undefined when acquisition failed.
-  */
+   * Result produced by the use phase, or undefined when acquisition failed.
+   */
   readonly result: Result<unknown, unknown> | undefined;
   /**
-  * Abort signal shared by the resource lifecycle.
-  */
+   * Abort signal shared by the resource lifecycle.
+   */
   readonly signal: ResultAsyncAbortSignal;
 }
 /**
-* Releases a resource after use, regardless of success or failure.
-*/
+ * Releases a resource after use, regardless of success or failure.
+ */
 type ResultAsyncResourceRelease<Resource> = (resource: Resource, context: ResultAsyncResourceReleaseContext) => ResultAsyncResourceEffect<unknown, unknown> | Promise<void> | void;
 /**
-* Options for `ResultAsync.withResource`.
-*/
+ * Options for `ResultAsync.withResource`.
+ */
 interface ResultAsyncWithResourceOptions<Resource, AcquireError, T, UseError> {
   /**
-  * Acquires the resource.
-  */
+   * Acquires the resource.
+   */
   readonly acquire: ResultAsyncResourceAcquire<Resource, AcquireError>;
   /**
-  * Releases the resource after use.
-  */
+   * Releases the resource after use.
+   */
   readonly release: ResultAsyncResourceRelease<Resource>;
   /**
-  * Optional external abort signal for the full lifecycle.
-  */
+   * Optional external abort signal for the full lifecycle.
+   */
   readonly signal?: ResultAsyncAbortSignal;
   /**
-  * Uses the acquired resource.
-  */
+   * Uses the acquired resource.
+   */
   readonly use: ResultAsyncResourceUse<Resource, T, UseError>;
 }
 type FirstSuccessOfAsync<Candidates extends Iterable<ResultAsyncCandidate>> = ResultAsync<InferAsyncOkTypes<ReturnType<IterableElement<Candidates>>>, InferAsyncErrTypes<ReturnType<IterableElement<Candidates>>>>;
@@ -1007,467 +1022,469 @@ interface ResultAsyncIfOptions<OnTrue extends ResultAsyncConditional, OnFalse ex
   readonly onFalse: () => OnFalse;
   readonly onTrue: () => OnTrue;
 }
+/** Async-disposable wrapper that finalizes a `ResultAsync` exactly once. */
 declare class DisposableResultAsync<T, E> implements PromiseLike<Result<T, E>>, AsyncDisposable {
   private readonly innerPromise;
   private readonly finalizer;
   private disposed;
   /**
-  * Creates an async disposable wrapper around a ResultAsync promise.
-  */
+   * Creates an async disposable wrapper around a ResultAsync promise.
+   */
   constructor(res: Promise<Result<T, E>>, finalizer: ResultAsyncFinalizer<T, E>);
   /**
-  * PromiseLike integration. Resolves to the wrapped Result.
-  */
+   * PromiseLike integration. Resolves to the wrapped Result.
+   */
   then<A, B>(successCallback?: (res: Result<T, E>) => A | PromiseLike<A>, failureCallback?: (reason: unknown) => B | PromiseLike<B>): PromiseLike<A | B>;
   /**
-  * Runs the finalizer once after the wrapped Result resolves.
-  *
-  * Finalizer exceptions and rejections are intentionally swallowed.
-  */
+   * Runs the finalizer once after the wrapped Result resolves.
+   *
+   * Finalizer exceptions and rejections are intentionally swallowed.
+   */
   [Symbol.asyncDispose](): Promise<void>;
 }
 /**
-* Represents an asynchronous Result type that wraps a Promise of a Result<T, E>.
-* This class provides a way to handle asynchronous operations that may succeed with a value of type T
-* or fail with an error of type E.
-*
-* @template T - The type of the success value
-* @template E - The type of the error value
-*
-* @implements {PromiseLike<Result<T, E>>}
-*
-* @example
-* ```typescript
-* // Create a successful async result
-* const okAsync = ResultAsync.okAsync(42);
-*
-* // Create a failed async result
-* const errAsync = ResultAsync.errAsync(new Error("Something went wrong"));
-*
-* // Transform a Promise into a ResultAsync
-* const resultFromPromise = ResultAsync.fromPromise(
-*   fetch("https://api.example.com/data"),
-*   (error) => new Error(`API call failed: ${error}`)
-* );
-* ```
-*
-* @remarks
-* ResultAsync implements the PromiseLike interface, allowing it to be used with async/await syntax.
-* It provides various utility methods for transforming and combining results, similar to the Result type,
-* but operating in an asynchronous context.
-*
-* The class includes methods for:
-* - Creating ResultAsync instances (okAsync, errAsync, fromPromise, fromCallback)
-* - Transforming values (map, mapErr)
-* - Chaining operations (andThen, orElse)
-* - Error handling (tapError)
-* - Conditional branching (if)
-* - Combining multiple ResultAsync instances (combine, combineWithAllErrors)
-*/
+ * Represents an asynchronous Result type that wraps a Promise of a Result<T, E>.
+ * This class provides a way to handle asynchronous operations that may succeed with a value of type T
+ * or fail with an error of type E.
+ *
+ * @template T - The type of the success value
+ * @template E - The type of the error value
+ *
+ * @implements {PromiseLike<Result<T, E>>}
+ *
+ * @example
+ * ```typescript
+ * // Create a successful async result
+ * const okAsync = ResultAsync.okAsync(42);
+ *
+ * // Create a failed async result
+ * const errAsync = ResultAsync.errAsync(new Error("Something went wrong"));
+ *
+ * // Transform a Promise into a ResultAsync
+ * const resultFromPromise = ResultAsync.fromPromise(
+ *   fetch("https://api.example.com/data"),
+ *   (error) => new Error(`API call failed: ${error}`)
+ * );
+ * ```
+ *
+ * @remarks
+ * ResultAsync implements the PromiseLike interface, allowing it to be used with async/await syntax.
+ * It provides various utility methods for transforming and combining results, similar to the Result type,
+ * but operating in an asynchronous context.
+ *
+ * The class includes methods for:
+ * - Creating ResultAsync instances (okAsync, errAsync, fromPromise, fromCallback)
+ * - Transforming values (map, mapErr)
+ * - Chaining operations (andThen, orElse)
+ * - Error handling (tapError)
+ * - Conditional branching (if)
+ * - Combining multiple ResultAsync instances (combine, combineWithAllErrors)
+ */
 declare class ResultAsync<T, E> extends Pipeable implements PromiseLike<Result<T, E>> {
   /**
-  * Returns a ResultAsync instance that is immediately resolved with a Result.ok(value).
-  *
-  * @param {T} value - The value to be wrapped in a Result.ok.
-  * @return {ResultAsync<T, E>} A ResultAsync instance with the given value and error type E.
-  */
+   * Returns a ResultAsync instance that is immediately resolved with a Result.ok(value).
+   *
+   * @param {T} value - The value to be wrapped in a Result.ok.
+   * @return {ResultAsync<T, E>} A ResultAsync instance with the given value and error type E.
+   */
   static okAsync<T, E = never>(this: void, value: T): ResultAsync<T, E>;
   static okAsync<E = never>(this: void, value: void): ResultAsync<void, E>;
   /**
-  * Returns a ResultAsync that is immediately resolved with a Result.ok(undefined) value.
-  *
-  * @return {ResultAsync<undefined, E>} A ResultAsync instance with undefined as the value type and E as the error type.
-  */
+   * Returns a ResultAsync that is immediately resolved with a Result.ok(undefined) value.
+   *
+   * @return {ResultAsync<undefined, E>} A ResultAsync instance with undefined as the value type and E as the error type.
+   */
   static unitAsync<E = never>(this: void): ResultAsync<undefined, E>;
   /**
-  * Returns a ResultAsync instance that is immediately resolved with a Result.err(error).
-  *
-  * @param {E} error - The error to be wrapped in a Result.err.
-  * @return {ResultAsync<T, E>} A ResultAsync instance with the given error and value type T.
-  */
+   * Returns a ResultAsync instance that is immediately resolved with a Result.err(error).
+   *
+   * @param {E} error - The error to be wrapped in a Result.err.
+   * @return {ResultAsync<T, E>} A ResultAsync instance with the given error and value type T.
+   */
   static errAsync<T = never, E = unknown>(this: void, err: E): ResultAsync<T, E>;
   static errAsync<T = never>(this: void, err: void): ResultAsync<T, void>;
   /**
-  * Creates a ResultAsync from a Promise, catching any errors that occur during its execution.
-  *
-  * Compatibility alias. Prefer the top-level `tryResultAsync` helper in new code.
-  *
-  * @param fn - The Promise or a function returning a Promise to be wrapped in a ResultAsync.
-  * @param errorFn - Optional function to transform the caught error into a specific error type.
-  *                  If not provided, the original error will be used.
-  * @returns A ResultAsync that will resolve to Ok with the promise's value if successful,
-  *          or Err with either the transformed error (if errorFn is provided) or the original error.
-  *
-  * New code should use the top-level `tryResultAsync` helper instead.
-  */
+   * Creates a ResultAsync from a Promise, catching any errors that occur during its execution.
+   *
+   * Compatibility alias. Prefer the top-level `tryResultAsync` helper in new code.
+   *
+   * @param fn - The Promise or a function returning a Promise to be wrapped in a ResultAsync.
+   * @param errorFn - Optional function to transform the caught error into a specific error type.
+   *                  If not provided, the original error will be used.
+   * @returns A ResultAsync that will resolve to Ok with the promise's value if successful,
+   *          or Err with either the transformed error (if errorFn is provided) or the original error.
+   *
+   * New code should use the top-level `tryResultAsync` helper instead.
+   */
   static tryCatch<T>(this: void, fn: Promise<T> | (() => Promise<T>)): ResultAsync<T, unknown>;
   static tryCatch<T, E>(this: void, fn: Promise<T> | (() => Promise<T>), errorFn: (e: unknown) => E): ResultAsync<T, E>;
   /**
-  * Returns a ResultAsync instance that is resolved with a Result.ok(value) or Result.err(error)
-  * based on the provided promise.
-  *
-  * @param {Promise<T>} promise - The promise to be wrapped in a ResultAsync.
-  * @return {ResultAsync<T, E>} A ResultAsync instance with the given promise and error type E.
-  */
+   * Returns a ResultAsync instance that is resolved with a Result.ok(value) or Result.err(error)
+   * based on the provided promise.
+   *
+   * @param {Promise<T>} promise - The promise to be wrapped in a ResultAsync.
+   * @return {ResultAsync<T, E>} A ResultAsync instance with the given promise and error type E.
+   */
   static fromSafePromise<T, E = never>(this: void, promise: PromiseLike<T>): ResultAsync<T, E>;
   /**
-  * Returns a ResultAsync instance that is resolved with a Result.ok(value) or Result.err(error)
-  * based on the provided promise.
-  *
-  * @param {Promise<T>} promise - The promise to be wrapped in a ResultAsync.
-  * @param {(e: unknown) => E} errorFn - A function that transforms the error from the promise into the error type E.
-  * @return {ResultAsync<T, E>} A ResultAsync instance with the given promise and error type E.
-  */
+   * Returns a ResultAsync instance that is resolved with a Result.ok(value) or Result.err(error)
+   * based on the provided promise.
+   *
+   * @param {Promise<T>} promise - The promise to be wrapped in a ResultAsync.
+   * @param {(e: unknown) => E} errorFn - A function that transforms the error from the promise into the error type E.
+   * @return {ResultAsync<T, E>} A ResultAsync instance with the given promise and error type E.
+   */
   static fromPromise<T, E>(this: void, promise: PromiseLike<T>, errorFn: (e: unknown) => E): ResultAsync<T, E>;
   /**
-  * Adapts a callback or subscription API into a cancellable ResultAsync.
-  *
-  * The returned cleanup function runs once after resolve, reject, cancellation, or synchronous
-  * subscription failure. Cleanup errors are ignored.
-  */
+   * Adapts a callback or subscription API into a cancellable ResultAsync.
+   *
+   * The returned cleanup function runs once after resolve, reject, cancellation, or synchronous
+   * subscription failure. Cleanup errors are ignored.
+   */
   static fromCallback<T, E>(this: void, options: ResultAsyncFromCallbackOptions<T, E>): ResultAsync<T, E | AbortError>;
   /**
-  * Combines many ResultAsync values and stops at the first Err.
-  *
-  * Arrays return an Ok array, records return an Ok record with the same keys, and iterables return
-  * an Ok readonly array.
-  */
+   * Combines many ResultAsync values and stops at the first Err.
+   *
+   * Arrays return an Ok array, records return an Ok record with the same keys, and iterables return
+   * an Ok readonly array.
+   */
   static combine<T extends readonly [ResultAsync<unknown, unknown>, ...ResultAsync<unknown, unknown>[]]>(this: void, asyncResultList: T): CombineResultAsyncs<T>;
   static combine<T extends readonly ResultAsync<unknown, unknown>[]>(this: void, asyncResultList: T): CombineResultAsyncs<T>;
   static combine<T extends ResultAsyncRecord>(this: void, asyncResultRecord: T): CombineResultAsyncsRecord<T>;
   static combine<R extends ResultAsync<unknown, unknown>>(this: void, asyncResults: Iterable<R>): CombineResultAsyncsIterable<R>;
   /**
-  * Combines many ResultAsync values and collects every Err instead of stopping at the first one.
-  */
+   * Combines many ResultAsync values and collects every Err instead of stopping at the first one.
+   */
   static combineWithAllErrors<T extends readonly [ResultAsync<unknown, unknown>, ...ResultAsync<unknown, unknown>[]]>(this: void, asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
   static combineWithAllErrors<T extends readonly ResultAsync<unknown, unknown>[]>(this: void, asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
   static combineWithAllErrors<T extends ResultAsyncRecord>(this: void, asyncResultRecord: T): CombineResultAsyncsRecordWithAllErrors<T>;
   static combineWithAllErrors<R extends ResultAsync<unknown, unknown>>(this: void, asyncResults: Iterable<R>): CombineResultAsyncsIterableWithAllErrors<R>;
   /**
-  * Validates many ResultAsync values and collects every Err.
-  *
-  * When passed items plus a mapper, the mapper must return a ResultAsync for each item. Use the
-  * optional concurrency setting to bound parallel work.
-  */
+   * Validates many ResultAsync values and collects every Err.
+   *
+   * When passed items plus a mapper, the mapper must return a ResultAsync for each item. Use the
+   * optional concurrency setting to bound parallel work.
+   */
   static validateAll<T extends readonly [ResultAsync<unknown, unknown>, ...ResultAsync<unknown, unknown>[]]>(this: void, asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
   static validateAll<T extends readonly ResultAsync<unknown, unknown>[]>(this: void, asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
   static validateAll<Item, R extends ResultAsync<unknown, unknown>>(this: void, items: Iterable<Item>, f: (value: Item, index: number) => R, options?: ResultAsyncValidateAllOptions): ResultAsyncValidatedAll<R>;
   /**
-  * Combines exactly two ResultAsync values into an Ok tuple or the first Err.
-  */
+   * Combines exactly two ResultAsync values into an Ok tuple or the first Err.
+   */
   static zip<Left extends ResultAsync<unknown, unknown>, Right extends ResultAsync<unknown, unknown>>(this: void, left: Left, right: Right): ResultAsyncZipped<Left, Right>;
   /**
-  * Retries a ResultAsync task according to a typed retry policy.
-  *
-  * The returned error channel includes the task error and `AbortError`.
-  */
+   * Retries a ResultAsync task according to a typed retry policy.
+   *
+   * The returned error channel includes the task error and `AbortError`.
+   */
   static retry<Task extends ResultAsyncRetryTask<unknown, unknown>>(this: void, task: Task, options: ResultAsyncRetryOptions<ResultAsyncRetryTaskErr<Task>>): ResultAsync<ResultAsyncRetryTaskOk<Task>, ResultAsyncRetryTaskErr<Task> | AbortError>;
   /**
-  * Retries a ResultAsync task and falls back to another Resultar operation after retry exhaustion.
-  */
+   * Retries a ResultAsync task and falls back to another Resultar operation after retry exhaustion.
+   */
   static retryOrElse<Task extends ResultAsyncRetryTask<unknown, unknown>, U, F>(this: void, task: Task, options: ResultAsyncRetryOrElseOptions<ResultAsyncRetryTaskErr<Task>, F, U>): ResultAsync<ResultAsyncRetryTaskOk<Task> | U, F | AbortError>;
   /**
-  * Acquires, uses, and releases a resource with cleanup on every path.
-  *
-  * Release errors are intentionally not part of the success/error channel; model cleanup failures
-  * in `use` when they should affect control flow.
-  */
+   * Acquires, uses, and releases a resource with cleanup on every path.
+   *
+   * Release errors are intentionally not part of the success/error channel; model cleanup failures
+   * in `use` when they should affect control flow.
+   */
   static withResource<Resource, AcquireError, T, UseError>(this: void, options: ResultAsyncWithResourceOptions<Resource, AcquireError, T, UseError>): ResultAsync<T, AcquireError | UseError | AbortError>;
   /**
-  * Races two cooperative ResultAsync tasks and returns the first settled Result.
-  */
+   * Races two cooperative ResultAsync tasks and returns the first settled Result.
+   */
   static race<Left extends ResultAsyncRaceTask<unknown, unknown>, Right extends ResultAsyncRaceTask<unknown, unknown>>(this: void, left: Left, right: Right): ResultAsync<ResultAsyncRaceTaskOk<Left> | ResultAsyncRaceTaskOk<Right>, ResultAsyncRaceTaskErr<Left> | ResultAsyncRaceTaskErr<Right>>;
   /**
-  * Races multiple cooperative ResultAsync tasks and returns the first settled Result.
-  */
+   * Races multiple cooperative ResultAsync tasks and returns the first settled Result.
+   */
   static raceAll<Tasks extends readonly [ResultAsyncRaceTask<unknown, unknown>, ...ResultAsyncRaceTask<unknown, unknown>[]]>(this: void, tasks: Tasks): ResultAsync<ResultAsyncRaceTasksOk<Tasks>, ResultAsyncRaceTasksErr<Tasks>>;
   /**
-  * Races two cooperative ResultAsync tasks and returns the first successful Ok.
-  *
-  * If both fail, the returned error is the final observed Err.
-  */
+   * Races two cooperative ResultAsync tasks and returns the first successful Ok.
+   *
+   * If both fail, the returned error is the final observed Err.
+   */
   static raceFirst<Left extends ResultAsyncRaceTask<unknown, unknown>, Right extends ResultAsyncRaceTask<unknown, unknown>>(this: void, left: Left, right: Right): ResultAsync<ResultAsyncRaceTaskOk<Left> | ResultAsyncRaceTaskOk<Right>, ResultAsyncRaceTaskErr<Left> | ResultAsyncRaceTaskErr<Right>>;
   /**
-  * Races two cooperative ResultAsync tasks and lets handlers decide what to do when either side
-  * settles first.
-  *
-  * Handlers receive the settled Result and a handle to the still-running opposite task.
-  */
+   * Races two cooperative ResultAsync tasks and lets handlers decide what to do when either side
+   * settles first.
+   *
+   * Handlers receive the settled Result and a handle to the still-running opposite task.
+   */
   static raceWith<Left extends ResultAsyncRaceTask<unknown, unknown>, Right extends ResultAsyncRaceTask<unknown, unknown>, OnLeftDone extends ResultAsyncConditional, OnRightDone extends ResultAsyncConditional>(this: void, left: Left, right: Right, handlers: {
     readonly onLeftDone: (result: Result<ResultAsyncRaceTaskOk<Left>, ResultAsyncRaceTaskErr<Left>>, right: ResultAsyncRaceHandle<ResultAsyncRaceTaskOk<Right>, ResultAsyncRaceTaskErr<Right>>) => OnLeftDone;
     readonly onRightDone: (result: Result<ResultAsyncRaceTaskOk<Right>, ResultAsyncRaceTaskErr<Right>>, left: ResultAsyncRaceHandle<ResultAsyncRaceTaskOk<Left>, ResultAsyncRaceTaskErr<Left>>) => OnRightDone;
   }): ResultAsync<HandlerOk<OnLeftDone> | HandlerOk<OnRightDone>, HandlerErr<OnLeftDone> | HandlerErr<OnRightDone>>;
   /**
-  * Runs a cooperative ResultAsync task with a typed timeout error.
-  */
+   * Runs a cooperative ResultAsync task with a typed timeout error.
+   */
   static timeout<Task extends ResultAsyncRaceTask<unknown, unknown>, TimeoutError>(this: void, task: Task, options: ResultAsyncTimeoutOptions<TimeoutError>): ResultAsync<ResultAsyncRaceTaskOk<Task>, ResultAsyncRaceTaskErr<Task> | TimeoutError>;
   /**
-  * Runs async candidates until the first Ok and returns the last Err if every candidate fails.
-  */
+   * Runs async candidates until the first Ok and returns the last Err if every candidate fails.
+   */
   static firstSuccessOf<Candidates extends Iterable<ResultAsyncCandidate>>(this: void, candidates: Candidates): FirstSuccessOfAsync<Candidates>;
   /**
-  * Chooses one of two Resultar async branches from a boolean or Resultar boolean condition.
-  */
+   * Chooses one of two Resultar async branches from a boolean or Resultar boolean condition.
+   */
   static if<OnTrue extends ResultAsyncConditional, OnFalse extends ResultAsyncConditional>(this: void, condition: ResultAsyncBooleanCondition, options: ResultAsyncIfOptions<OnTrue, OnFalse>): ResultAsyncIf<never, OnTrue, OnFalse>;
   static if<Condition extends ResultAsyncConditionResult, OnTrue extends ResultAsyncConditional, OnFalse extends ResultAsyncConditional>(this: void, condition: Condition, options: ResultAsyncIfOptions<OnTrue, OnFalse>): ResultAsyncIf<HandlerErr<Condition>, OnTrue, OnFalse>;
   /**
-  * Runs `body` only when the condition is true; otherwise returns Ok(undefined).
-  */
+   * Runs `body` only when the condition is true; otherwise returns Ok(undefined).
+   */
   static when<R extends ResultAsyncConditional>(this: void, condition: ResultAsyncBooleanCondition, body: () => R): ResultAsyncWhen<R>;
   /**
-  * Runs `body` only when a Resultar boolean condition is Ok(true).
-  */
+   * Runs `body` only when a Resultar boolean condition is Ok(true).
+   */
   static whenResult<Condition extends ResultAsyncConditionResult, R extends ResultAsyncConditional>(this: void, condition: Condition, body: () => R): ResultAsyncWhenWithCondition<Condition, R>;
   /**
-  * Runs `body` only when the condition is false; otherwise returns Ok(undefined).
-  */
+   * Runs `body` only when the condition is false; otherwise returns Ok(undefined).
+   */
   static unless<R extends ResultAsyncConditional>(this: void, condition: ResultAsyncBooleanCondition, body: () => R): ResultAsyncWhen<R>;
   /**
-  * Runs `body` only when a Resultar boolean condition is Ok(false).
-  */
+   * Runs `body` only when a Resultar boolean condition is Ok(false).
+   */
   static unlessResult<Condition extends ResultAsyncConditionResult, R extends ResultAsyncConditional>(this: void, condition: Condition, body: () => R): ResultAsyncWhenWithCondition<Condition, R>;
   /**
-  * Repeats a ResultAsync-producing body while a condition holds.
-  *
-  * Use `discard: true` when only failure matters and collected Ok values are not needed.
-  */
+   * Repeats a ResultAsync-producing body while a condition holds.
+   *
+   * Use `discard: true` when only failure matters and collected Ok values are not needed.
+   */
   static loop<State, BodyState extends State, R extends ResultAsync<unknown, unknown>>(this: void, initial: State, options: ResultAsyncLoopOptions<State, BodyState, R>): ResultAsyncLoopCollected<R>;
   static loop<State, R extends ResultAsync<unknown, unknown>>(this: void, initial: State, options: ResultAsyncLoopBooleanOptions<State, R>): ResultAsyncLoopCollected<R>;
   static loop<State, BodyState extends State, R extends ResultAsync<unknown, unknown>>(this: void, initial: State, options: ResultAsyncLoopDiscardOptions<State, BodyState, R>): ResultAsyncLoopDiscarded<R>;
   static loop<State, R extends ResultAsync<unknown, unknown>>(this: void, initial: State, options: ResultAsyncLoopBooleanDiscardOptions<State, R>): ResultAsyncLoopDiscarded<R>;
   /**
-  * Repeatedly transforms state with a ResultAsync-producing body until the condition fails.
-  */
+   * Repeatedly transforms state with a ResultAsync-producing body until the condition fails.
+   */
   static iterate<State, BodyState extends WidenLiteral<State>, R extends ResultAsync<WidenLiteral<State>, unknown>>(this: void, initial: State, options: ResultAsyncIterateOptions<WidenLiteral<State>, BodyState, R>): ResultAsyncIterated<WidenLiteral<State>, R>;
   static iterate<State, R extends ResultAsync<WidenLiteral<State>, unknown>>(this: void, initial: State, options: ResultAsyncIterateBooleanOptions<WidenLiteral<State>, R>): ResultAsyncIterated<WidenLiteral<State>, R>;
   /**
-  * Runs a ResultAsync-producing mapper for each item.
-  *
-  * Use `discard: true` when only failure matters and collected Ok values are not needed. Use
-  * `concurrency` to bound parallel work.
-  */
+   * Runs a ResultAsync-producing mapper for each item.
+   *
+   * Use `discard: true` when only failure matters and collected Ok values are not needed. Use
+   * `concurrency` to bound parallel work.
+   */
   static forEach<Item, R extends ResultAsync<unknown, unknown>>(this: void, items: Iterable<Item>, f: (value: Item, index: number) => R, options?: ResultAsyncForEachOptions): ResultAsyncForEachCollected<R>;
   static forEach<Item, R extends ResultAsync<unknown, unknown>>(this: void, items: Iterable<Item>, f: (value: Item, index: number) => R, options: ResultAsyncForEachDiscardOptions): ResultAsyncForEachDiscarded<R>;
   /**
-  * Wraps an async function so every later call returns a ResultAsync.
-  *
-  * Prefer `tryResultAsync` when you want to run the operation immediately.
-  */
+   * Wraps an async function so every later call returns a ResultAsync.
+   *
+   * Prefer `tryResultAsync` when you want to run the operation immediately.
+   */
   static fromThrowable<A extends readonly unknown[], T, E>(this: void, fn: (...args: A) => Promise<T>, errorFn?: (err: unknown) => E): (...args: A) => ResultAsync<T, E>;
   private readonly innerPromise;
   /**
-  * Creates a ResultAsync from a Promise that resolves to a Result.
-  *
-  * Most application code should prefer `tryResultAsync`, `fromPromise`, `okAsync`, or `errAsync`.
-  */
+   * Creates a ResultAsync from a Promise that resolves to a Result.
+   *
+   * Most application code should prefer `tryResultAsync`, `fromPromise`, `okAsync`, or `errAsync`.
+   */
   constructor(res: Promise<Result<T, E>>);
   /**
-  * PromiseLike integration. Resolves to the underlying `Result<T, E>`.
-  *
-  * Prefer ResultAsync combinators for application flow; this exists so ResultAsync can be awaited
-  * and used by Promise APIs.
-  */
+   * PromiseLike integration. Resolves to the underlying `Result<T, E>`.
+   *
+   * Prefer ResultAsync combinators for application flow; this exists so ResultAsync can be awaited
+   * and used by Promise APIs.
+   */
   then<A, B>(successCallback?: (res: Result<T, E>) => A | PromiseLike<A>, failureCallback?: (reason: unknown) => B | PromiseLike<B>): PromiseLike<A | B>;
   /**
-  * Maps the Err value while preserving the Ok value.
-  */
+   * Maps the Err value while preserving the Ok value.
+   */
   mapErr<U>(f: (t: E) => U | Promise<U>): ResultAsync<T, U>;
   /**
-  * Maps the Ok value while preserving the error channel.
-  */
+   * Maps the Ok value while preserving the error channel.
+   */
   map<X>(f: (t: T) => X | Promise<X>): ResultAsync<X, E>;
   /**
-  * Replaces the Ok value with a constant while preserving the error channel.
-  */
+   * Replaces the Ok value with a constant while preserving the error channel.
+   */
   as<X>(value: X): ResultAsync<X, E>;
   /**
-  * Keeps the Ok value only when the predicate passes; otherwise returns an Err from `onFalse`.
-  */
+   * Keeps the Ok value only when the predicate passes; otherwise returns an Err from `onFalse`.
+   */
   filterOrElse<U extends T, F>(predicate: (value: T) => value is U, onFalse: (value: T) => F | Promise<F>): ResultAsync<U, E | F>;
   filterOrElse<F>(predicate: (value: T) => boolean | Promise<boolean>, onFalse: (value: T) => F | Promise<F>): ResultAsync<T, E | F>;
   /**
-  * Chains another fallible sync or async operation from the Ok value.
-  *
-  * Use this instead of `map` when the callback returns `Result` or `ResultAsync`.
-  */
+   * Chains another fallible sync or async operation from the Ok value.
+   *
+   * Use this instead of `map` when the callback returns `Result` or `ResultAsync`.
+   */
   andThen<R extends Result<unknown, unknown>>(f: (t: T) => R): ResultAsync<InferOkTypes<R>, InferErrTypes<R> | E>;
   andThen<R extends ResultAsync<unknown, unknown>>(f: (t: T) => R): ResultAsync<InferAsyncOkTypes<R>, InferAsyncErrTypes<R> | E>;
   andThen<U, F>(f: (t: T) => Result<U, F> | ResultAsync<U, F>): ResultAsync<U, E | F>;
   /**
-  * Branches from the Ok value into one of two async fallible Result branches.
-  */
+   * Branches from the Ok value into one of two async fallible Result branches.
+   */
   if(fCondition: (t: T) => boolean): {
     true: <X1, Y1>(fTrue: (t: T) => ResultAsync<X1, Y1>) => {
       false: <X2, Y2>(fFalse: (t: T) => ResultAsync<X2, Y2>) => ResultAsync<X1 | X2, Y1 | Y2 | E>;
     };
   };
   /**
-  * Recovers from Err with another Result or ResultAsync.
-  */
+   * Recovers from Err with another Result or ResultAsync.
+   */
   orElse<R extends Result<unknown, unknown>>(f: (e: E) => R): ResultAsync<InferOkTypes<R> | T, InferErrTypes<R>>;
   orElse<R extends ResultAsync<unknown, unknown>>(f: (e: E) => R): ResultAsync<InferAsyncOkTypes<R> | T, InferAsyncErrTypes<R>>;
   orElse<U, A>(f: (e: E) => Result<U, A> | ResultAsync<U, A>): ResultAsync<U | T, A>;
   /**
-  * Recovers from a specific tagged error by `_tag`.
-  */
+   * Recovers from a specific tagged error by `_tag`.
+   */
   catchTag<const Tag extends TagsOf<E>, R extends Result<unknown, unknown>>(tag: Tag, f: (error: ErrorForTag$1<E, Tag>) => R): ResultAsync<T | InferOkTypes<R>, ExcludeTag<E, Tag> | InferErrTypes<R>>;
   catchTag<const Tag extends TagsOf<E>, R extends ResultAsync<unknown, unknown>>(tag: Tag, f: (error: ErrorForTag$1<E, Tag>) => R): ResultAsync<T | InferAsyncOkTypes<R>, ExcludeTag<E, Tag> | InferAsyncErrTypes<R>>;
   catchTag<U, F, const Tag extends TagsOf<E>>(tag: Tag, f: (error: ErrorForTag$1<E, Tag>) => Result<U, F> | ResultAsync<U, F>): ResultAsync<T | U, ExcludeTag<E, Tag> | F>;
   /**
-  * Recovers from multiple tagged errors by `_tag`.
-  */
+   * Recovers from multiple tagged errors by `_tag`.
+   */
   catchTags<const Handlers extends object>(handlers: Handlers & ResultAsyncCatchTagHandlers<E, Handlers>): ResultAsync<T | HandlerOk<CatchTagHandlerResult<Handlers>>, ExcludeTag<E, keyof Handlers & string> | HandlerErr<CatchTagHandlerResult<Handlers>>>;
   /**
-  * Recovers from a nested tagged `reason` on a specific tagged error.
-  */
+   * Recovers from a nested tagged `reason` on a specific tagged error.
+   */
   catchReason<const ErrorTag extends TagsWithReasonOf<E>, const ReasonTag extends ReasonTagsOf<E, ErrorTag>, R extends Result<unknown, unknown>>(errorTag: ErrorTag, reasonTag: ReasonTag, f: (reason: ReasonForTag<E, ErrorTag, ReasonTag>, error: ErrorForTag$1<E, ErrorTag>) => R): ResultAsync<T | InferOkTypes<R>, ExcludeReasonTag<E, ErrorTag, ReasonTag> | InferErrTypes<R>>;
   catchReason<const ErrorTag extends TagsWithReasonOf<E>, const ReasonTag extends ReasonTagsOf<E, ErrorTag>, R extends ResultAsync<unknown, unknown>>(errorTag: ErrorTag, reasonTag: ReasonTag, f: (reason: ReasonForTag<E, ErrorTag, ReasonTag>, error: ErrorForTag$1<E, ErrorTag>) => R): ResultAsync<T | InferAsyncOkTypes<R>, ExcludeReasonTag<E, ErrorTag, ReasonTag> | InferAsyncErrTypes<R>>;
   catchReason<U, F, const ErrorTag extends TagsWithReasonOf<E>, const ReasonTag extends ReasonTagsOf<E, ErrorTag>>(errorTag: ErrorTag, reasonTag: ReasonTag, f: (reason: ReasonForTag<E, ErrorTag, ReasonTag>, error: ErrorForTag$1<E, ErrorTag>) => Result<U, F> | ResultAsync<U, F>): ResultAsync<T | U, ExcludeReasonTag<E, ErrorTag, ReasonTag> | F>;
   /**
-  * Recovers from multiple nested tagged `reason` variants on a specific tagged error.
-  */
+   * Recovers from multiple nested tagged `reason` variants on a specific tagged error.
+   */
   catchReasons<const ErrorTag extends TagsWithReasonOf<E>, const Handlers extends object>(errorTag: ErrorTag, handlers: Handlers & ResultAsyncCatchReasonHandlers<E, ErrorTag, Handlers>): ResultAsync<T | HandlerOk<CatchReasonHandlerResult<Handlers>>, ExcludeReasonTag<E, ErrorTag, keyof Handlers & string> | HandlerErr<CatchReasonHandlerResult<Handlers>>>;
   /**
-  * Moves the nested `reason` of a tagged error into the ResultAsync error channel.
-  */
+   * Moves the nested `reason` of a tagged error into the ResultAsync error channel.
+   */
   unwrapReason<const ErrorTag extends TagsWithReasonOf<E>>(errorTag: ErrorTag): ResultAsync<T, ExcludeTag<E, ErrorTag> | ReasonsOf<E, ErrorTag>>;
   /**
-  * Converts this ResultAsync into a Promise of a plain value by handling both Ok and Err.
-  */
+   * Converts this ResultAsync into a Promise of a plain value by handling both Ok and Err.
+   */
   match<A, B = A>(handlers: MatchHandlers$1<T, E, A, B>): Promise<A | B>;
   match<A, B = A>(ok: (t: T) => A, fnErr: (e: E) => B): Promise<A | B>;
   /**
-  * Converts this ResultAsync into a Promise of a plain value with exhaustive tagged-error handlers.
-  */
+   * Converts this ResultAsync into a Promise of a plain value with exhaustive tagged-error handlers.
+   */
   matchTags<A, const Handlers extends object>(ok: (t: T) => A, handlers: Handlers & MatchTagHandlers<E, Handlers>): Promise<A | MatchTagHandlerResult<Handlers>>;
   /**
-  * Converts this ResultAsync into a Promise of a plain value with partial tagged-error handlers and
-  * a fallback.
-  */
+   * Converts this ResultAsync into a Promise of a plain value with partial tagged-error handlers and
+   * a fallback.
+   */
   matchTagsPartial<A, B, const Handlers extends object>(ok: (t: T) => A, handlers: Handlers & PartialMatchTagHandlers<E, Handlers>, fallback: (error: E) => B): Promise<A | MatchTagHandlerResult<Handlers> | B>;
   /**
-  * Resolves to the Ok value, or `t` when this ResultAsync is Err.
-  */
+   * Resolves to the Ok value, or `t` when this ResultAsync is Err.
+   */
   unwrapOr<A>(t: A): Promise<T | A>;
   /**
-  * Resolves to the Ok value or rejects with the Err value.
-  *
-  * Use this at final application boundaries after the error channel has been modeled.
-  */
+   * Resolves to the Ok value or rejects with the Err value.
+   *
+   * Use this at final application boundaries after the error channel has been modeled.
+   */
   unwrapOrThrow(): Promise<T>;
   /**
-  * Runs a side effect for either variant and preserves the original async result.
-  *
-  * For `Ok`, the callback receives `(value, undefined)`.
-  * For `Err`, the callback receives `(undefined, error)`.
-  * Callback errors and rejected callback promises are intentionally ignored.
-  *
-  * Use `map`, `mapErr`, `andThen`, or `orElse` when the callback should
-  * transform the result.
-  */
+   * Runs a side effect for either variant and preserves the original async result.
+   *
+   * For `Ok`, the callback receives `(value, undefined)`.
+   * For `Err`, the callback receives `(undefined, error)`.
+   * Callback errors and rejected callback promises are intentionally ignored.
+   *
+   * Use `map`, `mapErr`, `andThen`, or `orElse` when the callback should
+   * transform the result.
+   */
   log(f: (t?: T, e?: E) => void | Promise<void>): ResultAsync<T, E>;
   /**
-  * Runs a side effect only for the `Ok` variant and preserves the original async result.
-  *
-  * Callback errors and rejected callback promises are intentionally ignored.
-  * Use `map` or `andThen` when the callback should transform the value.
-  */
+   * Runs a side effect only for the `Ok` variant and preserves the original async result.
+   *
+   * Callback errors and rejected callback promises are intentionally ignored.
+   * Use `map` or `andThen` when the callback should transform the value.
+   */
   tap(f: (t: T) => void | Promise<void>): ResultAsync<T, E>;
   /**
-  * Runs a side effect only for the `Err` variant and preserves the original async result.
-  *
-  * Callback errors and rejected callback promises are intentionally ignored.
-  * Use `mapErr` or `orElse` when the callback should transform the error.
-  */
+   * Runs a side effect only for the `Err` variant and preserves the original async result.
+   *
+   * Callback errors and rejected callback promises are intentionally ignored.
+   * Use `mapErr` or `orElse` when the callback should transform the error.
+   */
   tapError(f: (e: E) => void | Promise<void>): ResultAsync<T, E>;
   /**
-  * Attaches an async disposal finalizer to this ResultAsync.
-  */
+   * Attaches an async disposal finalizer to this ResultAsync.
+   */
   toAsyncDisposable(f: ResultAsyncFinalizer<T, E>): DisposableResultAsync<T, E>;
   /**
-  * Enables `yield* resultAsync` inside async `safeTry` generators.
-  */
+   * Enables `yield* resultAsync` inside async `safeTry` generators.
+   */
   [Symbol.asyncIterator](): AsyncGenerator<Result<never, E>, T>;
 }
+/** `ResultAsync` convention that restricts the error channel to real `Error` instances. */
 type StrictResultAsync<T, E extends Error = Error> = ResultAsync<T, E>;
 /**
-* Creates an Ok ResultAsync.
-*/
+ * Creates an Ok ResultAsync.
+ */
 declare const okAsync: typeof ResultAsync.okAsync;
 /**
-* Creates an Err ResultAsync.
-*/
+ * Creates an Err ResultAsync.
+ */
 declare const errAsync: typeof ResultAsync.errAsync;
 /**
-* Adapts a callback or subscription API into a cancellable ResultAsync.
-*/
+ * Adapts a callback or subscription API into a cancellable ResultAsync.
+ */
 declare const fromCallback: typeof ResultAsync.fromCallback;
 /**
-* Converts an existing promise into a ResultAsync and maps rejection into a typed Err.
-*/
+ * Converts an existing promise into a ResultAsync and maps rejection into a typed Err.
+ */
 declare const fromPromise: typeof ResultAsync.fromPromise;
 /**
-* Converts an existing promise that is expected not to reject into a ResultAsync.
-*
-* Use `fromPromise` or `tryResultAsync` when rejection should become a typed Err.
-*/
+ * Converts an existing promise that is expected not to reject into a ResultAsync.
+ *
+ * Use `fromPromise` or `tryResultAsync` when rejection should become a typed Err.
+ */
 declare const fromSafePromise: typeof ResultAsync.fromSafePromise;
 /**
-* Creates an Ok ResultAsync with `undefined`.
-*/
+ * Creates an Ok ResultAsync with `undefined`.
+ */
 declare const unitAsync: typeof ResultAsync.unitAsync;
 /**
-* Wraps an async function so every later call returns a ResultAsync.
-*/
+ * Wraps an async function so every later call returns a ResultAsync.
+ */
 declare const fromThrowableAsync: typeof ResultAsync.fromThrowable;
 /**
-* Captures a promise or async factory into `ResultAsync<T, E>`.
-*
-* Use `tryResultAsync` at the edge of uncontrolled async code: network calls, file I/O,
-* third-party SDKs, JSON parsing promises, and framework APIs that can reject. The mapper receives
-* the rejected or thrown `unknown` cause and returns the typed error for the Resultar channel.
-*
-* Passing a factory is preferred when creating the promise can throw synchronously.
-*
-* @example
-* ```ts
-* const user = tryResultAsync(
-*   () => fetchUser(id),
-*   (cause) => new FetchUserError({ cause, id }),
-* )
-* ```
-*/
+ * Captures a promise or async factory into `ResultAsync<T, E>`.
+ *
+ * Use `tryResultAsync` at the edge of uncontrolled async code: network calls, file I/O,
+ * third-party SDKs, JSON parsing promises, and framework APIs that can reject. The mapper receives
+ * the rejected or thrown `unknown` cause and returns the typed error for the Resultar channel.
+ *
+ * Passing a factory is preferred when creating the promise can throw synchronously.
+ *
+ * @example
+ * ```ts
+ * const user = tryResultAsync(
+ *   () => fetchUser(id),
+ *   (cause) => new FetchUserError({ cause, id }),
+ * )
+ * ```
+ */
 declare function tryResultAsync<T, E>(fn: Promise<T> | (() => Promise<T>), errorFn: (e: unknown) => E): ResultAsync<T, E>;
 /**
-* Captures an async boundary with named `try` and `catch` fields.
-*
-* This is equivalent to `tryResultAsync(() => ..., toError)`, but it reads better for reusable
-* infrastructure helpers where the label, task, and mapper live together.
-*
-* @example
-* ```ts
-* const startup = tryResultAsync({
-*   try: () => fastify.register(plugin),
-*   catch: (cause) => new StartupTaskError({ cause, label: "register plugin" }),
-* })
-* ```
-*/
+ * Captures an async boundary with named `try` and `catch` fields.
+ *
+ * This is equivalent to `tryResultAsync(() => ..., toError)`, but it reads better for reusable
+ * infrastructure helpers where the label, task, and mapper live together.
+ *
+ * @example
+ * ```ts
+ * const startup = tryResultAsync({
+ *   try: () => fastify.register(plugin),
+ *   catch: (cause) => new StartupTaskError({ cause, label: "register plugin" }),
+ * })
+ * ```
+ */
 declare function tryResultAsync<T, E>(options: TryResultAsyncOptions<T, E> & {
   readonly catch: (e: unknown) => E;
 }): ResultAsync<T, E>;
 /**
-* Captures a promise or async factory into `ResultAsync<T, unknown>`.
-*
-* Prefer the overload with a catch mapper in application code so the error channel stays documented.
-* This overload is useful while adapting unknown external failures or during migration.
-*/
+ * Captures a promise or async factory into `ResultAsync<T, unknown>`.
+ *
+ * Prefer the overload with a catch mapper in application code so the error channel stays documented.
+ * This overload is useful while adapting unknown external failures or during migration.
+ */
 declare function tryResultAsync<T>(input: Promise<T> | (() => Promise<T>) | TryResultAsyncOptions<T>): ResultAsync<T, unknown>;
 /**
-* Runs a `ResultAsync` at an application boundary and returns the success value.
-*
-* If the result is `Err`, this rejects with the error. Use it at final framework, CLI, test, or
-* bootstrap boundaries after the error channel has already been modeled with Resultar.
-*/
+ * Runs a `ResultAsync` at an application boundary and returns the success value.
+ *
+ * If the result is `Err`, this rejects with the error. Use it at final framework, CLI, test, or
+ * bootstrap boundaries after the error channel has already been modeled with Resultar.
+ */
 declare const runPromise: <T, E>(result: ResultAsync<T, E>) => Promise<T>;
 /** Compatibility alias. Prefer `tryResultAsync` in new code. */
 declare const tryCatchAsync: typeof tryResultAsync;
@@ -1480,40 +1497,162 @@ type Writable<T> = T extends readonly unknown[] ? [...T] : T;
 //#endregion
 //#region src/redacted.d.ts
 /**
-* String-like wrapper that hides a sensitive value in messages and JSON output.
-*/
+ * String-like wrapper that hides a sensitive value in messages and JSON output.
+ */
 type Redacted<T> = string & {
   /**
-  * Internal marker used by `isRedacted`.
-  */
+   * Internal marker used by `isRedacted`.
+   */
   readonly __resultarRedacted: true;
   readonly __resultarRedactedType?: T;
   /**
-  * Optional label shown as `<redacted:label>`.
-  */
+   * Optional label shown as `<redacted:label>`.
+   */
   readonly label: string | undefined;
   /**
-  * Serializes to the redacted placeholder.
-  */
+   * Serializes to the redacted placeholder.
+   */
   toJSON: () => string;
   /**
-  * Converts to the redacted placeholder.
-  */
+   * Converts to the redacted placeholder.
+   */
   toString: () => string;
 };
 /**
-* Wraps a sensitive value so tagged-error messages and JSON output show only a placeholder.
-*/
+ * Wraps a sensitive value so tagged-error messages and JSON output show only a placeholder.
+ */
 declare const redact: <T>(value: T, label?: string) => Redacted<T>;
 /**
-* Checks whether a value was created by `redact`.
-*/
+ * Checks whether a value was created by `redact`.
+ */
 declare const isRedacted: (value: unknown) => value is Redacted<unknown>;
 /**
-* Returns the original sensitive value from a Redacted wrapper.
-*/
+ * Returns the original sensitive value from a Redacted wrapper.
+ */
 declare const revealRedacted: <T>(value: Redacted<T>) => T;
 //#endregion
+//#region src/result-task.d.ts
+/** A failure cause produced by a `ResultTask` execution. */
+type Cause<E> = {
+  readonly _tag: "Fail";
+  readonly error: E;
+} | {
+  readonly _tag: "Die";
+  readonly defect: unknown;
+};
+/** The complete outcome of a `ResultTask` execution. */
+type Exit<A, E> = {
+  readonly _tag: "Success";
+  readonly value: A;
+} | {
+  readonly _tag: "Failure";
+  readonly cause: Cause<E>;
+};
+/** A service that can be requested from a `ResultTask.gen` workflow. */
+interface ServiceTag<Identifier extends string, Service> {
+  readonly _tag: "ServiceTag";
+  readonly identifier: Identifier;
+  readonly key: symbol;
+  readonly [Symbol.iterator]: () => Generator<ResultTaskServiceYield<ServiceTag<Identifier, Service>>, Service, Service>;
+}
+/** Options for running a `ResultTask` with an optional signal and its required services. */
+type ResultTaskRunOptions<R = never> = {
+  readonly signal?: AbortSignal;
+} & ([R] extends [never] ? {
+  readonly services?: never;
+} : {
+  readonly services: ResultTaskServices<R>;
+});
+/** The object-shaped service environment required by a task. */
+type ResultTaskServices<R> = { readonly [Tag in Extract<R, AnyServiceTag> as Tag["identifier"]]: ServiceForTag<Tag>; };
+/** Options for creating a synchronous task with an explicit error boundary. */
+interface ResultTaskTryOptions<A, E> {
+  readonly try: () => A;
+  readonly catch: (cause: unknown) => E;
+}
+/** Options for creating a lazy promise-producing task with an explicit error boundary. */
+interface ResultTaskTryPromiseOptions<A, E> {
+  readonly try: (signal: AbortSignal) => PromiseLike<A>;
+  readonly catch: (cause: unknown) => E;
+}
+type AnyServiceTag = Pick<ServiceTag<string, unknown>, "_tag" | "identifier" | "key">;
+type ServiceForTag<Tag> = Tag extends ServiceTag<string, infer Service> ? Service : never;
+interface ResultTaskYield<A, E, R> {
+  readonly _tag: "ResultTask";
+  readonly task: ResultTask<A, E, R>;
+}
+interface ResultTaskServiceYield<Tag extends AnyServiceTag> {
+  readonly _tag: "Service";
+  readonly tag: Tag;
+}
+type GeneratorError<Yield> = Yield extends {
+  readonly _tag: "ResultTask";
+  readonly task: infer Task;
+} ? Task extends ResultTask<infer _A, infer E, infer _R> ? E : never : never;
+type GeneratorRequirements<Yield> = Yield extends {
+  readonly _tag: "ResultTask";
+  readonly task: infer Task;
+} ? Task extends ResultTask<infer _A, infer _E, infer R> ? R : never : Yield extends {
+  readonly _tag: "Service";
+  readonly tag: infer Tag;
+} ? Tag : never;
+type ResultTaskRunArguments<R> = [R] extends [never] ? [options?: ResultTaskRunOptions<R>] : [options: ResultTaskRunOptions<R>];
+/**
+ * A lazy, composable workflow that can succeed with `A` or fail with `E`.
+ *
+ * Constructing a `ResultTask` never runs its work. Use `runResult`, `runExit`, or `runPromise` at an
+ * explicit application boundary to execute it.
+ */
+declare class ResultTask<A, E = never, R = never> extends Pipeable {
+  private readonly execute;
+  private constructor();
+  private readonly typeWitness;
+  /** Creates a task that succeeds with `value` when it is executed. */
+  static succeed<A, E = never>(value: A): ResultTask<A, E>;
+  /** Creates a task that fails with `error` when it is executed. */
+  static fail<const E>(error: E): ResultTask<never, E>;
+  /** Lifts an already computed Result into a lazy task. */
+  static fromResult<A, E>(result: Result<A, E>): ResultTask<A, E>;
+  /** Creates a task for synchronous work. Thrown values are defects, not typed failures. */
+  static sync<A>(evaluate: () => A): ResultTask<A>;
+  /** Creates a task that maps synchronous throws into the typed error channel. */
+  static try<A, E>(options: ResultTaskTryOptions<A, E>): ResultTask<A, E>;
+  /** Creates a lazy task that maps synchronous throws and promise rejections into `E`. */
+  static tryPromise<A, E>(options: ResultTaskTryPromiseOptions<A, E>): ResultTask<A, E>;
+  /** Creates a service tag that can be requested with `yield*` inside `ResultTask.gen`. */
+  static service<Service, const Identifier extends string>(identifier: Identifier): ServiceTag<Identifier, Service>;
+  /** Builds a task from a generator and short-circuits on the first failed task. */
+  static gen<Yield, Return, Next>(body: () => Generator<Yield, Return, Next>): ResultTask<Return, GeneratorError<Yield>, GeneratorRequirements<Yield>>;
+  /** Maps the success value without executing the task. */
+  map<B>(f: (value: A) => B): ResultTask<B, E, R>;
+  /** Chains another task from the success value without executing either task immediately. */
+  flatMap<B, E2, R2>(f: (value: A) => ResultTask<B, E2, R2>): ResultTask<B, E | E2, R | R2>;
+  /** Alias for `flatMap`, matching the existing Resultar vocabulary. */
+  andThen<B, E2, R2>(f: (value: A) => ResultTask<B, E2, R2>): ResultTask<B, E | E2, R | R2>;
+  /** Recovers from a typed failure without recovering from a runtime defect. */
+  catchAll<B, E2, R2>(f: (error: E) => ResultTask<B, E2, R2>): ResultTask<A | B, E2, R | R2>;
+  /** Enables `yield* task` inside `ResultTask.gen` workflows. */
+  [Symbol.iterator](): Generator<ResultTaskYield<A, E, R>, A, Exit<A, E>>;
+  /** Provides one required service and removes it from the task's requirements. */
+  static provideService<A, E, R, Tag extends Extract<R, AnyServiceTag>>(task: ResultTask<A, E, R>, tag: Tag, service: ServiceForTag<Tag>): ResultTask<A, E, Exclude<R, Tag>>;
+  /** Provides all requirements using an object keyed by service identifier. */
+  static provideServices<A, E, R>(task: ResultTask<A, E, R>, services: ResultTaskServices<R>): ResultTask<A, E>;
+  /** Maps the success value using the canonical functional form. */
+  static map<A, E, R, B>(task: ResultTask<A, E, R>, f: (value: A) => B): ResultTask<B, E, R>;
+  /** Chains a task using the canonical functional form. */
+  static flatMap<A, E, R, B, E2, R2>(task: ResultTask<A, E, R>, f: (value: A) => ResultTask<B, E2, R2>): ResultTask<B, E | E2, R | R2>;
+  /** Recovers from a typed failure using the canonical functional form. */
+  static catchAll<A, E, R, B, E2, R2>(task: ResultTask<A, E, R>, f: (error: E) => ResultTask<B, E2, R2>): ResultTask<A | B, E2, R | R2>;
+  private static runExitInternal;
+  private static runResultInternal;
+  /** Runs a task and preserves success, typed failure, and runtime defects in an `Exit`. */
+  static runExit<A, E, R>(task: ResultTask<A, E, R>, ...args: ResultTaskRunArguments<R>): Promise<Exit<A, E>>;
+  /** Runs a task and returns a Result, rejecting only when a runtime defect occurs. */
+  static runResult<A, E, R>(task: ResultTask<A, E, R>, ...args: ResultTaskRunArguments<R>): Promise<Result<A, E>>;
+  /** Runs a task and returns the success value, rejecting on typed failures or defects. */
+  static runPromise<A, E, R>(task: ResultTask<A, E, R>, ...args: ResultTaskRunArguments<R>): Promise<A>;
+}
+//#endregion
 //#region src/tagged-error.d.ts
 type Alpha = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z" | "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z" | "_";
 type Digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
@@ -1542,85 +1681,86 @@ type ConstructorProps<Template extends string> = TemplateProps<Template> & {
 type TaggedErrorConstructorArgs<Template extends string> = [ExtractTemplateVariables<Template>] extends [never] ? [props?: {
   readonly cause?: unknown;
 }] : [props: ConstructorProps<Template>];
+/** Configuration used to create a tagged `Error` class. */
 interface TaggedErrorOptions<Tag extends string, MessageTemplate extends string, Base extends Error = Error> {
   /**
-  * Optional base Error class to extend instead of native Error.
-  */
+   * Optional base Error class to extend instead of native Error.
+   */
   readonly extends?: ErrorBaseConstructor<Base>;
   /**
-  * Message template. `$prop` placeholders are filled from constructor props.
-  */
+   * Message template. `$prop` placeholders are filled from constructor props.
+   */
   readonly message?: MessageTemplate;
   /**
-  * Stable runtime tag and Error name.
-  */
+   * Stable runtime tag and Error name.
+   */
   readonly name: Tag;
 }
 /**
-* Instance type produced by `createTaggedError`.
-*/
+ * Instance type produced by `createTaggedError`.
+ */
 type TaggedErrorInstance<Tag extends string, MessageTemplate extends string, Base extends Error = Error> = Base & Readonly<TemplateProps<MessageTemplate>> & {
   /**
-  * Stable runtime tag.
-  */
+   * Stable runtime tag.
+   */
   readonly _tag: Tag;
   /**
-  * Stable identity for grouping errors by tag and message template.
-  */
+   * Stable identity for grouping errors by tag and message template.
+   */
   readonly fingerprint: readonly [Tag, MessageTemplate];
   /**
-  * Original message template before interpolation.
-  */
+   * Original message template before interpolation.
+   */
   readonly messageTemplate: MessageTemplate;
   /**
-  * Finds a matching cause in the error cause chain.
-  */
+   * Finds a matching cause in the error cause chain.
+   */
   findCause: <T extends Error>(ErrorClass: ErrorClass<T>) => T | undefined;
   /**
-  * Serializes the tagged error, metadata, and cause chain.
-  */
+   * Serializes the tagged error, metadata, and cause chain.
+   */
   toJSON: () => object;
 };
 /**
-* Class type returned by `createTaggedError`.
-*/
+ * Class type returned by `createTaggedError`.
+ */
 type TaggedErrorClass<Tag extends string, MessageTemplate extends string, Base extends Error = Error> = {
   new (...args: TaggedErrorConstructorArgs<MessageTemplate>): TaggedErrorInstance<Tag, MessageTemplate, Base>;
   /**
-  * Stable runtime tag.
-  */
+   * Stable runtime tag.
+   */
   readonly tag: Tag;
   /**
-  * Creates an Err containing this tagged error.
-  */
+   * Creates an Err containing this tagged error.
+   */
   err: <This extends new (...args: TaggedErrorConstructorArgs<MessageTemplate>) => Error>(this: This, ...args: TaggedErrorConstructorArgs<MessageTemplate>) => ErrResult<never, ErrorClassInstance<This>>;
   /**
-  * Narrows a value to this tagged error class.
-  */
+   * Narrows a value to this tagged error class.
+   */
   is: (value: unknown) => value is TaggedErrorInstance<Tag, MessageTemplate, Base>;
 };
 /**
-* Union of members produced by `taggedEnum`.
-*/
+ * Union of members produced by `taggedEnum`.
+ */
 type TaggedEnum<Members extends Record<string, object>> = { readonly [Tag in keyof Members]: Readonly<Members[Tag]> & {
   readonly _tag: Tag;
-} }[keyof Members];
+}; }[keyof Members];
 type TaggedEnumMember<Members extends Record<string, object>, Tag extends keyof Members> = Readonly<Members[Tag]> & {
   readonly _tag: Tag;
 };
 type TaggedEnumConstructor<Members extends Record<string, object>, Tag extends keyof Members> = keyof Members[Tag] extends never ? (props?: Readonly<Members[Tag]>) => TaggedEnumMember<Members, Tag> : (props: Readonly<Members[Tag]>) => TaggedEnumMember<Members, Tag>;
 /**
-* Factory returned by `taggedEnum`.
-*/
-type TaggedEnumFactory<Members extends Record<string, object>> = { readonly [Tag in keyof Members]: TaggedEnumConstructor<Members, Tag> } & {
+ * Factory returned by `taggedEnum`.
+ */
+type TaggedEnumFactory<Members extends Record<string, object>> = { readonly [Tag in keyof Members]: TaggedEnumConstructor<Members, Tag>; } & {
   /**
-  * Narrows a value to a tagged enum member.
-  */
+   * Narrows a value to a tagged enum member.
+   */
   $is: <Tag extends keyof Members>(tag: Tag, value: unknown) => value is TaggedEnumMember<Members, Tag>;
   /**
-  * Exhaustively matches a tagged enum value.
-  */
-  $match: <ReturnType>(value: TaggedEnum<Members>, handlers: { readonly [Tag in keyof Members]: (value: TaggedEnumMember<Members, Tag>) => ReturnType }) => ReturnType;
+   * Exhaustively matches a tagged enum value.
+   */
+  $match: <ReturnType>(value: TaggedEnum<Members>, handlers: { readonly [Tag in keyof Members]: (value: TaggedEnumMember<Members, Tag>) => ReturnType; }) => ReturnType;
 };
 type TaggedErrorLike = Error & {
   readonly _tag: string;
@@ -1630,7 +1770,7 @@ type ErrorForTag<ErrorType extends Error, Tag extends string> = Extract<ErrorTyp
   readonly _tag: Tag;
 }>;
 type UntaggedError<ErrorType extends Error> = Exclude<ErrorType, TaggedErrorLike>;
-type MatchHandlers<ErrorType extends Error, ReturnType> = { readonly [Tag in TaggedErrorTags<ErrorType>]: (error: ErrorForTag<ErrorType, Tag>) => ReturnType } & ([UntaggedError<ErrorType>] extends [never] ? {
+type MatchHandlers<ErrorType extends Error, ReturnType> = { readonly [Tag in TaggedErrorTags<ErrorType>]: (error: ErrorForTag<ErrorType, Tag>) => ReturnType; } & ([UntaggedError<ErrorType>] extends [never] ? {
   readonly Error?: (error: Error) => ReturnType;
 } : {
   readonly Error: (error: UntaggedError<ErrorType>) => ReturnType;
@@ -1638,43 +1778,43 @@ type MatchHandlers<ErrorType extends Error, ReturnType> = { readonly [Tag in Tag
 type PartialMatchHandlers<ErrorType extends Error, ReturnType> = Partial<MatchHandlers<ErrorType, ReturnType>>;
 declare const defaultMessageTemplate = "$message";
 /**
-* Narrows a value to native or platform-recognized Error.
-*/
+ * Narrows a value to native or platform-recognized Error.
+ */
 declare function isError(value: unknown): value is Error;
 declare function isError<Value>(value: Value): value is Extract<Value, Error>;
 /**
-* Finds the first cause in an Error cause chain that is an instance of `ErrorClass`.
-*/
+ * Finds the first cause in an Error cause chain that is an instance of `ErrorClass`.
+ */
 declare const findCause: <T extends Error>(error: Error, ErrorClass: ErrorClass<T>) => T | undefined;
 /**
-* Creates an Error class with a stable `_tag`, typed template props, cause support, and JSON output.
-*
-* Prefer tagged errors for domain failures that travel through Resultar error channels.
-*
-* @example
-* ```ts
-* class UserNotFoundError extends createTaggedError({
-*   name: "UserNotFoundError",
-*   message: "User $id was not found",
-* }) {}
-* ```
-*/
+ * Creates an Error class with a stable `_tag`, typed template props, cause support, and JSON output.
+ *
+ * Prefer tagged errors for domain failures that travel through Resultar error channels.
+ *
+ * @example
+ * ```ts
+ * class UserNotFoundError extends createTaggedError({
+ *   name: "UserNotFoundError",
+ *   message: "User $id was not found",
+ * }) {}
+ * ```
+ */
 declare function createTaggedError<const Tag extends string, const MessageTemplate extends string = typeof defaultMessageTemplate, Base extends Error = Error>(options: Omit<TaggedErrorOptions<Tag, MessageTemplate, Base>, "message"> & {
   readonly message?: RejectReservedTemplateVariables<MessageTemplate>;
 }): TaggedErrorClass<Tag, MessageTemplate, Base>;
 /**
-* Creates a small tagged-union factory with member constructors, `$is`, and `$match`.
-*/
+ * Creates a small tagged-union factory with member constructors, `$is`, and `$match`.
+ */
 declare const taggedEnum: <Members extends Record<string, object>>() => TaggedEnumFactory<Members>;
 /**
-* Matches an Error by tagged `_tag`, with optional native `Error` fallback.
-*
-* Throws the original error when no handler matches.
-*/
+ * Matches an Error by tagged `_tag`, with optional native `Error` fallback.
+ *
+ * Throws the original error when no handler matches.
+ */
 declare const matchError: <ErrorType extends Error, ReturnType>(error: ErrorType, handlers: MatchHandlers<ErrorType, ReturnType>) => ReturnType;
 /**
-* Matches an Error by tagged `_tag`, then native `Error`, then the provided fallback.
-*/
+ * Matches an Error by tagged `_tag`, then native `Error`, then the provided fallback.
+ */
 declare const matchErrorPartial: <ErrorType extends Error, ReturnType>(error: ErrorType, handlers: PartialMatchHandlers<ErrorType, ReturnType>, fallback: (error: ErrorType) => ReturnType) => ReturnType;
 //#endregion
-export { AbortError, DisposableResult, DisposableResultAsync, type ErrResult, type OkResult, type Redacted, Result, ResultAsync, type ResultAsyncAbortSignal, type ResultAsyncCallbackCleanup, type ResultAsyncCallbackContext, type ResultAsyncConcurrency, type ResultAsyncFromCallbackOptions, type ResultAsyncRaceHandle, type ResultAsyncRaceTask, type ResultAsyncResourceAcquire, type ResultAsyncResourceEffect, type ResultAsyncResourceRelease, type ResultAsyncResourceReleaseContext, type ResultAsyncResourceUse, type ResultAsyncRetryContext, type ResultAsyncRetryOptions, type ResultAsyncRetryOrElseOptions, type ResultAsyncRetryTask, type ResultAsyncTimeoutOptions, type ResultAsyncWithResourceOptions, type ResultOperations, type SafeTryAsyncOptions, type SafeTryOptions, type StrictResult, type StrictResultAsync, type TaggedEnum, type TaggedEnumFactory, type TaggedErrorClass, type TaggedErrorInstance, type TaggedErrorOptions, type TryResultAsyncOptions, type TryResultOptions, createTaggedError, tryResult as default, tryResult as try, tryResult, err, errAsync, findCause, fromCallback, fromPromise, fromSafePromise, fromThrowable, fromThrowableAsync, isAbortError, isError, isRedacted, matchError, matchErrorPartial, ok, okAsync, redact, revealRedacted, runPromise, runSync, safeTry, taggedEnum, tryResultAsync as tryAsync, tryResultAsync, tryCatch, tryCatchAsync, unit, unitAsync };
+export { AbortError, type Cause, DisposableResult, DisposableResultAsync, type ErrResult, type Exit, type OkResult, type Redacted, Result, ResultAsync, type ResultAsyncAbortSignal, type ResultAsyncCallbackCleanup, type ResultAsyncCallbackContext, type ResultAsyncConcurrency, type ResultAsyncFromCallbackOptions, type ResultAsyncRaceHandle, type ResultAsyncRaceTask, type ResultAsyncResourceAcquire, type ResultAsyncResourceEffect, type ResultAsyncResourceRelease, type ResultAsyncResourceReleaseContext, type ResultAsyncResourceUse, type ResultAsyncRetryContext, type ResultAsyncRetryOptions, type ResultAsyncRetryOrElseOptions, type ResultAsyncRetryTask, type ResultAsyncTimeoutOptions, type ResultAsyncWithResourceOptions, type ResultOperations, ResultTask, type ResultTaskRunOptions, type ResultTaskServices, type ResultTaskTryOptions, type ResultTaskTryPromiseOptions, type SafeTryAsyncOptions, type SafeTryOptions, type ServiceTag, type StrictResult, type StrictResultAsync, type TaggedEnum, type TaggedEnumFactory, type TaggedErrorClass, type TaggedErrorInstance, type TaggedErrorOptions, type TryResultAsyncOptions, type TryResultOptions, createTaggedError, tryResult as default, tryResult as try, tryResult, err, errAsync, findCause, fromCallback, fromPromise, fromSafePromise, fromThrowable, fromThrowableAsync, isAbortError, isError, isRedacted, matchError, matchErrorPartial, ok, okAsync, redact, revealRedacted, runPromise, runSync, safeTry, taggedEnum, tryResultAsync as tryAsync, tryResultAsync, tryCatch, tryCatchAsync, unit, unitAsync };