resultar 3.7.0 → 3.8.0

package/dist/index.d.ts

@@ -365,7 +365,7 @@ interface ErrResult<T, E> extends ResultOperations<T, E> {
   readonly error: E;
 }
 /** Success-or-failure value with explicit Ok and Err channels. */
-type Result<T, E> = OkResult<T, E> | ErrResult<T, E>;
+export 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>;
 /**
@@ -541,12 +541,12 @@ interface ResultStatic {
   };
 }
 /** Static helpers for creating, combining, and iterating over Result values. */
-declare const Result: ResultStatic;
+export declare const Result: ResultStatic;
 /**
  * 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 {
+export declare class DisposableResult<T, E> implements Resultable<T, E>, Disposable {
   private disposed;
   private readonly finalizer;
   /**
@@ -598,14 +598,14 @@ declare class DisposableResult<T, E> implements Resultable<T, E>, Disposable {
  * 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> & {
+export 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>;
-declare function safeTry<T, E>(input: (() => Generator<Result<never, E>, Result<T, E>>) | SafeTryOptions<Result<never, E>, Result<T, E>>): Result<T, E>;
-declare function safeTry<YieldErr extends Result<never, unknown>, GeneratorReturnResult extends Result<unknown, unknown>, CatchErr>(input: SafeTryOptions<YieldErr, GeneratorReturnResult, CatchErr> & {
+export declare function safeTry<T, E>(input: (() => Generator<Result<never, E>, Result<T, E>>) | SafeTryOptions<Result<never, E>, Result<T, E>>): Result<T, E>;
+export declare function safeTry<YieldErr extends Result<never, unknown>, GeneratorReturnResult extends Result<unknown, unknown>, CatchErr>(input: SafeTryOptions<YieldErr, GeneratorReturnResult, CatchErr> & {
   readonly catch: (e: unknown) => CatchErr;
 }): 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>>;
+export 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.
@@ -614,31 +614,31 @@ declare function safeTry<YieldErr extends Result<never, unknown>, GeneratorRetur
  * 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> & {
+export 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>;
-declare function safeTry<T, E>(input: (() => AsyncGenerator<Result<never, E>, Result<T, E>>) | SafeTryAsyncOptions<Result<never, E>, Result<T, E>>): ResultAsync<T, E>;
-declare function safeTry<YieldErr extends Result<never, unknown>, GeneratorReturnResult extends Result<unknown, unknown>, CatchErr>(input: SafeTryAsyncOptions<YieldErr, GeneratorReturnResult, CatchErr> & {
+export declare function safeTry<T, E>(input: (() => AsyncGenerator<Result<never, E>, Result<T, E>>) | SafeTryAsyncOptions<Result<never, E>, Result<T, E>>): ResultAsync<T, E>;
+export declare function safeTry<YieldErr extends Result<never, unknown>, GeneratorReturnResult extends Result<unknown, unknown>, CatchErr>(input: SafeTryAsyncOptions<YieldErr, GeneratorReturnResult, CatchErr> & {
   readonly catch: (e: unknown) => CatchErr;
 }): 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>>;
+export 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.
  */
-declare function ok<T, E = never>(value: T): OkResult<T, E>;
-declare function ok<E = never>(value: void): OkResult<void, E>;
+export declare function ok<T, E = never>(value: T): OkResult<T, E>;
+export declare function ok<E = never>(value: void): OkResult<void, E>;
 /**
  * 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>;
+export declare function err<T = never, E extends string = string>(err: E): ErrResult<T, E>;
+export declare function err<T = never, E = unknown>(err: E): ErrResult<T, E>;
+export 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.
  */
-declare const fromThrowable: typeof Result.fromThrowable;
+export declare const fromThrowable: typeof Result.fromThrowable;
 /**
  * Runs synchronous work and captures thrown values into `Result<T, E>`.
  *
@@ -654,14 +654,14 @@ declare const fromThrowable: typeof Result.fromThrowable;
  * )
  * ```
  */
