better-effect 0.2.0 → 0.3.0

package/dist/index-Bg6ofRE1.d.mts

@@ -0,0 +1,232 @@
+import { Err, InferErr, InferOk, Result } from "better-result";
+//#region src/service/types.d.ts
+type ServiceToken<A = unknown> = (abstract new (...args: any[]) => A) & {
+  readonly name: string;
+};
+type AnyServiceToken = ServiceToken<any>;
+type ServiceClass<A = unknown> = (new (...args: any[]) => A) & {
+  readonly name: string;
+};
+type ServiceInstance<T extends AnyServiceToken> = InstanceType<T>;
+type MethodRequirements<T> = { [K in keyof T]: T[K] extends ((...args: any[]) => infer Return) ? EffectRequirements<Return> : never; }[keyof T];
+/** Services required by the Effect-returning methods of a Service class. */
+type ServiceRequirements<T extends AnyServiceToken> = MethodRequirements<InstanceType<T>>;
+//#endregion
+//#region src/effect/types.d.ts
+/**
+ * Type-only identity for a Service requirement yielded by a generator.
+ *
+ * The declaration has no runtime value. Service iterators return their
+ * resolved instances without yielding a marker at runtime.
+ */
+declare const ServiceRequirementTypeId: unique symbol;
+/** Type-only identity for requirement metadata attached to Effect results. */
+declare const EffectRequirementsTypeId: unique symbol;
+/**
+ * Metadata carried by the yield type of a Service token.
+ *
+ * This interface is intentionally phantom: it is used only while TypeScript
+ * infers a generator's yielded values.
+ */
+interface ServiceRequirement<T extends AnyServiceToken> {
+  readonly [ServiceRequirementTypeId]: T;
+}
+/**
+ * A better-result Result with phantom metadata for required Services.
+ */
+type EffectResult<A, E, Requirements = never> = Result<A, E> & {
+  readonly [EffectRequirementsTypeId]?: Requirements;
+};
+type AnyEffectResult = EffectResult<unknown, unknown, any>;
+/** Values that an Effect generator may yield. */
+type EffectYield = Err<never, unknown> | ServiceRequirement<AnyServiceToken>;
+/** Extract the error channel from Result values yielded by a generator. */
+type InferYieldError<Y> = Y extends Err<never, infer E> ? E : never;
+/** Extract Service tokens carried by yielded Service requirements. */
+type InferYieldRequirements<Y> = Y extends ServiceRequirement<infer Requirement> ? Requirement : never;
+type InferEffectRequirements<T> = T extends unknown ? typeof EffectRequirementsTypeId extends keyof T ? T extends {
+  readonly [EffectRequirementsTypeId]?: infer Requirements;
+} ? Requirements : never : never : never;
+/** Extract phantom Service requirements from an Effect result or Promise. */
+type EffectRequirements<T> = InferEffectRequirements<Awaited<T>>;
+/** Extract the success value from an Effect result or Promise. */
+type EffectSuccess<T> = Awaited<T> extends Result<infer A, unknown> ? A : never;
+/** Extract the error value from an Effect result or Promise. */
+type EffectError<T> = Awaited<T> extends Result<unknown, infer E> ? E : never;
+/** Build the public result type produced from an Effect generator. */
+type EffectFromGenerator<Yield, Returned extends Result<any, any>> = EffectResult<InferOk<Returned>, InferYieldError<Yield> | InferErr<Returned>, InferYieldRequirements<Yield> | EffectRequirements<Returned>>;
+//#endregion
+//#region src/service/service.d.ts
+declare function Service<Self>(): {
+  new (): {};
+  [Symbol.asyncIterator](this: ServiceToken<Self>): AsyncGenerator<ServiceRequirement<ServiceToken<Self>>, Self, unknown>;
+};
+//#endregion
+//#region src/service/runtime.d.ts
+interface ServiceResolver {
+  resolve<T extends AnyServiceToken>(token: T): InstanceType<T> | PromiseLike<InstanceType<T>>;
+}
+declare class ServiceRuntime {
+  static run<A>(resolver: ServiceResolver, program: () => A): A;
+  static current(): ServiceResolver;
+  static resolve<T extends AnyServiceToken>(token: T): Promise<InstanceType<T>>;
+}
+//#endregion
+//#region src/service/errors.d.ts
+declare class ServiceRuntimeNotConfiguredError extends Error {
+  constructor();
+}
+declare class ServiceNotFoundError extends Error {
+  readonly service: AnyServiceToken;
+  constructor(service: AnyServiceToken);
+}
+//#endregion
+//#region src/scope/errors.d.ts
+declare class ScopeRuntimeNotConfiguredError extends Error {
+  constructor();
+}
+declare class ScopeClosedError extends Error {
+  constructor();
+}
+declare class ScopeCloseError extends Error {
+  readonly causes: readonly unknown[];
+  constructor(causes: readonly unknown[]);
+}
+declare class ResourceNotDisposableError extends Error {
+  constructor();
+}
+//#endregion
+//#region src/scope/types.d.ts
+type MaybePromise$1<T> = T | PromiseLike<T>;
+type ScopeOutcome = {
+  readonly status: 'success';
+} | {
+  readonly status: 'failure';
+  readonly cause: unknown;
+};
+type ScopeFinalizer = (outcome: ScopeOutcome) => MaybePromise$1<void>;
+type CleanupFailureDiagnostic = {
+  readonly outcome: ScopeOutcome;
+  readonly error: ScopeCloseError;
+};
+type SyncDisposableResource = {
+  [Symbol.dispose]: () => void;
+  [Symbol.asyncDispose]?: () => MaybePromise$1<void>;
+};
+type AsyncDisposableResource = {
+  [Symbol.dispose]?: () => void;
+  [Symbol.asyncDispose]: () => MaybePromise$1<void>;
+};
+type DisposableResource = SyncDisposableResource | AsyncDisposableResource;
+//#endregion
+//#region src/utils/types.d.ts
+type MaybePromise<T> = T | PromiseLike<T>;
+//#endregion
+//#region src/layer/types.d.ts
+interface LayerProvider {
+  readonly service: ServiceClass<any>;
+  readonly acquire: () => MaybePromise<unknown>;
+  readonly release?: (instance: unknown, outcome: ScopeOutcome) => MaybePromise<void>;
+}
+type LayerSpec<Provided extends AnyServiceToken, Required extends AnyServiceToken = never> = {
+  readonly provided: Provided;
+  readonly required: Required;
+};
+type AnyLayerSpec = LayerSpec<AnyServiceToken, AnyServiceToken>;
+type LayerGenerator<S extends ServiceClass<any>, Yield extends ServiceRequirement<AnyServiceToken> = ServiceRequirement<AnyServiceToken>> = () => AsyncGenerator<Yield, InstanceType<S>, unknown>;
+type LayerGeneratorRequirements<S extends ServiceClass<any>, Yield extends ServiceRequirement<AnyServiceToken>> = ServiceRequirements<S> | InferYieldRequirements<Yield>;
+//#endregion
+//#region src/layer/inference.d.ts
+type AnyLayer = Layer<any>;
+type LayerSpecs<L extends AnyLayer> = L extends Layer<infer Specs> ? Specs : never;
+type LayerProvided<L extends AnyLayer> = LayerSpecs<L> extends LayerSpec<infer Provided, any> ? Provided : never;
+type LayerRawRequired<L extends AnyLayer> = LayerSpecs<L> extends LayerSpec<any, infer Required> ? Required : never;
+type LayerSpecProvided<Specs extends AnyLayerSpec> = Specs extends LayerSpec<infer Provided, any> ? Provided : never;
+type SameServiceToken<Left extends AnyServiceToken, Right extends AnyServiceToken> = [Left] extends [Right] ? [Right] extends [Left] ? true : false : false;
+type IsOverridden<Provided extends AnyServiceToken, Replacements extends AnyServiceToken> = Replacements extends AnyServiceToken ? SameServiceToken<Provided, Replacements> : false;
+type RemoveOverriddenSpecs<Specs extends AnyLayerSpec, Replacements extends AnyServiceToken> = Specs extends LayerSpec<infer Provided, any> ? true extends IsOverridden<Provided, Replacements> ? never : Specs : never;
+type ReplaceLayerSpecs<Current extends AnyLayerSpec, Replacement extends AnyLayerSpec> = RemoveOverriddenSpecs<Current, LayerSpecProvided<Replacement>> | Replacement;
+type OverrideLayerSpecs<Current extends AnyLayerSpec, Overrides extends readonly AnyLayer[]> = Overrides extends readonly [infer Head extends AnyLayer, ...infer Tail extends readonly AnyLayer[]] ? OverrideLayerSpecs<ReplaceLayerSpecs<Current, LayerSpecs<Head>>, Tail> : Current;
+type RequirementProvided<Requirement extends AnyServiceToken, Provided extends AnyServiceToken> = Provided extends AnyServiceToken ? Provided extends (abstract new (...args: any[]) => InstanceType<Requirement>) ? true : false : false;
+type MissingRequirement<Requirement extends AnyServiceToken, Provided extends AnyServiceToken> = true extends RequirementProvided<Requirement, Provided> ? never : Requirement;
+/** Service tokens from `Required` that are not supplied by `Provided`. */
+type MissingServices<Required, Provided extends AnyServiceToken> = Required extends AnyServiceToken ? MissingRequirement<Required, Provided> : never;
+type LayerMissing<L extends AnyLayer> = MissingServices<LayerRawRequired<L>, LayerProvided<L>>;
+type MissingLayerServices<Missing extends AnyServiceToken> = {
+  readonly __betterEffectMissingServices: Missing;
+};
+type CompleteLayer<L extends AnyLayer> = [LayerMissing<L>] extends [never] ? L : L & MissingLayerServices<LayerMissing<L>>;
+/** Services required by an execution result that are not in its environment. */
+type ExecutionMissing<Provided extends AnyServiceToken, ProgramResult> = MissingServices<EffectRequirements<ProgramResult>, Provided>;
+/** Named diagnostic contract for an execution with unavailable Services. */
+type MissingRuntimeServices<Missing extends AnyServiceToken> = {
+  readonly __betterEffectMissingRuntimeServices: Missing;
+};
+type ExecutionProgram<A> = () => A | PromiseLike<A>;
+/** Keep execution callbacks unchanged when their Effect requirements are met. */
+type CompleteExecution<Provided extends AnyServiceToken, A> = [ExecutionMissing<Provided, A>] extends [never] ? ExecutionProgram<A> : ExecutionProgram<A> & MissingRuntimeServices<ExecutionMissing<Provided, A>>;
+//#endregion
+//#region src/layer/layer.d.ts
+declare const LayerTypeId: unique symbol;
+declare class Layer<Specs extends AnyLayerSpec = AnyLayerSpec> {
+  readonly [LayerTypeId]: Specs;
+  readonly providers: readonly LayerProvider[];
+  private constructor();
+  static make<S extends ServiceClass<any>>(service: S, acquire: () => MaybePromise<InstanceType<S>>): Layer<LayerSpec<S, ServiceRequirements<S>>>;
+  static succeed<S extends ServiceClass<any>>(service: S, instance: InstanceType<S>): Layer<LayerSpec<S, ServiceRequirements<S>>>;
+  static scoped<S extends ServiceClass<any>>(service: S, acquire: () => MaybePromise<InstanceType<S>>, release: (instance: InstanceType<S>) => MaybePromise<void>): Layer<LayerSpec<S, ServiceRequirements<S>>>;
+  static scopedGen<S extends ServiceClass<any>, Yield extends ServiceRequirement<AnyServiceToken>>(service: S, factory: LayerGenerator<S, Yield>, release: (instance: InstanceType<S>, outcome: ScopeOutcome) => MaybePromise<void>): Layer<LayerSpec<S, LayerGeneratorRequirements<S, Yield>>>;
+  static gen<S extends ServiceClass<any>, Yield extends ServiceRequirement<AnyServiceToken>>(service: S, factory: LayerGenerator<S, Yield>): Layer<LayerSpec<S, LayerGeneratorRequirements<S, Yield>>>;
+  static merge<const Layers extends readonly Layer<any>[]>(...layers: Layers): Layer<Layers[number] extends Layer<infer Specs> ? Specs : never>;
+  static override<Base extends Layer<any>, const Overrides extends readonly Layer<any>[]>(base: Base, ...overrides: Overrides): Layer<OverrideLayerSpecs<Base extends Layer<infer Specs> ? Specs : never, Overrides>>;
+}
+//#endregion
+//#region src/layer/errors.d.ts
+declare class DuplicateServiceError extends Error {
+  readonly service: ServiceClass<any>;
+  constructor(service: ServiceClass<any>);
+}
+declare class LayerRegistrationError extends Error {
+  readonly service: ServiceClass<any> | undefined;
+  readonly registrationCause: unknown;
+  readonly cleanupCause?: unknown;
+  constructor(service: ServiceClass<any> | undefined, registrationCause: unknown, cleanupCause?: unknown);
+}
+declare class LayerDisposeError extends Error {
+  readonly causes: readonly unknown[];
+  constructor(causes: readonly unknown[]);
+}
+declare class LayerGeneratorYieldError extends Error {
+  readonly service: ServiceClass<any>;
+  constructor(service: ServiceClass<any>);
+}
+declare class BuiltLayerDisposedError extends Error {
+  constructor();
+}
+//#endregion
+//#region src/runtime/outcome.d.ts
+type RuntimeShutdownDiagnostic = {
+  readonly outcome: ScopeOutcome;
+  readonly error: LayerDisposeError;
+};
+type CleanupFailureObserver = (diagnostic: CleanupFailureDiagnostic | RuntimeShutdownDiagnostic) => MaybePromise$1<void>;
+type RuntimeOptions = {
+  readonly onCleanupFailure?: CleanupFailureObserver;
+};
+//#endregion
+//#region src/layer/backend.d.ts
+interface LayerBackend extends ServiceResolver {
+  register(provider: LayerProvider): void | PromiseLike<void>;
+  disposeAll(): void | PromiseLike<void>;
+}
+//#endregion
+//#region src/layer/runtime.d.ts
+interface BuiltLayer<Provided extends AnyServiceToken = AnyServiceToken> {
+  readonly backend: LayerBackend;
+  run<A>(program: CompleteExecution<Provided, A>): Promise<Awaited<A>>;
+  dispose(outcome?: ScopeOutcome): Promise<void>;
+}
+declare const buildLayer: <L extends AnyLayer>(layer: CompleteLayer<L>, backend: LayerBackend, options?: RuntimeOptions) => Promise<BuiltLayer<LayerProvided<L>>>;
+//#endregion
+export { ServiceNotFoundError as A, EffectSuccess as B, MaybePromise$1 as C, ScopeCloseError as D, ResourceNotDisposableError as E, AnyEffectResult as F, ServiceInstance as G, ServiceRequirement as H, EffectError as I, ServiceRequirements as K, EffectFromGenerator as L, ServiceResolver as M, ServiceRuntime as N, ScopeClosedError as O, Service as P, EffectRequirements as R, DisposableResource as S, ScopeOutcome as T, AnyServiceToken as U, EffectYield as V, ServiceClass as W, LayerProvided as _, RuntimeOptions as a, LayerProvider as b, DuplicateServiceError as c, LayerRegistrationError as d, Layer as f, LayerMissing as g, CompleteLayer as h, CleanupFailureObserver as i, ServiceRuntimeNotConfiguredError as j, ScopeRuntimeNotConfiguredError as k, LayerDisposeError as l, CompleteExecution as m, buildLayer as n, RuntimeShutdownDiagnostic as o, AnyLayer as p, ServiceToken as q, LayerBackend as r, BuiltLayerDisposedError as s, BuiltLayer as t, LayerGeneratorYieldError as u, LayerRawRequired as v, ScopeFinalizer as w, CleanupFailureDiagnostic as x, LayerSpecs as y, EffectResult as z };
+//# sourceMappingURL=index-Bg6ofRE1.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-Bg6ofRE1.d.mts","names":[],"sources":["../src/service/types.ts","../src/effect/types.ts","../src/service/service.ts","../src/service/runtime.ts","../src/service/errors.ts","../src/scope/errors.ts","../src/scope/types.ts","../src/utils/types.ts","../src/layer/types.ts","../src/layer/inference.ts","../src/layer/layer.ts","../src/layer/errors.ts","../src/runtime/outcome.ts","../src/layer/backend.ts","../src/layer/runtime.ts"],"mappings":"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"}

