better-effect 0.10.0 → 0.12.0

package/dist/{index-BafDna0B.d.mts → index-CX6iAoCB.d.mts}

@@ -1,96 +1,5 @@
-import { A as ProgramFromGenerator, C as EffectError, D as EffectYield, E as EffectSuccess, M as AnyService, S as Effect$1, T as EffectRequirements, f as DisposableResource, h as ScopeOutcome, k as Program$1, p as MaybePromise$1, w as EffectFromGenerator, x as AnyEffect } from "./index-CULgSzUw.mjs";
-import { S as LayerInput, T as ProvidedEnvironment, _ as Layer, a as RuntimeShutdownDiagnostic, b as CompleteInput, i as RuntimeRunOptions, n as RuntimeDisposeOptions, r as RuntimeOptions, v as CompleteExecution, y as CompleteExecutionLayer } from "./index-C7KX5rAP.mjs";
-import { n as LayerBackend } from "./map-layer-backend-rNwfH0Bz.mjs";
+import { A as ProgramFromGenerator, C as EffectError, D as EffectYield, E as EffectSuccess, M as AnyService, S as Effect$1, T as EffectRequirements, f as DisposableResource, h as ScopeOutcome, k as Program$1, p as MaybePromise, w as EffectFromGenerator, x as AnyEffect } from "./index-heuaRmXR.mjs";
 import { Err, Result, UnhandledException } from "better-result";
-//#region src/runtime/types.d.ts
-/**
- * Name a Runtime type from a concrete Layer without repeating its provided
- * branded Service instance union.
- *
- * @example
- * ```ts
- * type AppRuntime = RuntimeFor<typeof AppLive>
- * ```
- */
-type RuntimeFor<L extends LayerInput> = Runtime<Layer.Provided<L>>;
-//#endregion
-//#region src/runtime/runtime.d.ts
-/**
- * Long-lived execution environment backed by a complete Layer.
- *
- * A Runtime owns Layer resources until `dispose()` is called. Each `run()` is
- * isolated in a child Scope, while Layer-scoped resources remain shared.
- *
- * @example
- * ```ts
- * const runtime = await Runtime.make(AppLive)
- * const result = await runtime.run(loadUser('u1'))
- * await runtime.dispose()
- * ```
- *
- * @typeParam Provided The branded Service instances supplied by the Layer.
- */
-declare class Runtime<Provided extends AnyService = any> {
-  private readonly handle;
-  private constructor();
-  /**
-   * Create a long-lived Runtime that owns its Layer resources.
-   *
-   * @example
-   * ```ts
-   * const runtime = await Runtime.make(AppLive)
-   * const result = await runtime.run(program)
-   * await runtime.dispose()
-   * ```
-   */
-  static make<L extends LayerInput>(layer: L & CompleteInput<L>, backend: LayerBackend, options?: RuntimeOptions): Promise<Runtime<ProvidedEnvironment<L>>>;
-  static make<L extends LayerInput>(layer: L & CompleteInput<L>, options?: RuntimeOptions): Promise<Runtime<ProvidedEnvironment<L>>>;
-  /**
-   * Run one program and dispose its Layer resources before resolving.
-   *
-   * This is convenient for request-style or command-style execution where a
-   * Runtime should not outlive the operation.
-   */
-  static run<A, L extends LayerInput>(layer: L & CompleteInput<L>, backend: LayerBackend, program: CompleteExecution<ProvidedEnvironment<L>, A>, options?: RuntimeOptions): Promise<Awaited<A>>;
-  static run<A, L extends LayerInput>(layer: L & CompleteInput<L>, program: CompleteExecution<ProvidedEnvironment<L>, A>, options?: RuntimeOptions): Promise<Awaited<A>>;
-  static run<A, L extends LayerInput>(layer: L & CompleteInput<L>, options: RuntimeOptions, program: CompleteExecution<ProvidedEnvironment<L>, A>): Promise<Awaited<A>>;
-  /** Run a callback with a managed Runtime and always dispose it afterward. */
-  static use<A, L extends LayerInput>(layer: L & CompleteInput<L>, use: (runtime: Runtime<ProvidedEnvironment<L>>) => A | PromiseLike<A>, options?: RuntimeOptions): Promise<Awaited<A>>;
-  /** Resolve every Layer provider and dispose the Runtime if warmup fails. */
-  warmup(): Promise<void>;
-  /** Run one execution in this Runtime's child Scope. */
-  run<A>(program: CompleteExecution<Provided, A>, options?: RuntimeRunOptions): Promise<Awaited<A>>;
-  /** Run one execution with a Layer owned by that execution's child Scope. */
-  runWith<Request extends LayerInput, A>(layer: Request & CompleteExecutionLayer<Provided, Request>, program: CompleteExecution<Provided | ProvidedEnvironment<Request>, A>, options?: RuntimeRunOptions): Promise<Awaited<A>>;
-  private runUnchecked;
-  /** Stop new executions and release the Runtime's Layer resources. */
-  dispose(options?: RuntimeDisposeOptions): Promise<void>;
-  /** @deprecated Scope outcomes are kept for internal compatibility. */
-  dispose(outcome: ScopeOutcome): Promise<void>;
-  /** Release Runtime-owned resources through JavaScript's async disposal protocol. */
-  [Symbol.asyncDispose](): Promise<void>;
-  private disposeWithOutcome;
-}
-/** Type-level aliases for naming Runtime handles and shutdown options. */
-declare namespace Runtime {
-  /** Name a Runtime type from a concrete Layer. */
-  type For<L extends LayerInput> = RuntimeFor<L>;
-  /** Optional Runtime shutdown configuration. */
-  type Options = RuntimeOptions;
-  /** Optional signal supplied to one managed Runtime execution. */
-  type RunOptions = RuntimeRunOptions;
-  /** Cooperative shutdown policy for a managed Runtime. */
-  type DisposeOptions = RuntimeDisposeOptions;
-  /** Diagnostic reported for aggregated Runtime shutdown cleanup failures. */
-  type ShutdownDiagnostic = RuntimeShutdownDiagnostic;
-}
-//#endregion
-//#region src/runtime/signal.d.ts
-/** Yieldable access to the signal of the current Runtime execution. */
-declare const CurrentAbortSignal: {
-  readonly [Symbol.iterator]: () => Generator<never, AbortSignal, unknown>;
-};
-//#endregion
 //#region src/effect/combinators.d.ts
 type EffectInput<A, E> = Result<A, E> | PromiseLike<Result<A, E>>;
 type AnyEffectInput = EffectInput<any, any>;