-declare function tryResult<T, E>(fn: () => Exclude<T, Promise<unknown>>, errorFn: (e: unknown) => E): Result<T, E>;
+export 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.
  */
-declare function tryResult<T, E>(options: TryResultOptions<T, E> & {
+export declare function tryResult<T, E>(options: TryResultOptions<T, E> & {
   readonly catch: (e: unknown) => E;
 }): Result<T, E>;
 /**
@@ -670,20 +670,20 @@ declare function tryResult<T, E>(options: TryResultOptions<T, E> & {
  * 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>;
+export declare function tryResult<T>(input: (() => Exclude<T, Promise<unknown>>) | TryResultOptions<T>): Result<T, unknown>;
 /**
  * Creates an Ok result with `undefined`.
  */
-declare function unit<E = never>(): OkResult<undefined, E>;
+export 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.
  */
-declare const runSync: <T, E>(result: Result<T, E>) => T;
+export declare const runSync: <T, E>(result: Result<T, E>) => T;
 /** Compatibility alias. Prefer `tryResult` in new code. */
-declare const tryCatch: typeof tryResult;
+export declare const tryCatch: typeof tryResult;
 type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, ...0[]];
 type CollectResults<T, Collected extends unknown[] = [], Depth extends number = 50> = [Depth] extends [never] ? [] : T extends [infer H, ...infer Rest] ? H extends Result<infer L, infer R> ? CollectResults<Rest, [...Collected, [L, R]], Prev[Depth]> : never : Collected;
 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;
@@ -705,7 +705,7 @@ type CombineResultsWithAllErrorsArray<T extends readonly Result<unknown, unknown
 /**
  * Standard cancellation error used by ResultAsync retry, race, timeout, and resource helpers.
  */
-declare class AbortError extends Error {
+export declare class AbortError extends Error {
   /**
    * Creates an AbortError.
    */
@@ -714,7 +714,7 @@ declare class AbortError extends Error {
 /**
  * Checks whether a value is an AbortError or abort-shaped platform error.
  */
-declare const isAbortError: (value: unknown) => value is AbortError;
+export declare const isAbortError: (value: unknown) => value is AbortError;
 //#endregion
 //#region src/result-task.d.ts
 /** A failure cause produced by a `ResultTask` execution. */
@@ -733,18 +733,18 @@ type Cause<E> = {
   readonly right: Cause<E>;
 };
 /** Rejection used when a simplified boundary cannot represent multiple failures. */
-declare class ResultTaskCauseError extends Error {
+export declare class ResultTaskCauseError extends Error {
   override readonly cause: Cause<unknown>;
   constructor(cause: Cause<unknown>);
 }
 /** Type identifier symbol for nominal `ResultTask` branding and variance checks. */
-declare const ResultTaskTypeId: unique symbol;
+export declare const ResultTaskTypeId: unique symbol;
 /** Type identifier symbol for nominal `ServiceTag` branding. */
-declare const ServiceTagTypeId: unique symbol;
+export declare const ServiceTagTypeId: unique symbol;
 /** Type identifier symbol for nominal `ResultTask` yieldable objects. */
-declare const ResultTaskYieldTypeId: unique symbol;
+export declare const ResultTaskYieldTypeId: unique symbol;
 /** Error thrown as a Die cause when a requested service is not provided in the environment. */
-declare class MissingServiceError extends Error {
+export declare class MissingServiceError extends Error {
   readonly serviceIdentifier: string;
   constructor(serviceIdentifier: string);
 }
@@ -796,6 +796,8 @@ type IncompatibleResolvedServices<R, Resolvers> = R extends AnyServiceTag ? R["i
 /** Owns resources across executions. Close it after its consumers have finished. */
 interface ResultTaskScopeOwner {
   readonly use: <A, E, R>(task: ResultTask<A, E, R>) => ResultTask<A, E, R>;
+  /** Registers an already-acquired resource's release synchronously, in registration order. */
+  readonly addFinalizer: (release: (exit: Exit<unknown, unknown>) => ResultTask<void, unknown>) => void;
   readonly close: (exit?: Exit<unknown, unknown>) => ResultTask<void, unknown>;
 }
 /** Options for running a `ResultTask` with an optional signal and its required services. */
@@ -847,35 +849,30 @@ type GeneratorRequirements<Yield> = Yield extends {
 } ? Tag : never;
 type ResultTaskRunArguments<R> = [WithoutScope<R>] extends [never] ? [options?: ResultTaskRunOptions<R>] : [options: ResultTaskRunOptions<R>];
 /** Returns true if a value is a nominal `ServiceTag`. */
-declare const isServiceTag: (value: unknown) => value is ServiceTag<string, unknown>;
+export declare const isServiceTag: (value: unknown) => value is ServiceTag<string, unknown>;
 /** Returns true if a value is a `ResultTask` instance. */
-declare const isResultTask: (value: unknown) => value is ResultTask<unknown, unknown, unknown>;
+export declare const isResultTask: (value: unknown) => value is ResultTask<unknown, unknown, unknown>;
 /** Creates a service tag that can be requested with `yield*` inside `ResultTask.gen`. */
-declare const serviceTag: <Service, const Identifier extends string = string>(identifier: Identifier) => ServiceTag<Identifier, Service>;
-interface ContinuationStep {
-  readonly current: ResultTask<unknown, unknown, unknown> | undefined;
-  readonly currentExit: Exit<unknown, unknown> | undefined;
-}
+export declare const serviceTag: <Service, const Identifier extends string = string>(identifier: Identifier) => ServiceTag<Identifier, Service>;
 /**
  * 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.
  */
-interface ResultTask<out A, out E = never, out R = never> {
+export interface ResultTask<out A, out E = never, out R = never> {
   readonly [ResultTaskTypeId]: {
     readonly success: (_: never) => A;
     readonly error: (_: never) => E;
     readonly requirements: (_: never) => R;
   };
 }
-declare class ResultTask<out A, out E = never, out R = never> extends Pipeable {
+export declare class ResultTask<out A, out E = never, out R = never> extends Pipeable {
+  #private;
   private readonly typeWitness;
   private readonly instruction;
   private readonly execute;
   private constructor();
-  /** @internal */
-  static toTapContinuationStep(res: unknown, onSuccess: () => ResultTask<unknown, unknown, unknown>, passThroughExit: Exit<unknown, unknown>): ContinuationStep;
   private static runTaskLoop;
   /** Creates a task that succeeds with `value` when it is executed. */
   static succeed<A>(value: A): ResultTask<A, never>;
@@ -1315,7 +1312,7 @@ interface ResultAsyncIfOptions<OnTrue extends ResultAsyncConditional, OnFalse ex
   readonly onTrue: () => OnTrue;
 }
 /** Async-disposable wrapper that finalizes a `ResultAsync` exactly once. */
-declare class DisposableResultAsync<T, E> implements PromiseLike<Result<T, E>>, AsyncDisposable {
+export declare class DisposableResultAsync<T, E> implements PromiseLike<Result<T, E>>, AsyncDisposable {
   private readonly innerPromise;
   private readonly finalizer;
   private disposed;
@@ -1372,7 +1369,7 @@ declare class DisposableResultAsync<T, E> implements PromiseLike<Result<T, E>>,
  * - Conditional branching (if)
  * - Combining multiple ResultAsync instances (combine, combineWithAllErrors)
  */
-declare class ResultAsync<T, E> extends Pipeable implements PromiseLike<Result<T, E>> {
+export 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).
    *
@@ -1706,33 +1703,33 @@ type StrictResultAsync<T, E extends Error = Error> = ResultAsync<T, E>;
 /**
  * Creates an Ok ResultAsync.
  */
-declare const okAsync: typeof ResultAsync.okAsync;
+export declare const okAsync: typeof ResultAsync.okAsync;
 /**
  * Creates an Err ResultAsync.
  */
-declare const errAsync: typeof ResultAsync.errAsync;
+export declare const errAsync: typeof ResultAsync.errAsync;
 /**
  * Adapts a callback or subscription API into a cancellable ResultAsync.
  */
-declare const fromCallback: typeof ResultAsync.fromCallback;
+export declare const fromCallback: typeof ResultAsync.fromCallback;
 /**
  * Converts an existing promise into a ResultAsync and maps rejection into a typed Err.
  */
-declare const fromPromise: typeof ResultAsync.fromPromise;
+export 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.
  */
-declare const fromSafePromise: typeof ResultAsync.fromSafePromise;
+export declare const fromSafePromise: typeof ResultAsync.fromSafePromise;
 /**
  * Creates an Ok ResultAsync with `undefined`.
  */
-declare const unitAsync: typeof ResultAsync.unitAsync;
+export declare const unitAsync: typeof ResultAsync.unitAsync;
 /**
  * Wraps an async function so every later call returns a ResultAsync.
  */
-declare const fromThrowableAsync: typeof ResultAsync.fromThrowable;
+export declare const fromThrowableAsync: typeof ResultAsync.fromThrowable;
 /**
  * Captures a promise or async factory into `ResultAsync<T, E>`.
  *
@@ -1750,7 +1747,7 @@ declare const fromThrowableAsync: typeof ResultAsync.fromThrowable;
  * )
  * ```
  */
-declare function tryResultAsync<T, E>(fn: Promise<T> | (() => Promise<T>), errorFn: (e: unknown) => E): ResultAsync<T, E>;
+export 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.
  *
@@ -1765,7 +1762,7 @@ declare function tryResultAsync<T, E>(fn: Promise<T> | (() => Promise<T>), error
  * })
  * ```
  */
-declare function tryResultAsync<T, E>(options: TryResultAsyncOptions<T, E> & {
+export declare function tryResultAsync<T, E>(options: TryResultAsyncOptions<T, E> & {
   readonly catch: (e: unknown) => E;
 }): ResultAsync<T, E>;
 /**
@@ -1774,16 +1771,16 @@ declare function tryResultAsync<T, E>(options: TryResultAsyncOptions<T, E> & {
  * 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>;
+export 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.
  */
-declare const runPromise: <T, E>(result: ResultAsync<T, E>) => Promise<T>;
+export declare const runPromise: <T, E>(result: ResultAsync<T, E>) => Promise<T>;
 /** Compatibility alias. Prefer `tryResultAsync` in new code. */
-declare const tryCatchAsync: typeof tryResultAsync;
+export declare const tryCatchAsync: typeof tryResultAsync;
 type CombineResultAsyncs<T extends readonly ResultAsync<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? TraverseAsync<UnwrapAsync<T>> : ResultAsync<ExtractOkAsyncTypes<T>, ExtractErrAsyncTypes<T>[number]>;
 type CombineResultsWithAllErrorsArrayAsync<T extends readonly ResultAsync<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? TraverseWithAllErrorsAsync<UnwrapAsync<T>> : ResultAsync<ExtractOkAsyncTypes<T>, ExtractErrAsyncTypes<T>[number][]>;
 type UnwrapAsync<T> = IsLiteralArray<T> extends 1 ? Writable<T> extends [infer H, ...infer Rest] ? H extends PromiseLike<infer HI> ? HI extends Result<unknown, unknown> ? [Dedup<HI>, ...UnwrapAsync<Rest>] : never : never : [] : T extends (infer A)[] ? A extends PromiseLike<infer HI> ? HI extends Result<infer L, infer R> ? Result<L, R>[] : never : never : never;
@@ -1817,15 +1814,15 @@ type Redacted<T> = string & {
 /**
  * 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>;
+export declare const redact: <T>(value: T, label?: string) => Redacted<T>;
 /**
  * Checks whether a value was created by `redact`.
  */
-declare const isRedacted: (value: unknown) => value is Redacted<unknown>;
+export declare const isRedacted: (value: unknown) => value is Redacted<unknown>;
 /**
  * Returns the original sensitive value from a Redacted wrapper.
  */
-declare const revealRedacted: <T>(value: Redacted<T>) => T;
+export declare const revealRedacted: <T>(value: Redacted<T>) => T;
 //#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" | "_";
@@ -1954,12 +1951,12 @@ declare const defaultMessageTemplate = "$message";
 /**
  * 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>;
+export declare function isError(value: unknown): value is Error;
+export 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`.
  */
-declare const findCause: <T extends Error>(error: Error, ErrorClass: ErrorClass<T>) => T | undefined;
+export 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.
  *
@@ -1973,22 +1970,22 @@ declare const findCause: <T extends Error>(error: Error, ErrorClass: ErrorClass<
  * }) {}
  * ```
  */
-declare function createTaggedError<const Tag extends string, const MessageTemplate extends string = typeof defaultMessageTemplate, Base extends Error = Error>(options: Omit<TaggedErrorOptions<Tag, MessageTemplate, Base>, "message"> & {
+export 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`.
  */
-declare const taggedEnum: <Members extends Record<string, object>>() => TaggedEnumFactory<Members>;
+export 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.
  */
-declare const matchError: <ErrorType extends Error, ReturnType>(error: ErrorType, handlers: MatchHandlers<ErrorType, ReturnType>) => ReturnType;
+export 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.
  */
-declare const matchErrorPartial: <ErrorType extends Error, ReturnType>(error: ErrorType, handlers: PartialMatchHandlers<ErrorType, ReturnType>, fallback: (error: ErrorType) => ReturnType) => ReturnType;
+export declare const matchErrorPartial: <ErrorType extends Error, ReturnType>(error: ErrorType, handlers: PartialMatchHandlers<ErrorType, ReturnType>, fallback: (error: ErrorType) => ReturnType) => ReturnType;
 //#endregion
-export { AbortError, type Cause, DisposableResult, DisposableResultAsync, type ErrResult, type Exit, MissingServiceError, 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 ResultTaskAcquireReleaseOptions, ResultTaskCauseError, type ResultTaskMatchOptions, type ResultTaskRunOptions, type ResultTaskScope, type ResultTaskScopeOwner, type ResultTaskServiceResolver, type ResultTaskServices, type ResultTaskTryOptions, type ResultTaskTryPromiseOptions, ResultTaskTypeId, ResultTaskYieldTypeId, type SafeTryAsyncOptions, type SafeTryOptions, type ServiceTag, ServiceTagTypeId, 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, isResultTask, isServiceTag, matchError, matchErrorPartial, ok, okAsync, redact, revealRedacted, runPromise, runSync, safeTry, serviceTag, taggedEnum, tryResultAsync as tryAsync, tryResultAsync, tryCatch, tryCatchAsync, unit, unitAsync };
+export { type Cause, type ErrResult, type Exit, type OkResult, type Redacted, 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 ResultTaskAcquireReleaseOptions, type ResultTaskMatchOptions, type ResultTaskRunOptions, type ResultTaskScope, type ResultTaskScopeOwner, type ResultTaskServiceResolver, 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, tryResult as default, tryResult as try, tryResultAsync as tryAsync };

package/dist/index.js

@@ -918,129 +918,6 @@ var ServiceTagValue = class {
 };
 /** Creates a service tag that can be requested with `yield*` inside `ResultTask.gen`. */
 const serviceTag = (identifier) => new ServiceTagValue(identifier);
-const applySuccessContinuation = (continuation, exit) => {
-	switch (continuation._tag) {
-		case "Map": try {
-			return {
-				current: void 0,
-				currentExit: success(continuation.f(exit.value))
-			};
-		} catch (error) {
-			return {
-				current: void 0,
-				currentExit: died(error)
-			};
-		}
-		case "FlatMap": try {
-			return {
-				current: continuation.f(exit.value),
-				currentExit: void 0
-			};
-		} catch (error) {
-			return {
-				current: void 0,
-				currentExit: died(error)
-			};
-		}
-		case "Tap": try {
-			const res = continuation.f(exit.value);
-			return ResultTask.toTapContinuationStep(res, () => ResultTask.succeed(exit.value), exit);
-		} catch (error) {
-			return {
-				current: void 0,
-				currentExit: died(error)
-			};
-		}
-		case "MapError": return {
-			current: void 0,
-			currentExit: exit
-		};
-		case "TapError": return {
-			current: void 0,
-			currentExit: exit
-		};
-		case "CatchAll": return {
-			current: void 0,
-			currentExit: exit
-		};
-		default: return {
-			current: void 0,
-			currentExit: exit
-		};
-	}
-};
-const applyFailureContinuation = (continuation, exit) => {
-	switch (continuation._tag) {
-		case "MapError":
-			if (exit.cause._tag === "Fail") try {
-				return {
-					current: void 0,
-					currentExit: failed(continuation.f(exit.cause.error))
-				};
-			} catch (error) {
-				return {
-					current: void 0,
-					currentExit: died(error)
-				};
-			}
-			return {
-				current: void 0,
-				currentExit: exit
-			};
-		case "TapError":
-			if (exit.cause._tag === "Fail") try {
-				const failError = exit.cause.error;
-				const res = continuation.f(failError);
-				return ResultTask.toTapContinuationStep(res, () => ResultTask.fail(failError), exit);
-			} catch (error) {
-				return {
-					current: void 0,
-					currentExit: died(error)
-				};
-			}
-			return {
-				current: void 0,
-				currentExit: exit
-			};
-		case "CatchAll":
-			if (exit.cause._tag === "Sequential") return {
-				current: void 0,
-				currentExit: died(new ResultTaskCauseError(exit.cause))
-			};
-			if (exit.cause._tag === "Fail") try {
-				return {
-					current: continuation.f(exit.cause.error),
-					currentExit: void 0
-				};
-			} catch (error) {
-				return {
-					current: void 0,
-					currentExit: died(error)
-				};
-			}
-			return {
-				current: void 0,
-				currentExit: exit
-			};
-		case "Map": return {
-			current: void 0,
-			currentExit: exit
-		};
-		case "FlatMap": return {
-			current: void 0,
-			currentExit: exit
-		};
-		case "Tap": return {
-			current: void 0,
-			currentExit: exit
-		};
-		default: return {
-			current: void 0,
-			currentExit: exit
-		};
-	}
-};
-const applyContinuation = (continuation, exit) => exit._tag === "Success" ? applySuccessContinuation(continuation, exit) : applyFailureContinuation(continuation, exit);
 const executeInstruction = async (instruction, continuations, context) => {
 	switch (instruction._tag) {
 		case "FlatMap":
@@ -1101,8 +978,129 @@ var ResultTask = class ResultTask extends Pipeable {
 		} : instructionOrExecute;
 		this.execute = (context) => ResultTask.runTaskLoop(this, context);
 	}
-	/** @internal */
-	static toTapContinuationStep(res, onSuccess, passThroughExit) {
+	static #applySuccessContinuation(continuation, exit) {
+		switch (continuation._tag) {
+			case "Map": try {
+				return {
+					current: void 0,
+					currentExit: success(continuation.f(exit.value))
+				};
+			} catch (error) {
+				return {
+					current: void 0,
+					currentExit: died(error)
+				};
+			}
+			case "FlatMap": try {
+				return {
+					current: continuation.f(exit.value),
+					currentExit: void 0
+				};
+			} catch (error) {
+				return {
+					current: void 0,
+					currentExit: died(error)
+				};
+			}
+			case "Tap": try {
+				const res = continuation.f(exit.value);
+				return ResultTask.#toTapContinuationStep(res, () => ResultTask.succeed(exit.value), exit);
+			} catch (error) {
+				return {
+					current: void 0,
+					currentExit: died(error)
+				};
+			}
+			case "MapError": return {
+				current: void 0,
+				currentExit: exit
+			};
+			case "TapError": return {
+				current: void 0,
+				currentExit: exit
+			};
+			case "CatchAll": return {
+				current: void 0,
+				currentExit: exit
+			};
+			default: return {
+				current: void 0,
+				currentExit: exit
+			};
+		}
+	}
+	static #applyFailureContinuation(continuation, exit) {
+		switch (continuation._tag) {
+			case "MapError":
+				if (exit.cause._tag === "Fail") try {
+					return {
+						current: void 0,
+						currentExit: failed(continuation.f(exit.cause.error))
+					};
+				} catch (error) {
+					return {
+						current: void 0,
+						currentExit: died(error)
+					};
+				}
+				return {
+					current: void 0,
+					currentExit: exit
+				};
+			case "TapError":
+				if (exit.cause._tag === "Fail") try {
+					const failError = exit.cause.error;
+					const res = continuation.f(failError);
+					return ResultTask.#toTapContinuationStep(res, () => ResultTask.fail(failError), exit);
+				} catch (error) {
+					return {
+						current: void 0,
+						currentExit: died(error)
+					};
+				}
+				return {
+					current: void 0,
+					currentExit: exit
+				};
+			case "CatchAll":
+				if (exit.cause._tag === "Sequential") return {
+					current: void 0,
+					currentExit: died(new ResultTaskCauseError(exit.cause))
+				};
+				if (exit.cause._tag === "Fail") try {
+					return {
+						current: continuation.f(exit.cause.error),
+						currentExit: void 0
+					};
+				} catch (error) {
+					return {
+						current: void 0,
+						currentExit: died(error)
+					};
+				}
+				return {
+					current: void 0,
+					currentExit: exit
+				};
+			case "Map": return {
+				current: void 0,
+				currentExit: exit
+			};
+			case "FlatMap": return {
+				current: void 0,
+				currentExit: exit
+			};
+			case "Tap": return {
+				current: void 0,
+				currentExit: exit
+			};
+			default: return {
+				current: void 0,
+				currentExit: exit
+			};
+		}
+	}
+	static #toTapContinuationStep(res, onSuccess, passThroughExit) {
 		if (res instanceof ResultTask) return {
 			current: res.flatMap(onSuccess),
 			currentExit: void 0
@@ -1132,7 +1130,7 @@ var ResultTask = class ResultTask extends Pipeable {
 				const nextContinuation = continuations.pop();
 				if (nextContinuation === void 0) return currentExit;
 				const resolvedExit = context.signal.aborted && currentExit._tag === "Success" ? interrupted(context.signal) : currentExit;
-				const step = applyContinuation(nextContinuation, resolvedExit);
+				const step = resolvedExit._tag === "Success" ? ResultTask.#applySuccessContinuation(nextContinuation, resolvedExit) : ResultTask.#applyFailureContinuation(nextContinuation, resolvedExit);
 				current = step.current;
 				currentExit = step.currentExit;
 			}
@@ -1410,6 +1408,12 @@ var ResultTask = class ResultTask extends Pipeable {
 		const pending = /* @__PURE__ */ new Set();
 		let closing = void 0;
 		return {
+			addFinalizer: (release) => {
+				if (closing !== void 0) throw new Error("Cannot acquire into a closing ResultTask scope");
+				scope.add((exit) => ResultTask.runExit(ResultTask.gen(function* () {
+					yield* release(exit);
+				})));
+			},
 			use: (task) => new ResultTask(async (context) => {
 				if (closing !== void 0) return died(/* @__PURE__ */ new Error("Cannot execute in a closed ResultTask scope"));
 				const attempt = new TaskScope();