better-effect 0.8.0 → 0.9.2

package/dist/{index-fUyY0eNJ.d.mts → index-CYAgpM_5.d.mts}

@@ -1,5 +1,5 @@
-import { B as ServiceTagOf, F as ServiceContract, H as ServiceTokenOf, M as AnyService, N as AnyServiceToken, P as ServiceClass, R as ServiceRequirements, T as EffectRequirements, V as ServiceToken, c as RuntimeContextStorage, d as CleanupFailureDiagnostic, h as ScopeOutcome, j as ServiceRequirement, p as MaybePromise, u as Scope } from "./index-BFgG9zZC.mjs";
-import { a as LayerRegistration, i as LayerGeneratorRequirements, n as LayerBackend, o as MaybePromise$1, r as LayerGenerator } from "./map-layer-backend-CGibcwkc.mjs";
+import { F as ServiceContract, H as ServiceToken, L as ServiceIdentityTypeId, M as AnyService, N as AnyServiceToken, P as ServiceClass, T as EffectRequirements, U as ServiceTokenOf, V as ServiceTagOf, c as RuntimeContextStorage, d as CleanupFailureDiagnostic, h as ScopeOutcome, j as ServiceRequirement, p as MaybePromise, u as Scope, z as ServiceRequirements } from "./index-1NLNdkJy.mjs";
+import { a as LayerRegistration, i as LayerGeneratorRequirements, n as LayerBackend, o as MaybePromise$1, r as LayerGenerator } from "./map-layer-backend-DMJauecV.mjs";
 //#region src/internal/variance.d.ts
 /** Type-level marker for a value produced by `A`. */
 type Covariant<A> = () => A;
