better-effect 0.4.0 → 0.5.0

package/dist/index-D77AvuBl.d.mts

@@ -0,0 +1,510 @@
+import { Err, InferErr, InferOk, Result } from "better-result";
+//#region src/service/types.d.ts
+type ServiceStatics<Tag extends string, Instance> = {
+  readonly name: string;
+  readonly serviceTag: Tag;
+  /** Type-check a structural implementation and return it unchanged. */
+  of(this: void, implementation: Instance): Instance;
+};
+/** A class constructor carrying a Service tag and its instance contract. */
+type ServiceToken<Tag extends string = string, Instance = any> = (abstract new (...args: any[]) => Instance) & ServiceStatics<Tag, Instance>;
+/** The widened token constraint used by generic Service infrastructure. */
+type AnyServiceToken = ServiceToken<string, any>;
+/** A concrete, constructible Service class accepted by a Layer provider. */
+type ServiceClass<Tag extends string = string, Instance = any> = (new (...args: any[]) => Instance) & ServiceStatics<Tag, Instance>;
+/** Extract the instance type represented by a Service token. */
+type ServiceInstance<T extends AnyServiceToken> = InstanceType<T>;
+/** Extract the literal identity tag represented by a Service token. */
+type ServiceTag<T extends AnyServiceToken> = T['serviceTag'];
+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.
+ *
+ * This type is used automatically by `Layer.make`, `Layer.gen`, and the other
+ * provider constructors.
+ */
+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.
+ *
+ * @typeParam A The successful value.
+ * @typeParam E The error value.
+ * @typeParam Requirements The tagged Service contracts required to produce it.
+ */
+type EffectResult<A, E, Requirements = never> = Result<A, E> & {
+  readonly [EffectRequirementsTypeId]?: Requirements;
+};
+/** An Effect result with unknown success, error, and Service 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
+type ServiceTagLiteral<Tag extends string> = string extends Tag ? never : Tag extends '' ? never : Tag;
+/**
+ * Declare a class-backed Service with a stable string-literal identity.
+ *
+ * The returned class is simultaneously the implementation type, the runtime
+ * dependency token, and the value yielded by `yield*` in an Effect generator.
+ * The explicit self type preserves exact instance inference, while the second
+ * call captures the tag as a literal for Layer composition and diagnostics.
+ *
+ * @example
+ * ```ts
+ * class Database extends Service<Database>()('Database') {
+ *   query(): string {
+ *     return 'ok'
+ *   }
+ * }
+ *
+ * const database = yield* Database
+ * database.query()
+ * ```
+ *
+ * @typeParam Self The instance type implemented by the declared Service.
+ */
+declare function Service<Self>(): <const Tag extends string>(tag: ServiceTagLiteral<Tag>) => (abstract new () => {}) & {
+  /** The stable logical identity used by Layers and resolver backends. */
+  readonly serviceTag: Tag;
+  /**
+   * Type-check a structural implementation of this Service.
+   *
+   * This is an identity helper. It returns the supplied value unchanged
+   * and does not invoke a constructor or modify its prototype.
+   *
+   * @example
+   * ```ts
+   * class Database extends Service<Database>()('Database') {
+   *   query(sql: string): string {
+   *     return sql
+   *   }
+   * }
+   *
+   * const database = Database.of({
+   *   query: (sql) => `Result: ${sql}`
+   * })
+   *
+   * database.query('SELECT 1')
+   * // 'Result: SELECT 1'
+   * // database is the original object, not an instance of Database
+   * ```
+   */
+  of(this: void, implementation: Self): Self;
+  /** Resolve this Service from the resolver active in the current runtime. */
+  [Symbol.asyncIterator](this: ServiceToken<Tag, Self>): AsyncGenerator<ServiceRequirement<ServiceToken<Tag, Self>>, Self, unknown>;
+};
+//#endregion
+//#region src/service/runtime.d.ts
+/** Resolves class-backed Service tokens for a runtime execution. */
+interface ServiceResolver {
+  /** Resolve a token to its corresponding Service instance. */
+  resolve<T extends AnyServiceToken>(token: T): InstanceType<T> | PromiseLike<InstanceType<T>>;
+}
+/** Provides the resolver context used by Service tokens during execution. */
+declare class ServiceRuntime {
+  /**
+   * Run a callback with a resolver available to `yield* Service` expressions.
+   *
+   * The context is scoped to the callback and is restored afterward.
+   *
+   * @example
+   * ```ts
+   * const value = ServiceRuntime.run(resolver, () => {
+   *   return ServiceRuntime.resolve(Database)
+   * })
+   * ```
+   */
+  static run<A>(resolver: ServiceResolver, program: () => A): A;
+  /** Return the resolver active in the current execution context. */
+  static current(): ServiceResolver;
+  /** Resolve a Service token using the active resolver. */
+  static resolve<T extends AnyServiceToken>(token: T): Promise<InstanceType<T>>;
+}
+//#endregion
+//#region src/service/errors.d.ts
+/** Thrown when a Service is accessed without an active runtime resolver. */
+declare class ServiceRuntimeNotConfiguredError extends Error {
+  constructor();
+}
+/** Thrown when a runtime has no provider for the requested Service tag. */
+declare class ServiceNotFoundError extends Error {
+  readonly service: AnyServiceToken;
+  constructor(service: AnyServiceToken);
+}
+//#endregion
+//#region src/scope/errors.d.ts
+/** Thrown when Scope context is accessed outside an active Scope execution. */
+declare class ScopeRuntimeNotConfiguredError extends Error {
+  constructor();
+}
+/** Thrown when a resource or finalizer is added after Scope closure begins. */
+declare class ScopeClosedError extends Error {
+  constructor();
+}
+/** Aggregates finalizer failures encountered while closing a Scope. */
+declare class ScopeCloseError extends Error {
+  readonly causes: readonly unknown[];
+  constructor(causes: readonly unknown[]);
+}
+/** Thrown when a value has neither Symbol.dispose nor Symbol.asyncDispose. */
+declare class ResourceNotDisposableError extends Error {
+  constructor();
+}
+//#endregion
+//#region src/scope/types.d.ts
+/** A value that may be returned synchronously or asynchronously. */
+type MaybePromise$1<T> = T | PromiseLike<T>;
+/** Final outcome supplied to Scope finalizers and resource releases. */
+type ScopeOutcome = {
+  /** Indicates that the owning program completed successfully. */
+  readonly status: 'success';
+} | {
+  /** Indicates that the owning program failed or was interrupted. */
+  readonly status: 'failure';
+  /** The original program or execution failure. */
+  readonly cause: unknown;
+};
+/** Cleanup callback registered with a Scope. */
+type ScopeFinalizer = (outcome: ScopeOutcome) => MaybePromise$1<void>;
+/** Aggregated cleanup information reported at an execution boundary. */
+type CleanupFailureDiagnostic = {
+  /** Outcome used for the Scope close that triggered cleanup. */
+  readonly outcome: ScopeOutcome;
+  /** Aggregated finalizer failure. */
+  readonly error: ScopeCloseError;
+};
+type SyncDisposableResource = {
+  [Symbol.dispose]: () => void;
+  [Symbol.asyncDispose]?: () => MaybePromise$1<void>;
+};
+type AsyncDisposableResource = {
+  [Symbol.dispose]?: () => void;
+  [Symbol.asyncDispose]: () => MaybePromise$1<void>;
+};
+/** A value implementing at least one JavaScript disposal protocol. */
+type DisposableResource = SyncDisposableResource | AsyncDisposableResource;
+//#endregion
+//#region src/utils/types.d.ts
+type MaybePromise<T> = T | PromiseLike<T>;
+//#endregion
+//#region src/layer/types.d.ts
+/** Runtime-facing provider registration supplied by a Layer backend. */
+interface LayerRegistration {
+  /** The class-backed Service token provided by this registration. */
+  readonly service: ServiceClass<any, any>;
+  /** Lazily acquire the Service instance. */
+  readonly acquire: () => MaybePromise<unknown>;
+}
+/** Type-level description of one Layer provider and its Service requirements. */
+type LayerSpec<Provided extends AnyServiceToken, Required extends AnyServiceToken = never> = {
+  /** Service constructor provided by the Layer. */
+  readonly provided: Provided;
+  /** Service constructors required while acquiring the provider. */
+  readonly required: Required;
+};
+/** Widened Layer specification used by generic Layer utilities. */
+type AnyLayerSpec = LayerSpec<AnyServiceToken, AnyServiceToken>;
+/** Generator shape used by `Layer.gen` and `Layer.scopedGen`. */
+type LayerGenerator<S extends ServiceClass<any, any>, Yield extends ServiceRequirement<AnyServiceToken> = ServiceRequirement<AnyServiceToken>> = () => AsyncGenerator<Yield, InstanceType<S>, unknown>;
+/** Service requirements inferred from a provider's methods and generator. */
+type LayerGeneratorRequirements<S extends ServiceClass<any, any>, Yield extends ServiceRequirement<AnyServiceToken>> = ServiceRequirements<S> | InferYieldRequirements<Yield>;
+//#endregion
+//#region src/layer/inference.d.ts
+/** Any Layer shape accepted by type-level inference helpers. */
+type AnyLayer = Layer<any, any>;
+/** Extract the provider specification union from a Layer. */
+type LayerSpecs<L extends AnyLayer> = L extends Layer<infer Specs, any> ? Specs : never;
+/** Extract the Service constructor union provided by a Layer. */
+type LayerProvided<L extends AnyLayer> = LayerSpecs<L> extends LayerSpec<infer Provided, any> ? Provided : never;
+/** Extract all raw Service requirements declared by a Layer's providers. */
+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 SameServiceTag<Left extends AnyServiceToken, Right extends AnyServiceToken> = string extends ServiceTag<Left> ? true : string extends ServiceTag<Right> ? true : [ServiceTag<Left>] extends [ServiceTag<Right>] ? [ServiceTag<Right>] extends [ServiceTag<Left>] ? true : false : false;
+type SameServiceContract<Left extends AnyServiceToken, Right extends AnyServiceToken> = [InstanceType<Left>] extends [InstanceType<Right>] ? [InstanceType<Right>] extends [InstanceType<Left>] ? true : false : false;
+type SameServiceToken<Left extends AnyServiceToken, Right extends AnyServiceToken> = SameServiceTag<Left, Right> extends true ? SameServiceContract<Left, Right> : 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 IncompatibleServicePair<Left extends AnyServiceToken, Right extends AnyServiceToken> = SameServiceTag<Left, Right> extends true ? SameServiceContract<Left, Right> extends true ? never : Right : never;
+type IncompatibleServicePairs<Left, Right> = Left extends AnyServiceToken ? Right extends AnyServiceToken ? IncompatibleServicePair<Left, Right> : never : never;
+type IncompatibleLayerSpecs<Current extends AnyLayerSpec, Replacement extends AnyLayerSpec> = IncompatibleServicePairs<LayerSpecProvided<Current>, LayerSpecProvided<Replacement>>;
+/** Same-tag replacements with incompatible instance contracts. */
+type OverrideLayerCollisions<Current extends AnyLayerSpec, Overrides extends readonly AnyLayer[]> = Overrides extends readonly [infer Head extends AnyLayer, ...infer Tail extends readonly AnyLayer[]] ? IncompatibleLayerSpecs<Current, LayerSpecs<Head>> | OverrideLayerCollisions<ReplaceLayerSpecs<Current, LayerSpecs<Head>>, Tail> : never;
+type RequirementProvided<Requirement extends AnyServiceToken, Provided extends AnyServiceToken> = Provided extends AnyServiceToken ? SameServiceTag<Requirement, Provided> extends true ? SameServiceContract<Requirement, Provided> : 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;
+/** Extract the requirements missing from a Layer's provided environment. */
+type LayerMissing<L extends AnyLayer> = MissingServices<LayerRawRequired<L>, LayerProvided<L>>;
+/** Extract incompatible same-tag override contracts from a Layer. */
+type LayerCollisions<L extends AnyLayer> = L extends Layer<any, infer Collisions> ? Collisions : never;
+type MissingLayerServices<Missing extends AnyServiceToken> = {
+  readonly __betterEffectMissingServices: Missing;
+};
+/**
+ * Put the missing Service tags in the required property name itself. This is
+ * intentionally separate from the stable marker above so TypeScript reports a
+ * useful diagnostic while existing type-level consumers can still inspect the
+ * missing-token union.
+ */
+type MissingLayerServiceDiagnostic<Missing extends AnyServiceToken> = { readonly [K in `__betterEffectMissingService__${ServiceTag<Missing>}`]: never; };
+type LayerCollisionServices<Collisions extends AnyServiceToken> = {
+  readonly __betterEffectLayerOverrideCollisions: Collisions;
+};
+/**
+ * A Layer accepted by Runtime boundaries after completeness validation.
+ *
+ * Incomplete Layers retain readable per-tag diagnostic properties so compiler
+ * errors identify the missing Services directly.
+ */
+type CompleteLayer<L extends AnyLayer> = [LayerMissing<L>] extends [never] ? [LayerCollisions<L>] extends [never] ? L : L & LayerCollisionServices<LayerCollisions<L>> : L & MissingLayerServiceDiagnostic<LayerMissing<L>> & MissingLayerServices<LayerMissing<L>> & ([LayerCollisions<L>] extends [never] ? unknown : LayerCollisionServices<LayerCollisions<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;
+};
+/** Readable per-tag diagnostics for execution boundaries. */
+type MissingRuntimeServiceDiagnostic<Missing extends AnyServiceToken> = { readonly [K in `__betterEffectMissingRuntimeService__${ServiceTag<Missing>}`]: never; };
+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> & MissingRuntimeServiceDiagnostic<ExecutionMissing<Provided, A>> & MissingRuntimeServices<ExecutionMissing<Provided, A>>;
+//#endregion
+//#region src/layer/layer.d.ts
+declare const LayerTypeId: unique symbol;
+declare const LayerCollisionTypeId: unique symbol;
+interface LayerProvider extends LayerRegistration {
+  readonly release?: (instance: unknown, outcome: ScopeOutcome) => MaybePromise<void>;
+}
+/** A Service class whose constructor can be called without arguments. */
+type DefaultConstructibleServiceClass<Tag extends string = string, Instance = any> = ServiceClass<Tag, Instance> & (new () => Instance);
+/**
+ * Declarative collection of Service providers.
+ *
+ * A Layer describes how to acquire implementations; it does not execute
+ * providers until a `Runtime` is created. Use `merge` to compose distinct
+ * providers and `override` when replacing an existing provider intentionally.
+ *
+ * @example
+ * ```ts
+ * const AppLive = Layer.merge(
+ *   Layer.succeed(Database, database),
+ *   Layer.make(UserRepository)
+ * )
+ *
+ * const runtime = await Runtime.make(AppLive, backend)
+ * ```
+ */
+declare class Layer<Specs extends AnyLayerSpec = AnyLayerSpec, Collisions extends AnyServiceToken = never> {
+  readonly [LayerTypeId]: Specs;
+  readonly [LayerCollisionTypeId]: Collisions;
+  /** The provider registrations retained by this Layer. */
+  readonly providers: readonly LayerProvider[];
+  private constructor();
+  /**
+   * Create a Layer that lazily acquires a Service instance.
+   *
+   * When the acquire callback is omitted, the Service must be constructible
+   * without required constructor arguments and is instantiated with `new`.
+   * Supplying an acquire callback remains available for custom construction.
+   *
+   * The acquire callback runs when the provider is first resolved by a
+   * Runtime. Dependencies declared by Effect-returning Service methods are
+   * tracked in the Layer's type.
+   *
+   * @example
+   * ```ts
+   * const DatabaseLive = Layer.make(Database)
+   * ```
+   *
+   * @example
+   * ```ts
+   * const DatabaseLive = Layer.make(Database, () => new Database(config))
+   * ```
+   */
+  static make<S extends DefaultConstructibleServiceClass<any, any>>(service: S): Layer<LayerSpec<S, ServiceRequirements<S>>>;
+  static make<S extends ServiceClass<any, any>>(service: S, acquire: () => MaybePromise<InstanceType<S>>): Layer<LayerSpec<S, ServiceRequirements<S>>>;
+  /**
+   * Create a Layer from an already-constructed Service instance.
+   *
+   * The instance is returned as-is whenever the Service is resolved.
+   *
+   * @example
+   * ```ts
+   * const DatabaseLive = Layer.succeed(Database, database)
+   * ```
+   */
+  static succeed<S extends ServiceClass<any, any>>(service: S, instance: InstanceType<S>): Layer<LayerSpec<S, ServiceRequirements<S>>>;
+  /**
+   * Define a provider with Runtime-root cleanup.
+   *
+   * The release callback intentionally keeps its compatibility-friendly
+   * one-argument shape and runs when the owning Runtime is disposed. Use
+   * `scopedGen` when acquisition needs contextual Services or cleanup needs
+   * `ScopeOutcome`.
+   *
+   * @example
+   * ```ts
+   * const DatabaseLive = Layer.scoped(
+   *   Database,
+   *   () => openDatabase(),
+   *   (database) => database.close()
+   * )
+   * ```
+   */
+  static scoped<S extends ServiceClass<any, any>>(service: S, acquire: () => MaybePromise<InstanceType<S>>, release: (instance: InstanceType<S>) => MaybePromise<void>): Layer<LayerSpec<S, ServiceRequirements<S>>>;
+  /**
+   * Define a provider whose acquisition can yield contextual Services.
+   *
+   * The release callback receives the acquired instance and the final
+   * `ScopeOutcome` selected by the owning Runtime.
+   *
+   * @example
+   * ```ts
+   * const RepositoryLive = Layer.scopedGen(
+   *   UserRepository,
+   *   async function* () {
+   *     const database = yield* Database
+   *     return new UserRepository(database)
+   *   },
+   *   (repository, outcome) => repository.close(outcome)
+   * )
+   * ```
+   */
+  static scopedGen<S extends ServiceClass<any, 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>>>;
+  /**
+   * Define a provider whose acquisition can yield contextual Services.
+   *
+   * Unlike `scopedGen`, this variant has no release callback. Use it for
+   * providers whose lifetime is managed elsewhere or that need no cleanup.
+   *
+   * @example
+   * ```ts
+   * const RepositoryLive = Layer.gen(UserRepository, async function* () {
+   *   const database = yield* Database
+   *   return new UserRepository(database)
+   * })
+   * ```
+   */
+  static gen<S extends ServiceClass<any, any>, Yield extends ServiceRequirement<AnyServiceToken>>(service: S, factory: LayerGenerator<S, Yield>): Layer<LayerSpec<S, LayerGeneratorRequirements<S, Yield>>>;
+  /**
+   * Compose Layers without replacing providers.
+   *
+   * Each Service tag may appear only once. Duplicate tags are rejected at
+   * runtime; use `override` when replacement is intentional.
+   *
+   * @example
+   * ```ts
+   * const AppLive = Layer.merge(DatabaseLive, RepositoryLive)
+   * ```
+   */
+  static merge<const Layers extends readonly Layer<any, any>[]>(...layers: Layers): Layer<Layers[number] extends Layer<infer Specs, any> ? Specs : never, Layers[number] extends Layer<any, infer Collisions> ? Collisions : never>;
+  /**
+   * Replace providers in a base Layer, using tag identity and compatible
+   * instance contracts.
+   *
+   * Overrides are applied from left to right; the last compatible provider for
+   * a tag wins. Incompatible same-tag replacements remain visible as a type
+   * diagnostic and cannot be passed as a complete Layer.
+   *
+   * @example
+   * ```ts
+   * const TestLive = Layer.override(AppLive, Layer.succeed(Database, fakeDb))
+   * ```
+   */
+  static override<Base extends Layer<any, any>, const Overrides extends readonly Layer<any, any>[]>(base: Base, ...overrides: Overrides): Layer<OverrideLayerSpecs<Base extends Layer<infer Specs, any> ? Specs : never, Overrides>, (Base extends Layer<any, infer Collisions> ? Collisions : never) | (Overrides[number] extends Layer<any, infer Collisions> ? Collisions : never) | OverrideLayerCollisions<Base extends Layer<infer Specs, any> ? Specs : never, Overrides>>;
+}
+//#endregion
+//#region src/layer/errors.d.ts
+/** Thrown when a Layer registers the same Service tag more than once. */
+declare class DuplicateServiceError extends Error {
+  readonly service: ServiceClass<any>;
+  constructor(service: ServiceClass<any>);
+}
+/** Thrown when one Service tag is associated with incompatible constructors. */
+declare class ServiceTagCollisionError extends Error {
+  readonly existing: AnyServiceToken;
+  readonly incoming: AnyServiceToken;
+  constructor(existing: AnyServiceToken, incoming: AnyServiceToken);
+}
+/** Thrown when a backend fails while registering a Layer provider. */
+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);
+}
+/** Thrown when one or more Layer-owned resources fail during disposal. */
+declare class LayerDisposeError extends Error {
+  readonly causes: readonly unknown[];
+  constructor(causes: readonly unknown[]);
+}
+/** Thrown when a Layer generator yields a value other than a Service requirement. */
+declare class LayerGeneratorYieldError extends Error {
+  readonly service: ServiceClass<any>;
+  constructor(service: ServiceClass<any>);
+}
+//#endregion
+//#region src/runtime/outcome.d.ts
+/** Aggregated cleanup information reported during Runtime shutdown. */
+type RuntimeShutdownDiagnostic = {
+  /** Final outcome supplied to the Runtime root Scope. */
+  readonly outcome: ScopeOutcome;
+  /** Aggregated root-Scope and backend cleanup failure. */
+  readonly error: LayerDisposeError;
+};
+/** Observer notified about cleanup failures without changing primary results. */
+type CleanupFailureObserver = (diagnostic: CleanupFailureDiagnostic | RuntimeShutdownDiagnostic) => MaybePromise$1<void>;
+/** Optional Runtime configuration for cleanup diagnostics. */
+type RuntimeOptions = {
+  /** Optional observer for best-effort cleanup diagnostics. */
+  readonly onCleanupFailure?: CleanupFailureObserver;
+};
+//#endregion
+//#region src/layer/backend.d.ts
+/** Runtime adapter responsible for registering, resolving, and disposing Layer providers. */
+interface LayerBackend extends ServiceResolver {
+  /** Register one Service provider with the backend. */
+  register(registration: LayerRegistration): MaybePromise<void>;
+  /** Dispose all backend-owned instances and provider registrations. */
+  disposeAll(): MaybePromise<void>;
+}
+//#endregion
+export { ServiceResolver as A, ServiceRequirement as B, ScopeOutcome as C, ScopeRuntimeNotConfiguredError as D, ScopeClosedError as E, EffectFromGenerator as F, ServiceTag as G, ServiceClass as H, EffectRequirements as I, ServiceToken as K, EffectResult as L, Service as M, AnyEffectResult as N, ServiceNotFoundError as O, EffectError as P, EffectSuccess as R, ScopeFinalizer as S, ScopeCloseError as T, ServiceInstance as U, AnyServiceToken as V, ServiceRequirements as W, LayerSpecs as _, DuplicateServiceError as a, DisposableResource as b, LayerRegistrationError as c, AnyLayer as d, CompleteExecution as f, LayerRawRequired as g, LayerProvided as h, RuntimeShutdownDiagnostic as i, ServiceRuntime as j, ServiceRuntimeNotConfiguredError as k, ServiceTagCollisionError as l, LayerMissing as m, CleanupFailureObserver as n, LayerDisposeError as o, CompleteLayer as p, RuntimeOptions as r, LayerGeneratorYieldError as s, LayerBackend as t, Layer as u, LayerRegistration as v, ResourceNotDisposableError as w, MaybePromise$1 as x, CleanupFailureDiagnostic as y, EffectYield as z };
+//# sourceMappingURL=index-D77AvuBl.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-D77AvuBl.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"],"mappings":"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"}