@@ -102,13 +11,13 @@ type ErrorMappedResult<Input, E2> = Effect$1<EffectSuccess<Input>, E2, EffectReq
 type ChainedResult<First, Next> = Effect$1<EffectSuccess<Next>, EffectError<First> | EffectError<Next>, EffectRequirements<First> | EffectRequirements<Next>>;
 type ChainedOutput<First, Next> = ChainedResult<First, Next>;
 type AsyncChainedOutput<First, Next> = Promise<ChainedResult<First, Next>>;
-type MapOperation<A, B> = {
+type MapOperation$1<A, B> = {
   <Input>(effect: Input & EffectInput<A, any>): PreserveAsync<Input, MappedResult<Input, B>>;
 };
-type MapErrorOperation<E1, E2> = {
+type MapErrorOperation$1<E1, E2> = {
   <Input>(effect: Input & EffectInput<any, E1>): PreserveAsync<Input, ErrorMappedResult<Input, E2>>;
 };
-type AndThenOperation<Next> = {
+type AndThenOperation$1<Next> = {
   <Input>(effect: Input & AnyEffectValue): ChainedOutput<Input, Next>;
 };
 type AndThenAsyncOperation<A, Next> = {
@@ -121,10 +30,10 @@ type AsResult<Input, Value> = Effect$1<Value, EffectError<Input>, EffectRequirem
 type MatchedResult<Input, OkResult, ErrResult> = Effect$1<EffectSuccess<OkResult> | EffectSuccess<ErrResult>, EffectError<OkResult> | EffectError<ErrResult>, EffectRequirements<Input> | EffectRequirements<OkResult> | EffectRequirements<ErrResult>>;
 type AllResult<Results extends readonly AnyEffectValue[]> = Effect$1<{ -readonly [Index in keyof Results]: EffectSuccess<Results[Index]>; }, EffectError<Results[number]>, EffectRequirements<Results[number]>>;
 type ZipResult<Left, Right> = Effect$1<[EffectSuccess<Left>, EffectSuccess<Right>], EffectError<Left> | EffectError<Right>, EffectRequirements<Left> | EffectRequirements<Right>>;
-type TapOperation = {
+type TapOperation$1 = {
   <Input>(effect: Input & AnyEffectInput, fn: (value: EffectSuccess<Input>) => void): PreserveAsync<Input, TappedResult<Input>>;
 };
-type TapErrorOperation = {
+type TapErrorOperation$1 = {
   <Input>(effect: Input & AnyEffectInput, fn: (error: EffectError<Input>) => void): PreserveAsync<Input, TappedResult<Input>>;
 };
 type TapBothOperation = {
@@ -133,7 +42,31 @@ type TapBothOperation = {
     err: (error: EffectError<Input>) => void;
   }): PreserveAsync<Input, TappedResult<Input>>;
 };
-type RecoverOperation<Next> = {
+type TapAsyncOperation = {
+  <Input>(effect: Input & AnyEffectInput): Promise<TappedResult<Input>>;
+};
+type TapErrorAsyncOperation = {
+  <Input>(effect: Input & AnyEffectInput): Promise<TappedResult<Input>>;
+};
+type TapBothAsyncOperation = {
+  <Input>(effect: Input & AnyEffectInput): Promise<TappedResult<Input>>;
+};
+type TaggedErrorLike = Error & {
+  readonly _tag: string;
+};
+type TaggedErrorHandlers<ErrorValue extends TaggedErrorLike> = { [Tag in ErrorValue['_tag']]: (error: Extract<ErrorValue, {
+  readonly _tag: Tag;
+}>) => unknown; };
+type TaggedErrorOf<Input> = Extract<EffectError<Input>, TaggedErrorLike>;
+type TaggedErrorHandlersFor<Input> = [EffectError<Input>] extends [TaggedErrorLike] ? TaggedErrorHandlers<TaggedErrorOf<Input>> : never;
+type HandlerReturn<Handlers> = { [Key in keyof Handlers]-?: NonNullable<Handlers[Key]> extends ((error: never) => infer Return) ? Return : never; }[keyof Handlers];
+type RequiredHandlerKeys<Handlers> = { [Key in keyof Handlers]-?: {} extends Pick<Handlers, Key> ? never : undefined extends Handlers[Key] ? never : Key; }[keyof Handlers];
+type UnhandledTaggedErrors<ErrorValue extends TaggedErrorLike, Handlers> = Exclude<ErrorValue, {
+  readonly _tag: Extract<RequiredHandlerKeys<Handlers>, ErrorValue['_tag']>;
+}>;
+type MatchErrorResult<Input, Handlers> = Effect$1<EffectSuccess<Input>, HandlerReturn<Handlers>, EffectRequirements<Input>>;
+type MatchErrorPartialResult<Input, Handlers> = Effect$1<EffectSuccess<Input>, HandlerReturn<Handlers> | UnhandledTaggedErrors<TaggedErrorOf<Input>, Handlers>, EffectRequirements<Input>>;
+type RecoverOperation$1<Next> = {
   <Input>(effect: Input & AnyEffectInput, fn: (error: EffectError<Input>) => Next): PreserveAsync<Input, RecoveredResult<Input, Next>>;
 };
 type RecoverAsyncOperation<Next> = {
@@ -151,8 +84,8 @@ type RecoverAsyncOperation<Next> = {
  * const toLabel = Effect.map((value: number) => `#${value}`)
  * ```
  */
-declare function map<A, B>(fn: (value: A) => B): MapOperation<A, B>;
-declare function map<Input, B>(effect: Input & AnyEffectInput, fn: (value: EffectSuccess<Input>) => B): PreserveAsync<Input, MappedResult<Input, B>>;
+declare function map$1<A, B>(fn: (value: A) => B): MapOperation$1<A, B>;
+declare function map$1<Input, B>(effect: Input & AnyEffectInput, fn: (value: EffectSuccess<Input>) => B): PreserveAsync<Input, MappedResult<Input, B>>;
 /**
  * Map the error value of a Result or Effect result while preserving its
  * successful value, asynchronous shape, and declaration-only Service requirements.
@@ -162,8 +95,8 @@ declare function map<Input, B>(effect: Input & AnyEffectInput, fn: (value: Effec
  * const labelled = Effect.mapError(Result.err('missing'), (error) => ({ error }))
  * ```
  */
-declare function mapError<E1, E2>(fn: (error: E1) => E2): MapErrorOperation<E1, E2>;
-declare function mapError<Input, E2>(effect: Input & AnyEffectInput, fn: (error: EffectError<Input>) => E2): PreserveAsync<Input, ErrorMappedResult<Input, E2>>;
+declare function mapError$1<E1, E2>(fn: (error: E1) => E2): MapErrorOperation$1<E1, E2>;
+declare function mapError$1<Input, E2>(effect: Input & AnyEffectInput, fn: (error: EffectError<Input>) => E2): PreserveAsync<Input, ErrorMappedResult<Input, E2>>;
 /**
  * Chain a synchronous Result-producing operation after a successful result.
  *
@@ -175,8 +108,8 @@ declare function mapError<Input, E2>(effect: Input & AnyEffectInput, fn: (error:
  * const user = Effect.andThen(Result.ok('u1'), (id) => repository.find(id))
  * ```
  */
-declare function andThen<A, Next extends AnyEffectValue>(next: (value: A) => Next): AndThenOperation<Next>;
-declare function andThen<Input, Next extends AnyEffectValue>(effect: Input & AnyEffectValue, next: (value: EffectSuccess<Input>) => Next): ChainedOutput<Input, Next>;
+declare function andThen$1<A, Next extends AnyEffectValue>(next: (value: A) => Next): AndThenOperation$1<Next>;
+declare function andThen$1<Input, Next extends AnyEffectValue>(effect: Input & AnyEffectValue, next: (value: EffectSuccess<Input>) => Next): ChainedOutput<Input, Next>;
 /**
  * Chain an asynchronous Result-producing operation after a successful result.
  *
@@ -191,11 +124,11 @@ declare function andThen<Input, Next extends AnyEffectValue>(effect: Input & Any
 declare function andThenAsync<A, Next extends AnyAsyncEffectInput>(next: (value: A) => Next): AndThenAsyncOperation<A, Next>;
 declare function andThenAsync<Input, Next extends AnyAsyncEffectInput>(effect: Input & AnyEffectInput, next: (value: EffectSuccess<Input>) => Next): AsyncChainedOutput<Input, Next>;
 /** Observe a successful value without changing the Result. */
-declare function tap(fn: (value: any) => void): TapOperation;
-declare function tap<Input>(effect: Input & AnyEffectInput, fn: (value: EffectSuccess<Input>) => void): PreserveAsync<Input, TappedResult<Input>>;
+declare function tap$1(fn: (value: any) => void): TapOperation$1;
+declare function tap$1<Input>(effect: Input & AnyEffectInput, fn: (value: EffectSuccess<Input>) => void): PreserveAsync<Input, TappedResult<Input>>;
 /** Observe an error value without changing the Result. */
-declare function tapError(fn: (error: any) => void): TapErrorOperation;
-declare function tapError<Input>(effect: Input & AnyEffectInput, fn: (error: EffectError<Input>) => void): PreserveAsync<Input, TappedResult<Input>>;
+declare function tapError$1(fn: (error: any) => void): TapErrorOperation$1;
+declare function tapError$1<Input>(effect: Input & AnyEffectInput, fn: (error: EffectError<Input>) => void): PreserveAsync<Input, TappedResult<Input>>;
 /** Observe whichever Result branch is active without changing the Result. */
 declare function tapBoth(handlers: {
   ok: (value: any) => void;
@@ -205,9 +138,28 @@ declare function tapBoth<Input>(effect: Input & AnyEffectInput, handlers: {
   ok: (value: EffectSuccess<Input>) => void;
   err: (error: EffectError<Input>) => void;
 }): PreserveAsync<Input, TappedResult<Input>>;
+/** Observe a successful value asynchronously without changing the Result. */
+declare function tapAsync(fn: (value: any) => PromiseLike<void>): TapAsyncOperation;
+declare function tapAsync<Input>(effect: Input & AnyEffectInput, fn: (value: EffectSuccess<Input>) => PromiseLike<void>): Promise<TappedResult<Input>>;
+/** Observe an error value asynchronously without changing the Result. */
+declare function tapErrorAsync(fn: (error: any) => PromiseLike<void>): TapErrorAsyncOperation;
+declare function tapErrorAsync<Input>(effect: Input & AnyEffectInput, fn: (error: EffectError<Input>) => PromiseLike<void>): Promise<TappedResult<Input>>;
+/** Observe the active Result branch asynchronously without changing the Result. */
+declare function tapBothAsync(handlers: {
+  ok: (value: any) => PromiseLike<void>;
+  err: (error: any) => PromiseLike<void>;
+}): TapBothAsyncOperation;
+declare function tapBothAsync<Input>(effect: Input & AnyEffectInput, handlers: {
+  ok: (value: EffectSuccess<Input>) => PromiseLike<void>;
+  err: (error: EffectError<Input>) => PromiseLike<void>;
+}): Promise<TappedResult<Input>>;
+/** Match every tagged error variant and map it to a new error value. */
+declare function matchError$1<Input, Handlers extends TaggedErrorHandlersFor<Input>>(effect: Input & AnyEffectInput, handlers: Handlers): PreserveAsync<Input, MatchErrorResult<Input, Handlers>>;
+/** Match selected tagged errors and retain unhandled variants unchanged. */
+declare function matchErrorPartial$1<Input, Handlers extends Partial<TaggedErrorHandlersFor<Input>>>(effect: Input & AnyEffectInput, handlers: Handlers): PreserveAsync<Input, MatchErrorPartialResult<Input, Handlers>>;
 /** Recover an Err with a synchronous Result-producing callback. */
-declare function recover<Next extends AnyEffectValue>(fn: (error: any) => Next): RecoverOperation<Next>;
-declare function recover<Input, Next extends AnyEffectValue>(effect: Input & AnyEffectInput, fn: (error: EffectError<Input>) => Next): PreserveAsync<Input, RecoveredResult<Input, Next>>;
+declare function recover$1<Next extends AnyEffectValue>(fn: (error: any) => Next): RecoverOperation$1<Next>;
+declare function recover$1<Input, Next extends AnyEffectValue>(effect: Input & AnyEffectInput, fn: (error: EffectError<Input>) => Next): PreserveAsync<Input, RecoveredResult<Input, Next>>;
 /** Recover an Err with an asynchronous Result-producing callback. */
 declare function recoverAsync<Next extends AnyAsyncEffectInput>(fn: (error: any) => Next): RecoverAsyncOperation<Next>;
 declare function recoverAsync<Input, Next extends AnyAsyncEffectInput>(effect: Input & AnyEffectInput, fn: (error: EffectError<Input>) => Next): Promise<RecoveredResult<Input, Next>>;
@@ -232,6 +184,56 @@ declare function all<const Results extends readonly AnyEffectValue[]>(results: R
 /** Combine two already-created Effects in input order. */
 declare function zip<Left, Right>(left: Left & AnyEffectValue, right: Right & AnyEffectValue): ZipResult<Left, Right>;
 //#endregion
+//#region src/effect/program-combinators.d.ts
+type AnyResult$1 = Result<any, any>;
+type RuntimeEffect = AnyResult$1 | PromiseLike<AnyResult$1>;
+type RuntimeProgram = () => RuntimeEffect;
+type ProgramInput<Input extends RuntimeProgram> = Input & Program$1<EffectSuccess<Input>, EffectError<Input>, EffectRequirements<Input>>;
+type CompatibleSuccess<Input, A> = EffectSuccess<Input> extends A ? unknown : never;
+type CompatibleError<Input, E> = EffectError<Input> extends E ? unknown : never;
+type ProgramOutput<Output> = Output extends Program$1<infer _Success, infer _Error, infer _Requirements extends AnyService> ? Output : Output extends PromiseLike<infer AsyncOutput> ? AsyncOutput extends Result<infer _Success, infer _Error> ? Output : never : Output extends Result<infer _Success, infer _Error> ? Output : never;
+type MappedProgram<Input, B> = Program$1<B, EffectError<Input>, EffectRequirements<Input>>;
+type ErrorMappedProgram<Input, E2> = Program$1<EffectSuccess<Input>, E2, EffectRequirements<Input>>;
+type ChainedProgram<Input, Next> = Program$1<EffectSuccess<Next>, EffectError<Input> | EffectError<Next>, EffectRequirements<Input> | EffectRequirements<Next>>;
+type TappedProgram<Input> = Program$1<EffectSuccess<Input>, EffectError<Input>, EffectRequirements<Input>>;
+type RecoveredProgram<Input, Next> = Program$1<EffectSuccess<Input> | EffectSuccess<Next>, EffectError<Next>, EffectRequirements<Input> | EffectRequirements<Next>>;
+type MapOperation<A, B> = {
+  <Input extends RuntimeProgram>(program: ProgramInput<Input> & CompatibleSuccess<Input, A>): MappedProgram<Input, B>;
+};
+type MapErrorOperation<E1, E2> = {
+  <Input extends RuntimeProgram>(program: ProgramInput<Input> & CompatibleError<Input, E1>): ErrorMappedProgram<Input, E2>;
+};
+type AndThenOperation<A, Next> = {
+  <Input extends RuntimeProgram>(program: ProgramInput<Input> & CompatibleSuccess<Input, A>): ChainedProgram<Input, Next>;
+};
+type TapOperation<A> = {
+  <Input extends RuntimeProgram>(program: ProgramInput<Input> & CompatibleSuccess<Input, A>): TappedProgram<Input>;
+};
+type TapErrorOperation<E> = {
+  <Input extends RuntimeProgram>(program: ProgramInput<Input> & CompatibleError<Input, E>): TappedProgram<Input>;
+};
+type RecoverOperation<E, Next> = {
+  <Input extends RuntimeProgram>(program: ProgramInput<Input> & CompatibleError<Input, E>): RecoveredProgram<Input, Next>;
+};
+/** Lazily map the successful Result value of a Program. */
+declare function map<A, B>(fn: (value: A) => B): MapOperation<A, B>;
+declare function map<Input extends RuntimeProgram, B>(program: ProgramInput<Input>, fn: (value: EffectSuccess<Input>) => B): MappedProgram<Input, B>;
+/** Lazily map the error Result value of a Program. */
+declare function mapError<E1, E2>(fn: (error: E1) => E2): MapErrorOperation<E1, E2>;
+declare function mapError<Input extends RuntimeProgram, E2>(program: ProgramInput<Input>, fn: (error: EffectError<Input>) => E2): ErrorMappedProgram<Input, E2>;
+/** Lazily continue a successful Program with an Effect or Program. */
+declare function andThen<A, Next>(next: (value: A) => Next & ProgramOutput<Next>): AndThenOperation<A, Next>;
+declare function andThen<Input extends RuntimeProgram, Next>(program: ProgramInput<Input>, next: (value: EffectSuccess<Input>) => Next & ProgramOutput<Next>): ChainedProgram<Input, Next>;
+/** Lazily observe a successful Program value without changing its Result. */
+declare function tap<A>(fn: (value: A) => void): TapOperation<A>;
+declare function tap<Input extends RuntimeProgram>(program: ProgramInput<Input>, fn: (value: EffectSuccess<Input>) => void): TappedProgram<Input>;
+/** Lazily observe a failed Program value without changing its Result. */
+declare function tapError<E>(fn: (error: E) => void): TapErrorOperation<E>;
+declare function tapError<Input extends RuntimeProgram>(program: ProgramInput<Input>, fn: (error: EffectError<Input>) => void): TappedProgram<Input>;
+/** Lazily recover a failed Program with an Effect or Program. */
+declare function recover<E, Next>(fn: (error: E) => Next & ProgramOutput<Next>): RecoverOperation<E, Next>;
+declare function recover<Input extends RuntimeProgram, Next>(program: ProgramInput<Input>, recover: (error: EffectError<Input>) => Next & ProgramOutput<Next>): RecoveredProgram<Input, Next>;
+//#endregion
 //#region src/effect/effect.d.ts
 type Effect<A, E, R extends AnyService = never> = Effect$1<A, E, R>;
 type LazyProgram<A, E, R extends AnyService = never> = Program$1<A, E, R>;
@@ -243,8 +245,14 @@ type ProgramAllSuccess<Programs extends readonly AnyProgram[]> = { -readonly [In
 type ProgramAllError<Programs extends readonly AnyProgram[]> = EffectError<Programs[number]>;
 type ProgramAllRequirements<Programs extends readonly AnyProgram[]> = EffectRequirements<Programs[number]>;
 type ProgramAllResult<Programs extends readonly AnyProgram[]> = Program$1<ProgramAllSuccess<Programs>, ProgramAllError<Programs>, ProgramAllRequirements<Programs>>;
+type ProgramResultFor<Child> = Child extends AnyProgram ? Result<EffectSuccess<Child>, EffectError<Child>> : never;
+type ProgramAllResultsSuccess<Programs extends readonly AnyProgram[]> = number extends Programs['length'] ? ReadonlyArray<Result<EffectSuccess<Programs[number]>, EffectError<Programs[number]>>> : { readonly [Index in keyof Programs]: ProgramResultFor<Programs[Index]>; };
+type ProgramAllResultsResult<Programs extends readonly AnyProgram[]> = Program$1<ProgramAllResultsSuccess<Programs>, never, ProgramAllRequirements<Programs>>;
+type ProgramForEachResult<Child extends AnyProgram> = Program$1<ReadonlyArray<EffectSuccess<Child>>, EffectError<Child>, EffectRequirements<Child>>;
 type ProgramAllOptions = {
   readonly concurrency?: number;
+  /** Optional diagnostic name for the collection execution. */
+  readonly name?: string;
 };
 /**
  * Compose `better-result` operations while preserving Service requirements in
@@ -270,11 +278,30 @@ declare function gen<Yield extends EffectYield, Returned extends AnyResult>(body
 /** Build a lazy Program without running its generator. */
 declare function fn<Yield extends EffectYield, Returned extends AnyResult>(body: () => Generator<Yield, Returned, unknown>): ProgramFromGenerator<Yield, Returned>;
 declare function fn<Yield extends EffectYield, Returned extends AnyResult>(body: () => AsyncGenerator<Yield, Returned, unknown>): ProgramFromGenerator<Yield, Returned>;
+type ProgramNamedOperation = {
+  <Input extends AnyProgram>(program: Input): Input;
+};
+/** Attach a lazy diagnostic name to a Program without invoking it. */
+declare function programNamed(name: string): ProgramNamedOperation;
+declare function programNamed<Input extends AnyProgram>(name: string, program: Input): Input;
 /** Build a lazy Program collection with optional bounded concurrency. */
 declare function programAll<const Programs extends readonly AnyProgram[]>(programs: Programs, options?: ProgramAllOptions): ProgramAllResult<Programs>;
+/** Build a lazy Program collection from an input array and Program factory. */
+declare function programForEach<const Items extends readonly unknown[], Child extends AnyProgram>(items: Items, makeProgram: (item: Items[number], index: number) => Child, options?: ProgramAllOptions): ProgramForEachResult<Child>;
+/** Build a lazy Program collection that retains every child Result. */
+declare function programAllResults<const Programs extends readonly AnyProgram[]>(programs: Programs, options?: ProgramAllOptions): ProgramAllResultsResult<Programs>;
 /** Value-level namespace for lazy Program combinators. */
 declare const Program: {
+  readonly named: typeof programNamed;
   readonly all: typeof programAll;
+  readonly forEach: typeof programForEach;
+  readonly allResults: typeof programAllResults;
+  readonly map: typeof map;
+  readonly mapError: typeof mapError;
+  readonly andThen: typeof andThen;
+  readonly tap: typeof tap;
+  readonly tapError: typeof tapError;
+  readonly recover: typeof recover;
 };
 /**
  * Acquire a resource in the current Scope and register its release callback.
@@ -291,7 +318,22 @@ declare const Program: {
  * )
  * ```
  */
-declare function acquireRelease<R>(acquire: () => MaybePromise$1<R>, release: (resource: R, outcome: ScopeOutcome) => MaybePromise$1<void>): AsyncGenerator<Err<never, UnhandledException>, R, unknown>;
+declare function acquireRelease<R>(acquire: () => MaybePromise<R>, release: (resource: R, outcome: ScopeOutcome) => MaybePromise<void>): AsyncGenerator<Err<never, UnhandledException>, R, unknown>;
+/**
+ * Acquire a Result-valued resource and register only successful acquisitions.
+ *
+ * Typed acquisition failures remain unchanged in the Effect error channel;
+ * unexpected acquisition and registration failures are normalized by
+ * `better-result`. Release failures remain Scope cleanup failures.
+ */
+declare function acquireReleaseResult<R, E>(acquire: () => MaybePromise<Result<R, E>>, release: (resource: R, outcome: ScopeOutcome) => MaybePromise<void>): AsyncGenerator<Err<never, E | UnhandledException>, R, unknown>;
+/**
+ * Lazily acquire and register a disposable resource in the current Scope.
+ *
+ * Disposal is delegated to `Scope.add`, including protocol preference,
+ * validation, race-safe registration, and cleanup error handling.
+ */
+declare function acquireDisposable<R extends DisposableResource>(acquire: () => MaybePromise<R>): AsyncGenerator<Err<never, UnhandledException>, R, unknown>;
 /**
  * Register an already-acquired disposable resource in the current Scope.
  *
@@ -315,15 +357,22 @@ type EffectNamespace = {
   readonly gen: typeof gen;
   readonly fn: typeof fn;
   readonly acquireRelease: typeof acquireRelease;
+  readonly acquireReleaseResult: typeof acquireReleaseResult;
+  readonly acquireDisposable: typeof acquireDisposable;
   readonly add: typeof add;
-  readonly map: typeof map;
-  readonly mapError: typeof mapError;
-  readonly andThen: typeof andThen;
+  readonly map: typeof map$1;
+  readonly mapError: typeof mapError$1;
+  readonly andThen: typeof andThen$1;
   readonly andThenAsync: typeof andThenAsync;
-  readonly tap: typeof tap;
-  readonly tapError: typeof tapError;
+  readonly tap: typeof tap$1;
+  readonly tapAsync: typeof tapAsync;
+  readonly tapError: typeof tapError$1;
+  readonly tapErrorAsync: typeof tapErrorAsync;
   readonly tapBoth: typeof tapBoth;
-  readonly recover: typeof recover;
+  readonly tapBothAsync: typeof tapBothAsync;
+  readonly matchError: typeof matchError$1;
+  readonly matchErrorPartial: typeof matchErrorPartial$1;
+  readonly recover: typeof recover$1;
   readonly recoverAsync: typeof recoverAsync;
   readonly flatten: typeof flatten;
   readonly as: typeof as;
@@ -347,60 +396,5 @@ declare namespace Effect {
   type Any = AnyEffect;
 }
 //#endregion
-//#region src/function/pipe.d.ts
-type Unary<A, B> = (value: A) => B;
-declare function pipe<A>(value: A): A;
-declare function pipe<A, B>(value: A, ab: Unary<A, B>): B;
-declare function pipe<A, B, C>(value: A, ab: Unary<A, B>, bc: Unary<B, C>): C;
-declare function pipe<A, B, C, D>(value: A, ab: Unary<A, B>, bc: Unary<B, C>, cd: Unary<C, D>): D;
-declare function pipe<A, B, C, D, E>(value: A, ab: Unary<A, B>, bc: Unary<B, C>, cd: Unary<C, D>, de: Unary<D, E>): E;
-declare function pipe<A, B, C, D, E, F>(value: A, ab: Unary<A, B>, bc: Unary<B, C>, cd: Unary<C, D>, de: Unary<D, E>, ef: Unary<E, F>): F;
-declare function pipe<A, B, C, D, E, F, G>(value: A, ab: Unary<A, B>, bc: Unary<B, C>, cd: Unary<C, D>, de: Unary<D, E>, ef: Unary<E, F>, fg: Unary<F, G>): G;
-declare function pipe<A, B, C, D, E, F, G, H>(value: A, ab: Unary<A, B>, bc: Unary<B, C>, cd: Unary<C, D>, de: Unary<D, E>, ef: Unary<E, F>, fg: Unary<F, G>, gh: Unary<G, H>): H;
-declare function pipe<A, B, C, D, E, F, G, H, I>(value: A, ab: Unary<A, B>, bc: Unary<B, C>, cd: Unary<C, D>, de: Unary<D, E>, ef: Unary<E, F>, fg: Unary<F, G>, gh: Unary<G, H>, hi: Unary<H, I>): I;
-declare function pipe<A, B, C, D, E, F, G, H, I, J>(value: A, ab: Unary<A, B>, bc: Unary<B, C>, cd: Unary<C, D>, de: Unary<D, E>, ef: Unary<E, F>, fg: Unary<F, G>, gh: Unary<G, H>, hi: Unary<H, I>, ij: Unary<I, J>): J;
-declare function pipe<A, B, C, D, E, F, G, H, I, J, K>(value: A, ab: Unary<A, B>, bc: Unary<B, C>, cd: Unary<C, D>, de: Unary<D, E>, ef: Unary<E, F>, fg: Unary<F, G>, gh: Unary<G, H>, hi: Unary<H, I>, ij: Unary<I, J>, jk: Unary<J, K>): K;
-//#endregion
-//#region src/resource/errors.d.ts
-declare const ResourceReleaseFailure_base: import("better-result").TaggedErrorClass<"ResourceReleaseFailure">;
-/** Describes a failure encountered while releasing a Resource. */
-declare class ResourceReleaseFailure extends ResourceReleaseFailure_base<{
-  readonly resource: string;
-  readonly cause: unknown;
-  readonly message: string;
-}> {}
-//#endregion
-//#region src/resource/types.d.ts
-/** A value that may be delivered synchronously or through a thenable. */
-type MaybePromise<T> = T | PromiseLike<T>;
-/** A synchronous or asynchronous better-result Result operation. */
-type AsyncResult<T, E> = MaybePromise<Result<T, E>>;
-/** The allowed return value of a custom Resource release callback. */
-type ReleaseOutcome = void | Result<void, unknown>;
-/** Receives release failures for diagnostics without changing error precedence. */
-type ReleaseFailureObserver = (failure: ResourceReleaseFailure) => MaybePromise<void>;
-/** Options controlling `Resource.acquireUseRelease`. */
-type AcquireUseReleaseOptions<R, A, AcquireError, UseError> = {
-  /** Human-readable name included in release failures. */
-  readonly name: string;
-  /** Acquire the resource. A failure skips use and release. */
-  readonly acquire: () => AsyncResult<R, AcquireError>;
-  /** Use the acquired resource. Release is attempted afterward. */
-  readonly use: (resource: R) => AsyncResult<A, UseError>;
-  /** Release the resource, or omit it to use its disposal protocol. */
-  readonly release?: (resource: R) => MaybePromise<ReleaseOutcome>;
-  /**
-   * Observe cleanup failures without changing error precedence. This is most
-   * useful when both `use` and `release` can fail.
-   */
-  readonly onReleaseFailure?: ReleaseFailureObserver;
-};
-//#endregion
-//#region src/resource/resource.d.ts
-declare const Resource: {
-  /** Acquire, use, and release a resource with deterministic error precedence. */
-  readonly acquireUseRelease: <R, A, AcquireError, UseError>({ name, acquire, use, release, onReleaseFailure }: AcquireUseReleaseOptions<R, A, AcquireError, UseError>) => Promise<Result<A, AcquireError | UseError | UnhandledException | ResourceReleaseFailure>>;
-};
-//#endregion
-export { ReleaseOutcome as a, Effect as c, CurrentAbortSignal as d, Runtime as f, ReleaseFailureObserver as i, Program as l, AcquireUseReleaseOptions as n, ResourceReleaseFailure as o, RuntimeFor as p, AsyncResult as r, pipe as s, Resource as t, ProgramAllOptions as u };
-//# sourceMappingURL=index-BafDna0B.d.mts.map
+export { Program as n, ProgramAllOptions as r, Effect as t };
+//# sourceMappingURL=index-CX6iAoCB.d.mts.map

package/dist/index-CX6iAoCB.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-CX6iAoCB.d.mts","names":[],"sources":["../src/effect/combinators.ts","../src/effect/program-combinators.ts","../src/effect/effect.ts"],"mappings":"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"}