@@ -91,9 +91,10 @@ type AmbiguousLayerUnion = {
 type ValidateLayerInput<L extends LayerInput> = LayerInputState<L> extends 'invalid-partial-any' ? InvalidLayerErasure : LayerInputState<L> extends 'invalid-union' ? AmbiguousLayerUnion : unknown;
 /** Validate every original element of a merge tuple. */
 type ValidateLayerTuple<Layers extends readonly LayerInput[]> = { [Index in keyof Layers]: ValidateLayerInput<Layers[Index]>; };
+type HasMatchingServiceTag<Left extends AnyService, Right extends AnyService> = [Extract<ServiceTagOf<Left>, ServiceTagOf<Right>>] extends [never] ? false : true;
 /** Remove compatible Services from a union while retaining all other identities. */
-type RemoveCompatibleServices<Provided extends AnyService, Replacements extends AnyService> = Provided extends AnyService ? true extends (Replacements extends AnyService ? SameService<Provided, Replacements> : false) ? never : Provided : never;
-type HasCompatibleService<Provided extends AnyService, Replacements extends AnyService> = true extends (Replacements extends AnyService ? SameService<Provided, Replacements> : false) ? true : false;
+type RemoveCompatibleServices<Provided extends AnyService, Replacements extends AnyService> = Provided extends AnyService ? HasMatchingServiceTag<Provided, Replacements> extends true ? true extends (Replacements extends AnyService ? SameService<Provided, Replacements> : false) ? never : Provided : Provided : never;
+type HasCompatibleService<Provided extends AnyService, Replacements extends AnyService> = HasMatchingServiceTag<Provided, Replacements> extends true ? true extends (Replacements extends AnyService ? SameService<Provided, Replacements> : false) ? true : false : false;
 type RemoveCompatibleEntries<Entries extends AnyProviderEntry, Replacements extends AnyService> = Entries extends ProviderEntry<infer Provided, any> ? HasCompatibleService<Provided, Replacements> extends true ? never : Entries : never;
 type ReplacePreciseOne<Entries extends AnyProviderEntry, Replacement extends LayerInput> = RemoveCompatibleEntries<Entries, Extract<ProvidedEnvironment<Replacement>, AnyService>> | PreciseEntries<Replacement>;
 type ReplaceErasedOne<Erased extends AnyErasedProvenance, Replacement extends LayerInput> = Erased extends ErasedProvenance<infer Provided, infer StickyRequired> ? ErasedProvenance<RemoveCompatibleServices<Provided, Extract<ProvidedEnvironment<Replacement>, AnyService>>, StickyRequired> : never;
@@ -104,13 +105,9 @@ type MergeLayerResult<Layers extends readonly LayerInput[]> = HasUncheckedLayerI
 /** Internal result type for Layer.merge. */
 type MergeResult<Layers extends readonly LayerInput[]> = MergeLayerResult<Layers>;
 type OverrideLayerResultUnchecked<Base extends LayerInput, Overrides extends readonly LayerInput[]> = HasUncheckedLayerInTuple<[Base, ...Overrides]> extends true ? Layer<any, any> : LayerResult<ApplyPreciseOverrides<PreciseEntries<Base>, Overrides>, ApplyErasedOverrides<ErasedEntries<Base>, Overrides>>;
-/** Internal result type for Layer.override. */
-type OverrideResult<Base extends LayerInput, Replacement extends LayerInput> = OverrideLayerResultUnchecked<Base, readonly [Replacement]>;
 /** Internal result type for an ordered override tuple. */
 type OverrideLayerResult<Base extends LayerInput, Overrides extends readonly LayerInput[]> = OverrideLayerResultUnchecked<Base, Overrides>;
 type IncompatibleOverridePair<Current extends AnyService, Replacement extends AnyService> = SameServiceTag<Current, Replacement> extends true ? SameServiceContract<Current, Replacement> extends true ? never : ServiceTokenOf<Replacement> : never;
-/** Fully distributive same-tag incompatible override comparison. */
-type IncompatibleOverridePairs<CurrentProvided extends AnyService, ReplacementProvided extends AnyService> = CurrentProvided extends AnyService ? ReplacementProvided extends AnyService ? IncompatibleOverridePair<CurrentProvided, ReplacementProvided> : never : never;
 type IncompatibleLayerOverride<Tokens extends AnyServiceToken> = {
   readonly __betterEffectIncompatibleLayerOverride: Tokens;
 };
@@ -118,10 +115,25 @@ type InvalidWidenedProvidedEnvironment = {
   readonly __betterEffectWidenedProvidedEnvironment: unique symbol;
 };
 type ValidateOverrideLayerInput<L extends LayerInput> = IsExactUncheckedLayer<L> extends true ? unknown : ValidateLayerInput<L> & (true extends HasWidenedTag<Extract<ProvidedEnvironment<L>, AnyService>> ? InvalidWidenedProvidedEnvironment : unknown);
-/** Validate one override against the currently accumulated Layer state. */
-type ValidateOneOverride<Current extends LayerInput, Replacement extends LayerInput> = ValidateOverrideLayerInput<Current> & ValidateOverrideLayerInput<Replacement> & (IsExactUncheckedLayer<Current> extends true ? unknown : IsExactUncheckedLayer<Replacement> extends true ? unknown : [IncompatibleOverridePairs<Extract<ProvidedEnvironment<Current>, AnyService>, Extract<ProvidedEnvironment<Replacement>, AnyService>>] extends [never] ? unknown : IncompatibleLayerOverride<IncompatibleOverridePairs<Extract<ProvidedEnvironment<Current>, AnyService>, Extract<ProvidedEnvironment<Replacement>, AnyService>>>);
+type ValidateOverrideTuple<Overrides extends readonly LayerInput[]> = { [Index in keyof Overrides]: ValidateOverrideLayerInput<Overrides[Index]>; };
+type ServiceAtTag<Services, Tag extends string> = Tag extends keyof Services ? Extract<Services[Tag], AnyService> : never;
+type ServiceTagMap<Services extends AnyService> = { [Tag in ServiceTagOf<Services>]: Extract<Services, {
+  readonly [ServiceIdentityTypeId]: Tag;
+}>; };
+type ExactMapOverrideMatch<Current, Replacement extends AnyService> = [MapServicesAtTag<Current, ServiceTagOf<Replacement>>] extends [never] ? true : [MapServicesAtTag<Current, ServiceTagOf<Replacement>>] extends [Replacement] ? [Replacement] extends [MapServicesAtTag<Current, ServiceTagOf<Replacement>>] ? true : false : false;
+type CanSkipBaseOverride<Current, Replacement extends AnyService> = false extends (Replacement extends AnyService ? [MapServicesAtTag<Current, ServiceTagOf<Replacement>>] extends [never] ? false : ExactMapOverrideMatch<Current, Replacement> : never) ? false : true;
+type MapServicesAtTag<Maps, Tag extends string> = Maps extends unknown ? ServiceAtTag<Maps, Tag> : never;
+type IncompatibleOverridePairsForValidation<CurrentProvided extends AnyService, Replacement extends AnyService> = CurrentProvided extends AnyService ? Replacement extends AnyService ? IncompatibleOverridePair<CurrentProvided, Replacement> : never : never;
+type ApplyValidationOverride<CurrentProvided extends AnyService, ReplacementProvided extends AnyService> = RemoveCompatibleServices<CurrentProvided, ReplacementProvided> | ReplacementProvided;
+type ValidateOverridePair<CurrentProvided extends AnyService, ReplacementProvided extends AnyService> = IncompatibleOverridePairsForValidation<CurrentProvided, ReplacementProvided> extends (infer Incompatible) ? [Incompatible] extends [never] ? unknown : IncompatibleLayerOverride<Extract<Incompatible, AnyServiceToken>> : never;
+/**
+ * Validate overrides while carrying only the current provided union.
+ * Rebuilding the full Layer provenance for every step is quadratic and can
+ * exhaust TypeScript's instantiation depth on otherwise simple override lists.
+ */
+type ValidateOverridesFromState<Overrides extends readonly LayerInput[], BaseMap, CurrentProvided extends AnyService, CurrentChanged extends boolean, CurrentUnchecked extends boolean> = Overrides extends readonly [infer Head extends LayerInput, ...infer Tail extends readonly LayerInput[]] ? CurrentUnchecked extends true ? ValidateOverridesFromState<Tail, BaseMap, AnyService, true, true> : IsExactUncheckedLayer<Head> extends true ? ValidateOverridesFromState<Tail, BaseMap, AnyService, true, true> : CurrentChanged extends false ? CanSkipBaseOverride<BaseMap, Extract<ProvidedEnvironment<Head>, AnyService>> extends true ? ValidateOverridesFromState<Tail, BaseMap, CurrentProvided, false, false> : ValidateOverridePair<CurrentProvided, Extract<ProvidedEnvironment<Head>, AnyService>> & ValidateOverridesFromState<Tail, BaseMap, ApplyValidationOverride<CurrentProvided, Extract<ProvidedEnvironment<Head>, AnyService>>, true, false> : ValidateOverridePair<CurrentProvided, Extract<ProvidedEnvironment<Head>, AnyService>> & ValidateOverridesFromState<Tail, BaseMap, ApplyValidationOverride<CurrentProvided, Extract<ProvidedEnvironment<Head>, AnyService>>, true, false> : unknown;
 /** Validate ordered overrides against the state produced by earlier overrides. */
-type ValidateOverrides<Base extends LayerInput, Overrides extends readonly LayerInput[]> = Overrides extends readonly [infer Head extends LayerInput, ...infer Tail extends readonly LayerInput[]] ? ValidateOneOverride<Base, Head> & ValidateOverrides<OverrideResult<Base, Head>, Tail> : unknown;
+type ValidateOverrides<Base extends LayerInput, Overrides extends readonly LayerInput[]> = Overrides extends readonly [] ? unknown : ValidateOverrideLayerInput<Base> & ValidateOverrideTuple<Overrides> & ValidateOverridesFromState<Overrides, ServiceTagMap<Extract<ProvidedEnvironment<Base>, AnyService>>, Extract<ProvidedEnvironment<Base>, AnyService>, false, IsExactUncheckedLayer<Base>>;
 /** A Layer accepted by Runtime boundaries after completeness validation. */
 type CompleteInput<L extends LayerInput> = ValidateLayerInput<L> & (LayerInputState<L> extends 'unchecked' ? L : LayerInputState<L> extends 'typed' ? [RequiredEnvironment<L>] extends [never] ? L : L & MissingDependencies<Extract<RequiredEnvironment<L>, AnyService>> : L);
 type ExecutionRequirementsMissing<RootProvided extends AnyService, Request extends LayerInput> = MissingServices<Extract<RequiredEnvironment<Request>, AnyService>, Extract<RootProvided, AnyService>>;
@@ -182,7 +194,9 @@ declare class Layer<in out Provided extends AnyService = AnyService, out Require
   /** Mark a Layer composition root as complete without changing its runtime value. */
   static complete<L extends LayerInput>(layer: L & CompleteInput<L>): L;
   /** Replace providers in a base Layer, using tag identity and compatible contracts. */
-  static override<Base extends LayerInput, const Overrides extends readonly LayerInput[]>(base: Base & ValidateLayerInput<Base>, ...overrides: Overrides & ValidateOverrides<Base, Overrides>): OverrideLayerResult<Base, Overrides>;
+  static override<Base extends LayerInput>(base: Base & ValidateLayerInput<Base>): OverrideLayerResult<Base, readonly []>;
+  static override<Base extends LayerInput, const Overrides extends readonly [LayerInput, ...LayerInput[]]>(base: Base & ValidateLayerInput<Base>, ...overrides: Overrides & ValidateOverrides<Base, Overrides>): OverrideLayerResult<Base, Overrides>;
+  static override<Base extends LayerInput, const Overrides extends readonly LayerInput[]>(base: Base & ValidateLayerInput<Base>, ...overrides: Overrides extends readonly [LayerInput, ...LayerInput[]] ? never : Overrides & ValidateOverrides<Base, Overrides>): OverrideLayerResult<Base, Overrides>;
 }
 /** Type-level aliases for inspecting Layer environments and completeness. */
 declare namespace Layer {
@@ -305,5 +319,5 @@ type RuntimeDisposeOptions = {
   readonly abortAfterGracePeriod?: boolean;
 };
 //#endregion
-export { ProvidedEnvironment as S, Layer as _, RuntimeShutdownDiagnostic as a, CompleteInput as b, RuntimeObserver as c, RuntimeServiceResolveEvent as d, DuplicateServiceError as f, ServiceTagCollisionError as g, LayerRegistrationError as h, RuntimeRunOptions as i, RuntimeResourceReleaseEvent as l, LayerGeneratorYieldError as m, RuntimeDisposeOptions as n, RuntimeExecutionEndEvent as o, LayerDisposeError as p, RuntimeOptions as r, RuntimeExecutionStartEvent as s, CleanupFailureObserver as t, RuntimeServiceAcquireEvent as u, CompleteExecution as v, LayerInput as x, CompleteExecutionLayer as y };
-//# sourceMappingURL=index-fUyY0eNJ.d.mts.map
+export { ProvidedEnvironment as C, LayerResult as S, Layer as _, RuntimeShutdownDiagnostic as a, CompleteInput as b, RuntimeObserver as c, RuntimeServiceResolveEvent as d, DuplicateServiceError as f, ServiceTagCollisionError as g, LayerRegistrationError as h, RuntimeRunOptions as i, RuntimeResourceReleaseEvent as l, LayerGeneratorYieldError as m, RuntimeDisposeOptions as n, RuntimeExecutionEndEvent as o, LayerDisposeError as p, RuntimeOptions as r, RuntimeExecutionStartEvent as s, CleanupFailureObserver as t, RuntimeServiceAcquireEvent as u, CompleteExecution as v, ProviderEntry as w, LayerInput as x, CompleteExecutionLayer as y };
+//# sourceMappingURL=index-CYAgpM_5.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-CYAgpM_5.d.mts","names":[],"sources":["../src/internal/variance.ts","../src/internal/missing-dependencies.ts","../src/layer/metadata.ts","../src/layer/inference.ts","../src/layer/layer.ts","../src/layer/errors.ts","../src/runtime/observer.ts","../src/runtime/outcome.ts"],"mappings":"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"}

package/dist/index.d.mts

@@ -1,321 +1,6 @@
-import { A as ProgramFromGenerator, C as EffectError, D as EffectYield, E as EffectSuccess, F as ServiceContract, H as ServiceTokenOf, I as ServiceIdentity, L as ServiceInstance, M as AnyService, N as AnyServiceToken, P as ServiceClass, R as ServiceRequirements, S as Effect$1, T as EffectRequirements, V as ServiceToken, _ as ScopeCloseError, a as ServiceResolver, b as Service, c as RuntimeContextStorage, d as CleanupFailureDiagnostic, f as DisposableResource, g as ResourceNotDisposableError, h as ScopeOutcome, i as ServiceRuntimeNotConfiguredError, j as ServiceRequirement, k as Program, l as CloseableScope, m as ScopeFinalizer, n as ServiceAcquisitionError, o as ServiceRuntime, p as MaybePromise$1, r as ServiceNotFoundError, s as RuntimeContext, t as CircularDependencyError, u as Scope, v as ScopeClosedError, w as EffectFromGenerator, x as AnyEffect, y as ScopeRuntimeNotConfiguredError, z as ServiceTag } from "./index-BFgG9zZC.mjs";
-import { S as ProvidedEnvironment, _ as Layer, a as RuntimeShutdownDiagnostic, b as CompleteInput, c as RuntimeObserver, d as RuntimeServiceResolveEvent, f as DuplicateServiceError, g as ServiceTagCollisionError, h as LayerRegistrationError, i as RuntimeRunOptions, l as RuntimeResourceReleaseEvent, m as LayerGeneratorYieldError, n as RuntimeDisposeOptions, o as RuntimeExecutionEndEvent, p as LayerDisposeError, r as RuntimeOptions, s as RuntimeExecutionStartEvent, t as CleanupFailureObserver, u as RuntimeServiceAcquireEvent, v as CompleteExecution, x as LayerInput, y as CompleteExecutionLayer } from "./index-fUyY0eNJ.mjs";
-import { a as LayerRegistration, n as LayerBackend, t as MapLayerBackend } from "./map-layer-backend-CGibcwkc.mjs";
+import { B as ServiceTag, C as EffectError, D as EffectYield, E as EffectSuccess, F as ServiceContract, H as ServiceToken, I as ServiceIdentity, M as AnyService, N as AnyServiceToken, P as ServiceClass, R as ServiceInstance, T as EffectRequirements, U as ServiceTokenOf, _ as ScopeCloseError, a as ServiceResolver, b as Service, c as RuntimeContextStorage, d as CleanupFailureDiagnostic, f as DisposableResource, g as ResourceNotDisposableError, h as ScopeOutcome, i as ServiceRuntimeNotConfiguredError, j as ServiceRequirement, l as CloseableScope, m as ScopeFinalizer, n as ServiceAcquisitionError, o as ServiceRuntime, r as ServiceNotFoundError, s as RuntimeContext, t as CircularDependencyError, u as Scope, v as ScopeClosedError, x as AnyEffect, y as ScopeRuntimeNotConfiguredError, z as ServiceRequirements } from "./index-1NLNdkJy.mjs";
+import { _ as Layer, a as RuntimeShutdownDiagnostic, c as RuntimeObserver, d as RuntimeServiceResolveEvent, f as DuplicateServiceError, g as ServiceTagCollisionError, h as LayerRegistrationError, i as RuntimeRunOptions, l as RuntimeResourceReleaseEvent, m as LayerGeneratorYieldError, n as RuntimeDisposeOptions, o as RuntimeExecutionEndEvent, p as LayerDisposeError, r as RuntimeOptions, s as RuntimeExecutionStartEvent, t as CleanupFailureObserver, u as RuntimeServiceAcquireEvent } from "./index-CYAgpM_5.mjs";
+import { a as LayerRegistration, n as LayerBackend, t as MapLayerBackend } from "./map-layer-backend-DMJauecV.mjs";
+import { a as AcquireUseReleaseOptions, c as ReleaseOutcome, d as Effect, f as Program, i as Resource, l as ResourceReleaseFailure, n as Runtime, o as AsyncResult, p as ProgramAllOptions, r as RuntimeFor, s as ReleaseFailureObserver, t as CurrentAbortSignal, u as pipe } from "./index-BJFBEsm5.mjs";
 import { t as RuntimeContextNotConfiguredError } from "./errors-BXKc7juX.mjs";
-import { Err, Result, UnhandledException } from "better-result";
-//#region src/effect/combinators.d.ts
-type EffectInput<A, E> = Result<A, E> | PromiseLike<Result<A, E>>;
-type AnyEffectInput = EffectInput<any, any>;
-type AnyEffectValue = Result<any, any>;
-type AnyAsyncEffectInput = PromiseLike<Result<any, any>>;
-type PreserveAsync<Input, Output> = Input extends PromiseLike<unknown> ? Promise<Output> : Output;
-type MappedResult<Input, B> = Effect$1<B, EffectError<Input>, EffectRequirements<Input>>;
-type ErrorMappedResult<Input, E2> = Effect$1<EffectSuccess<Input>, E2, EffectRequirements<Input>>;
-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> = {
-  <Input>(effect: Input & EffectInput<A, any>): PreserveAsync<Input, MappedResult<Input, B>>;
-};
-type MapErrorOperation<E1, E2> = {
-  <Input>(effect: Input & EffectInput<any, E1>): PreserveAsync<Input, ErrorMappedResult<Input, E2>>;
-};
-type AndThenOperation<Next> = {
-  <Input>(effect: Input & AnyEffectValue): ChainedOutput<Input, Next>;
-};
-type AndThenAsyncOperation<A, Next> = {
-  <Input>(effect: Input & EffectInput<A, any>): AsyncChainedOutput<Input, Next>;
-};
-/**
- * Map the successful value of a Result or Effect result.
- *
- * Supports both data-first and data-last forms and preserves asynchronous
- * results and declaration-only Service requirements.
- *
- * @example
- * ```ts
- * const doubled = Effect.map(Result.ok(2), (value) => value * 2)
- * 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>>;
-/**
- * Map the error value of a Result or Effect result while preserving its
- * successful value, asynchronous shape, and declaration-only Service requirements.
- *
- * @example
- * ```ts
- * 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>>;
-/**
- * Chain a synchronous Result-producing operation after a successful result.
- *
- * The next operation is skipped when the input is an error. Both error types
- * and both sets of Service requirements are preserved in the output.
- *
- * @example
- * ```ts
- * 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>;
-/**
- * Chain an asynchronous Result-producing operation after a successful result.
- *
- * The returned value is always a Promise and retains both operations' error
- * and Service-requirement metadata.
- *
- * @example
- * ```ts
- * const user = Effect.andThenAsync(loadUser(), (user) => fetchProfile(user.id))
- * ```
- */
-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>;
-//#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<A, E, R>;
-type AnyResult = Result<any, any>;
-/**
- * Compose `better-result` operations while preserving Service requirements in
- * a declaration-only type channel.
- *
- * A generator may yield Service tokens and Result operations. It must return a
- * `Result` as its final value; Service yields are resolved by the active
- * Runtime and do not add runtime values to the Result stream.
- * Use `fn` when generator execution should wait for a Runtime boundary.
- *
- * @example
- * ```ts
- * const loadUser = Effect.gen(async function* () {
- *   const database = yield* Database
- *   const user = yield* Result.await(database.findUser('u1'))
- *
- *   return Result.ok(user)
- * })
- * ```
- */
-declare function gen<Yield extends EffectYield, Returned extends AnyResult>(body: () => Generator<Yield, Returned, unknown>): EffectFromGenerator<Yield, Returned>;
-declare function gen<Yield extends EffectYield, Returned extends AnyResult>(body: () => AsyncGenerator<Yield, Returned, unknown>): Promise<EffectFromGenerator<Yield, Returned>>;
-/** 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>;
-/**
- * Acquire a resource in the current Scope and register its release callback.
- *
- * Acquisition failures are represented in the Effect Result error channel;
- * release failures remain owned by Scope cleanup. The release callback
- * receives the final outcome chosen by the enclosing execution boundary.
- *
- * @example
- * ```ts
- * const connection = yield* Effect.acquireRelease(
- *   () => pool.connect(),
- *   (connection, outcome) => connection.close(outcome)
- * )
- * ```
- */
-declare function acquireRelease<R>(acquire: () => MaybePromise$1<R>, release: (resource: R, outcome: ScopeOutcome) => MaybePromise$1<void>): AsyncGenerator<Err<never, UnhandledException>, R, unknown>;
-/**
- * Register an already-acquired disposable resource in the current Scope.
- *
- * The resource is not acquired by this helper. Registration failures are
- * represented in the Effect Result error channel; disposal failures remain
- * owned by Scope cleanup.
- *
- * @example
- * ```ts
- * const file = yield* Effect.add(await openFile('notes.txt'))
- * ```
- */
-declare function add<R extends DisposableResource>(resource: R): AsyncGenerator<Err<never, UnhandledException>, R, unknown>;
-/**
- * Effect namespace containing generator, resource, and Result combinators.
- *
- * Prefer these helpers when a program needs typed Service requirements or
- * Scope-aware acquisition and cleanup.
- */
-declare const Effect: {
-  /** Compose a generator-based Effect program. */
-  readonly gen: typeof gen;
-  /** Build a lazy Program from a generator. */
-  readonly fn: typeof fn;
-  /** Acquire and register a resource in the current Scope. */
-  readonly acquireRelease: typeof acquireRelease;
-  /** Register an already-acquired disposable in the current Scope. */
-  readonly add: typeof add;
-  /** Map a successful Effect result. */
-  readonly map: typeof map;
-  /** Map an Effect error. */
-  readonly mapError: typeof mapError;
-  /** Chain a synchronous Effect result. */
-  readonly andThen: typeof andThen;
-  /** Chain an asynchronous Effect result. */
-  readonly andThenAsync: typeof andThenAsync;
-};
-/** Type-level aliases for inspecting Effect result channels and requirements. */
-declare namespace Effect {
-  /** A nominal lazy computation that produces an Effect when invoked. */
-  type Program<A, E, R extends AnyService = never> = LazyProgram<A, E, R>;
-  /** Extract the success channel from an Effect result or Promise. */
-  type Success<T> = EffectSuccess<T>;
-  /** Extract the error channel from an Effect result or Promise. */
-  type Error<T> = EffectError<T>;
-  /** Extract the Service requirements from an Effect result or Promise. */
-  type Requirements<T> = EffectRequirements<T>;
-  /** An Effect with erased success, error, and requirements. */
-  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
-//#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
-export { type AcquireUseReleaseOptions, type AnyEffect, type AnyService, type AnyServiceToken, type AsyncResult, CircularDependencyError, type CleanupFailureDiagnostic, type CleanupFailureObserver, type CloseableScope, CurrentAbortSignal, type DisposableResource, DuplicateServiceError, Effect, type EffectError, type EffectRequirements, type EffectSuccess, type EffectYield, Layer, type LayerBackend, LayerDisposeError, LayerGeneratorYieldError, type LayerRegistration, LayerRegistrationError, MapLayerBackend, type Program, type ReleaseFailureObserver, type ReleaseOutcome, Resource, ResourceNotDisposableError, ResourceReleaseFailure, Runtime, type RuntimeContext, RuntimeContextNotConfiguredError, type RuntimeContextStorage, type RuntimeDisposeOptions, type RuntimeExecutionEndEvent, type RuntimeExecutionStartEvent, type RuntimeFor, type RuntimeObserver, type RuntimeOptions, type RuntimeResourceReleaseEvent, type RuntimeRunOptions, type RuntimeServiceAcquireEvent, type RuntimeServiceResolveEvent, type RuntimeShutdownDiagnostic, Scope, ScopeCloseError, ScopeClosedError, type ScopeFinalizer, type ScopeOutcome, ScopeRuntimeNotConfiguredError, Service, ServiceAcquisitionError, type ServiceClass, type ServiceContract, type ServiceIdentity, type ServiceInstance, ServiceNotFoundError, type ServiceRequirement, type ServiceRequirements, type ServiceResolver, ServiceRuntime, ServiceRuntimeNotConfiguredError, type ServiceTag, ServiceTagCollisionError, type ServiceToken, type ServiceTokenOf, pipe };
-//# sourceMappingURL=index.d.mts.map
+export { type AcquireUseReleaseOptions, type AnyEffect, type AnyService, type AnyServiceToken, type AsyncResult, CircularDependencyError, type CleanupFailureDiagnostic, type CleanupFailureObserver, type CloseableScope, CurrentAbortSignal, type DisposableResource, DuplicateServiceError, Effect, type EffectError, type EffectRequirements, type EffectSuccess, type EffectYield, Layer, type LayerBackend, LayerDisposeError, LayerGeneratorYieldError, type LayerRegistration, LayerRegistrationError, MapLayerBackend, Program, type ProgramAllOptions, type ReleaseFailureObserver, type ReleaseOutcome, Resource, ResourceNotDisposableError, ResourceReleaseFailure, Runtime, type RuntimeContext, RuntimeContextNotConfiguredError, type RuntimeContextStorage, type RuntimeDisposeOptions, type RuntimeExecutionEndEvent, type RuntimeExecutionStartEvent, type RuntimeFor, type RuntimeObserver, type RuntimeOptions, type RuntimeResourceReleaseEvent, type RuntimeRunOptions, type RuntimeServiceAcquireEvent, type RuntimeServiceResolveEvent, type RuntimeShutdownDiagnostic, Scope, ScopeCloseError, ScopeClosedError, type ScopeFinalizer, type ScopeOutcome, ScopeRuntimeNotConfiguredError, Service, ServiceAcquisitionError, type ServiceClass, type ServiceContract, type ServiceIdentity, type ServiceInstance, ServiceNotFoundError, type ServiceRequirement, type ServiceRequirements, type ServiceResolver, ServiceRuntime, ServiceRuntimeNotConfiguredError, type ServiceTag, ServiceTagCollisionError, type ServiceToken, type ServiceTokenOf, pipe };