package/dist/index.d.mts

@@ -1,62 +1,50 @@
-import { a as ServiceResolver, c as ServiceClass, i as MaybePromise$1, l as ServiceInstance, n as LayerGenerator, o as ServiceRuntime, r as LayerProvider, s as AnyServiceToken, t as LayerBackend, u as ServiceToken } from "./backend-CNAls62W.mjs";
-import { Result, UnhandledException } from "better-result";
-//#region src/service/service.d.ts
-declare function Service<Self>(): {
-  new (): {};
-  [Symbol.asyncIterator](): AsyncGenerator<never, Self, unknown>;
-};
-//#endregion
-//#region src/service/errors.d.ts
-declare class ServiceRuntimeNotConfiguredError extends Error {
-  constructor();
-}
-declare class ServiceNotFoundError extends Error {
-  readonly service: AnyServiceToken;
-  constructor(service: AnyServiceToken);
+import { A as ServiceNotFoundError, B as EffectSuccess, C as MaybePromise$1, D as ScopeCloseError, E as ResourceNotDisposableError, F as AnyEffectResult, G as ServiceInstance, H as ServiceRequirement, I as EffectError, K as ServiceRequirements, L as EffectFromGenerator, M as ServiceResolver, N as ServiceRuntime, O as ScopeClosedError, P as Service, R as EffectRequirements, S as DisposableResource, T as ScopeOutcome, U as AnyServiceToken, V as EffectYield, W as ServiceClass, _ as LayerProvided, a as RuntimeOptions, c as DuplicateServiceError, d as LayerRegistrationError, f as Layer, g as LayerMissing, h as CompleteLayer, i as CleanupFailureObserver, j as ServiceRuntimeNotConfiguredError, k as ScopeRuntimeNotConfiguredError, l as LayerDisposeError, m as CompleteExecution, n as buildLayer, o as RuntimeShutdownDiagnostic, p as AnyLayer, q as ServiceToken, r as LayerBackend, s as BuiltLayerDisposedError, t as BuiltLayer, u as LayerGeneratorYieldError, v as LayerRawRequired, w as ScopeFinalizer, x as CleanupFailureDiagnostic, y as LayerSpecs, z as EffectResult } from "./index-Bg6ofRE1.mjs";
+import { Err, Result, UnhandledException } from "better-result";
+//#region src/scope/scope.d.ts
+interface Scope {
+  addFinalizer(finalizer: ScopeFinalizer): void;
+  acquire<R>(acquire: () => MaybePromise$1<R>, release: (resource: R, outcome: ScopeOutcome) => MaybePromise$1<void>): Promise<R>;
+  add<R extends DisposableResource>(resource: R): Promise<R>;
+  fork(): CloseableScope;
 }
-//#endregion
-//#region src/layer/layer.d.ts
-declare class Layer {
-  readonly providers: readonly LayerProvider[];
-  private constructor();
-  static make<S extends ServiceClass<any>>(service: S, acquire: () => MaybePromise$1<InstanceType<S>>): Layer;
-  static succeed<S extends ServiceClass<any>>(service: S, instance: InstanceType<S>): Layer;
-  static scoped<S extends ServiceClass<any>>(service: S, acquire: () => MaybePromise$1<InstanceType<S>>, release: (instance: InstanceType<S>) => MaybePromise$1<void>): Layer;
-  static gen<S extends ServiceClass<any>>(service: S, factory: LayerGenerator<S>): Layer;
-  static merge(...layers: readonly Layer[]): Layer;
-  static override(base: Layer, ...overrides: readonly Layer[]): Layer;
+interface CloseableScope extends Scope {
+  close(outcome?: ScopeOutcome): Promise<void>;
 }
+declare const Scope: {
+  readonly make: () => CloseableScope;
+  readonly current: () => Scope;
+  readonly provide: <A>(scope: Scope, program: () => A) => A;
+  readonly [Symbol.iterator]: () => Generator<never, Scope, unknown>;
+  readonly run: <A>(program: (scope: Scope) => A | PromiseLike<A>) => Promise<Awaited<A>>;
+};
 //#endregion
-//#region src/layer/runtime.d.ts
-interface BuiltLayer {
-  readonly backend: LayerBackend;
-  run<A>(program: () => A): A;
-  dispose(): Promise<void>;
-}
-declare const buildLayer: (layer: Layer, backend: LayerBackend) => Promise<BuiltLayer>;
-//#endregion
-//#region src/layer/errors.d.ts
-declare class DuplicateServiceError extends Error {
-  readonly service: ServiceClass<any>;
-  constructor(service: ServiceClass<any>);
-}
-declare class LayerRegistrationError extends Error {
-  readonly service: ServiceClass<any> | undefined;
-  readonly registrationCause: unknown;
-  readonly cleanupCause?: unknown;
-  constructor(service: ServiceClass<any> | undefined, registrationCause: unknown, cleanupCause?: unknown);
-}
-declare class LayerDisposeError extends Error {
-  readonly causes: readonly unknown[];
-  constructor(causes: readonly unknown[]);
-}
-declare class LayerGeneratorYieldError extends Error {
-  readonly service: ServiceClass<any>;
-  constructor(service: ServiceClass<any>);
-}
-declare class BuiltLayerDisposedError extends Error {
-  constructor();
-}
+//#region src/effect/effect.d.ts
+type AnyResult = Result<any, any>;
+/**
+ * Compose better-result operations while preserving Service requirements in
+ * a phantom type channel.
+ */
+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>>;
+/**
+ * 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.
+ */
+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.
+ *
+ * Registration failures are represented in the Effect Result error channel;
+ * disposal failures remain owned by Scope cleanup.
+ */
+declare function add<R extends DisposableResource>(resource: R): AsyncGenerator<Err<never, UnhandledException>, R, unknown>;
+declare const Effect: {
+  readonly gen: typeof gen;
+  readonly acquireRelease: typeof acquireRelease;
+  readonly add: typeof add;
+};
 //#endregion
 //#region src/resource/errors.d.ts
 declare const ResourceReleaseFailure_base: import("better-result").TaggedErrorClass<"ResourceReleaseFailure">;
@@ -70,10 +58,6 @@ declare class ResourceReleaseFailure extends ResourceReleaseFailure_base<{
 type MaybePromise<T> = T | PromiseLike<T>;
 type AsyncResult<T, E> = MaybePromise<Result<T, E>>;
 type ReleaseOutcome = void | Result<void, unknown>;
-type DisposableResource = {
-  [Symbol.dispose]?: () => void;
-  [Symbol.asyncDispose]?: () => MaybePromise<void>;
-};
 type ReleaseFailureObserver = (failure: ResourceReleaseFailure) => MaybePromise<void>;
 type AcquireUseReleaseOptions<R, A, AcquireError, UseError> = {
   readonly name: string;
@@ -97,14 +81,20 @@ declare const Resource: {
 };
 //#endregion
 //#region src/runtime/runtime.d.ts
-declare class Runtime {
+declare class Runtime<Provided extends AnyServiceToken = AnyServiceToken> {
   private readonly built;
   private constructor();
-  static make(layer: Layer, backend: LayerBackend): Promise<Runtime>;
-  static run<A>(layer: Layer, backend: LayerBackend, program: () => A | PromiseLike<A>): Promise<Awaited<A>>;
-  run<A>(program: () => A): A;
+  static make<L extends AnyLayer>(layer: CompleteLayer<L>, backend: LayerBackend, options?: RuntimeOptions): Promise<Runtime<LayerProvided<L>>>;
+  static run<A, L extends AnyLayer>(layer: CompleteLayer<L>, backend: LayerBackend, program: CompleteExecution<LayerProvided<L>, A>, options?: RuntimeOptions): Promise<Awaited<A>>;
+  run<A>(program: CompleteExecution<Provided, A>): Promise<Awaited<A>>;
+  private runUnchecked;
   dispose(): Promise<void>;
+  private disposeWithOutcome;
 }
 //#endregion
-export { type AcquireUseReleaseOptions, type AnyServiceToken, type AsyncResult, type BuiltLayer, BuiltLayerDisposedError, type DisposableResource, DuplicateServiceError, Layer, type LayerBackend, LayerDisposeError, LayerGeneratorYieldError, LayerRegistrationError, type ReleaseFailureObserver, type ReleaseOutcome, Resource, ResourceReleaseFailure, Runtime, Service, type ServiceClass, type ServiceInstance, ServiceNotFoundError, type ServiceResolver, ServiceRuntime, ServiceRuntimeNotConfiguredError, type ServiceToken, buildLayer };
+//#region src/runtime/types.d.ts
+/** Runtime handle whose provided Services are inferred from a Layer. */
+type RuntimeFor<L extends AnyLayer> = Runtime<LayerProvided<L>>;
+//#endregion
+export { type AcquireUseReleaseOptions, type AnyEffectResult, type AnyServiceToken, type AsyncResult, type BuiltLayer, BuiltLayerDisposedError, type CleanupFailureDiagnostic, type CleanupFailureObserver, type CloseableScope, type DisposableResource, DuplicateServiceError, Effect, type EffectError, type EffectRequirements, type EffectResult, type EffectSuccess, type EffectYield, Layer, type LayerBackend, LayerDisposeError, LayerGeneratorYieldError, type LayerMissing, type LayerProvided, type LayerRawRequired, LayerRegistrationError, type LayerSpecs, type ReleaseFailureObserver, type ReleaseOutcome, Resource, ResourceNotDisposableError, ResourceReleaseFailure, Runtime, type RuntimeFor, type RuntimeOptions, type RuntimeShutdownDiagnostic, Scope, ScopeCloseError, ScopeClosedError, type ScopeFinalizer, type ScopeOutcome, ScopeRuntimeNotConfiguredError, Service, type ServiceClass, type ServiceInstance, ServiceNotFoundError, type ServiceRequirement, type ServiceRequirements, type ServiceResolver, ServiceRuntime, ServiceRuntimeNotConfiguredError, type ServiceToken, buildLayer };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/service/service.ts","../src/service/errors.ts","../src/layer/layer.ts","../src/layer/runtime.ts","../src/layer/errors.ts","../src/resource/errors.ts","../src/resource/types.ts","../src/resource/resource.ts","../src/runtime/runtime.ts"],"mappings":";;;iBAIgB,QAAQ;;GAGoB,OAAA,kBAAA,sBAAsB;;;;cCLrD,yCAAyC;EACpD;;cAOW,6BAA6B;WACnB,SAAS;EAA9B,YAAqB,SAAS;;;;cCFnB;WACF,oBAAoB;UAEtB;SAIA,KAAK,UAAU,mBACpB,SAAS,GAET,eAAe,eAAa,aAAa,MACxC;SASI,QAAQ,UAAU,mBAAmB,SAAS,GAAG,UAAU,aAAa,KAAK;SAI7E,OAAO,UAAU,mBACtB,SAAS,GACT,eAAe,eAAa,aAAa,KACzC,UAAU,UAAU,aAAa,OAAO,uBACvC;SAWI,IAAI,UAAU,mBAAmB,SAAS,GAAG,SAAS,eAAe,KAAK;SAI1E,SAAS,iBAAiB,UAAU;SAkBpC,SAAS,MAAM,UAAU,oBAAoB,UAAU;;;;UC5D/C;WACN,SAAS;EAElB,IAAI,GAAG,eAAe,IAAI;EAE1B,WAAW;;cA+CA,aAAU,OAAiB,OAAK,SAAW,iBAAe,QAAQ;;;cC5DlE,8BAA8B;WACpB,SAAS;EAA9B,YAAqB,SAAS;;cAOnB,+BAA+B;WAE/B,SAAS;WACT;WACA;EAHX,YACW,SAAS,+BACT,4BACA;;cAUA,0BAA0B;WAChB;EAArB,YAAqB;;cAOV,iCAAiC;WACvB,SAAS;EAA9B,YAAqB,SAAS;;cAOnB,gCAAgC;EAC3C;;;;;cCvCW,+BAA+B;WACjC;WACA;WACA;;;;KCDC,aAAa,KAAK,IAAI,YAAY;KAElC,YAAY,GAAG,KAAK,aAAa,OAAW,GAAG;KAE/C,wBAAwB;KAExB;GACT,OAAO;GAEP,OAAO,sBAAsB;;KAGpB,0BAA0B,SAAS,2BAA2B;KAE9D,yBAAyB,GAAG,GAAG,cAAc;WAC9C;WAEA,eAAe,YAAY,GAAG;WAE9B,MAAM,UAAU,MAAM,YAAY,GAAG;WAErC,WAAW,UAAU,MAAM,aAAa;;;;;;;;WASxC,mBAAmB;;;;cC1BxB,oBAAqB,GAAG,GAAG,cAAc,YAAQ,MAAA,SAAA,KAAA,SAAA,oBAMpD,yBAAyB,GAAG,GAAG,cAAc,cAAY,QAC1D,OAAW,GAAG,eAAe,WAAW,qBAAqB;cAWlD;qCAAA;;;;cCxBA;mBAC0B;UAA9B;SAEM,KAAK,OAAO,OAAO,SAAS,eAAe,QAAQ;SAMnD,IAAI,GACf,OAAO,OACP,SAAS,cACT,eAAe,IAAI,YAAY,KAC9B,QAAQ,QAAQ;EAUnB,IAAI,GAAG,eAAe,IAAI;EAI1B,WAAW"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/scope/scope.ts","../src/effect/effect.ts","../src/resource/errors.ts","../src/resource/types.ts","../src/resource/resource.ts","../src/runtime/runtime.ts","../src/runtime/types.ts"],"mappings":";;;UAUiB;EACf,aAAa,WAAW;EAExB,QAAQ,GACN,eAAe,eAAa,IAC5B,UAAU,UAAU,GAAG,SAAS,iBAAiB,uBAChD,QAAQ;EAEX,IAAI,UAAU,oBAAoB,UAAU,IAAI,QAAQ;EAExD,QAAQ;;UAGO,uBAAuB;EACtC,MAAM,UAAU,eAAe;;cAgKpB;WACH,YAAA;WAIG,eAAA;WAIH,UAAA,GAAC,OAAS,OAAK,eAAiB,MAAI;YAKtB,OAAA,iBAAA,iBAAiB;WAInC,MAAA,GAAC,UAAY,OAAO,UAAU,IAAI,YAAY,OAAK,QAAQ,QAAQ;;;;KChMpE,YAAY;;;;;iBAcD,IAAI,cAAc,aAAa,iBAAiB,WAC9D,YAAY,UAAU,OAAO,qBAC5B,oBAAoB,OAAO;iBAEd,IAAI,cAAc,aAAa,iBAAiB,WAC9D,YAAY,eAAe,OAAO,qBACjC,QAAQ,oBAAoB,OAAO;;;;;;;iBAmBtB,eAAe,GAC7B,eAAe,eAAa,IAC5B,UAAU,UAAU,GAAG,SAAS,iBAAiB,uBAChD,eAAe,WAAW,qBAAqB;;;;;;;iBAYlC,IAAI,UAAU,oBAC5B,UAAU,IACT,eAAe,WAAW,qBAAqB;cAMrC;;;;;;;;cCtEA,+BAA+B;WACjC;WACA;WACA;;;;KCCC,aAAa,KAAK,IAAI,YAAY;KAElC,YAAY,GAAG,KAAK,aAAa,OAAW,GAAG;KAE/C,wBAAwB;KAExB,0BAA0B,SAAS,2BAA2B;KAE9D,yBAAyB,GAAG,GAAG,cAAc;WAC9C;WAEA,eAAe,YAAY,GAAG;WAE9B,MAAM,UAAU,MAAM,YAAY,GAAG;WAErC,WAAW,UAAU,MAAM,aAAa;;;;;;;;WASxC,mBAAmB;;;;cCpBxB,oBAAqB,GAAG,GAAG,cAAc,YAAQ,MAAA,SAAA,KAAA,SAAA,oBAMpD,yBAAyB,GAAG,GAAG,cAAc,cAAY,QAC1D,OAAW,GAAG,eAAe,WAAW,qBAAqB;cAoBlD;qCAAA;;;;cCpBA,QAAQ,iBAAiB,kBAAkB;mBACjB;UAA9B;SAEM,KAAK,UAAU,UAC1B,OAAO,cAAc,IACrB,SAAS,cACT,UAAS,iBACR,QAAQ,QAAQ,cAAc;SAMpB,IAAI,GAAG,UAAU,UAC5B,OAAO,cAAc,IACrB,SAAS,cACT,SAAS,kBAAkB,cAAc,IAAI,IAC7C,UAAS,iBACR,QAAQ,QAAQ;EAoDnB,IAAI,GAAG,SAAS,kBAAkB,UAAU,KAAK,QAAQ,QAAQ;UAIzD;EAIR,WAAW;UAIH;;;;;KC9FE,WAAW,UAAU,YAAY,QAAQ,cAAc"}