better-effect 0.5.0 → 0.6.0

package/dist/index-DMfjhNR_.d.mts

@@ -0,0 +1,500 @@
+import { Err, InferErr, InferOk, Result } from "better-result";
+//#region src/service/types.d.ts
+/** Internal type-only identity for the branded Service instance. */
+declare const ServiceIdentityTypeId: unique symbol;
+/** A branded Service instance identity carried by the literal Service tag. */
+interface ServiceIdentity<out Tag extends string = string> {
+  readonly [ServiceIdentityTypeId]: Tag;
+}
+/** The widened Service instance constraint used by contextual APIs. */
+type AnyService = ServiceIdentity<string>;
+/** Remove the internal Service identity marker from an implementation contract. */
+type ServiceContract<S> = S extends unknown ? Omit<S, typeof ServiceIdentityTypeId> : never;
+type ServiceStatics<out Tag extends string, in out Instance extends AnyService> = {
+  readonly name: string;
+  readonly serviceTag: Tag;
+  /** Type-check a structural implementation and return it unchanged. */
+  readonly of: (this: void, implementation: ServiceContract<Instance>) => Instance;
+};
+type AbstractServiceConstructor<out Instance> = abstract new (...args: any[]) => Instance;
+/** A class constructor carrying a Service tag and its instance contract. */
+interface ServiceToken<out Tag extends string = string, in out Instance extends AnyService = any> extends AbstractServiceConstructor<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 extends AnyService = AnyService> = (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 branded Service instance. */
+type ServiceTagOf<S extends AnyService> = S[typeof ServiceIdentityTypeId];
+/** Extract the Service token represented by a branded Service instance. */
+type ServiceTokenOf<S extends AnyService> = S extends AnyService ? ServiceToken<ServiceTagOf<S>, S> : never;
+/** Extract the literal identity tag represented by a Service instance or token. */
+type ServiceTag<T extends AnyService | AnyServiceToken> = T extends AnyService ? ServiceTagOf<T> : T extends AnyServiceToken ? T['serviceTag'] : never;
+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<S extends AnyService> = MethodRequirements<S>;
+//#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<out T> {
+  readonly [ServiceRequirementTypeId]: T;
+}
+/** A `better-result` Result with phantom metadata for required Services. */
+type Effect<A, E, R extends AnyService = never> = Result<A, E> & {
+  readonly [EffectRequirementsTypeId]?: R;
+};
+/** An Effect with erased success, error, and Service requirements. */
+type AnyEffect = Effect<unknown, unknown, AnyService>;
+/** Values that an Effect generator may yield. */
+type EffectYield = Err<never, unknown> | ServiceRequirement<unknown>;
+/** Extract the error channel from Result values yielded by a generator. */
+type InferYieldError<Y> = Y extends Err<never, infer E> ? E : never;
+/** Extract branded Service instances carried by yielded Service requirements. */
+type InferYieldRequirements<Y> = Y extends ServiceRequirement<infer Requirement> ? Requirement extends AnyService ? Requirement : never : never;
+type InferEffectRequirements<T> = T extends unknown ? typeof EffectRequirementsTypeId extends keyof T ? T extends {
+  readonly [EffectRequirementsTypeId]?: infer Requirements extends AnyService;
+} ? Requirements : never : never : never;
+/** Extract phantom Service requirements from an Effect or Promise. */
+type EffectRequirements<T> = InferEffectRequirements<Awaited<T>>;
+/** Extract the success value from an Effect or Promise. */
+type EffectSuccess<T> = Awaited<T> extends Result<infer A, unknown> ? A : never;
+/** Extract the error value from an Effect or Promise. */
+type EffectError<T> = Awaited<T> extends Result<unknown, infer E> ? E : never;
+/** Build the public Effect type produced from a generator. */
+type EffectFromGenerator<Yield, Returned extends Result<any, any>> = Effect<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;
+interface ServiceFactory<Self> {
+  <const Tag extends string>(tag: ServiceTagLiteral<Tag>): (abstract new () => ServiceIdentity<Tag>) & {
+    readonly name: string;
+    readonly serviceTag: Tag;
+  } & {
+    readonly of: Service.FactoryOf<Self, Tag>;
+    readonly [Symbol.asyncIterator]: (this: ServiceToken<Tag, Self & ServiceIdentity<Tag>>) => AsyncGenerator<ServiceRequirement<Self>, Self, unknown>;
+  };
+}
+/**
+ * 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>(): ServiceFactory<Self>;
+/** Type-level aliases for Service tokens and their instance contracts. */
+declare namespace Service {
+  /** The widened Service instance constraint. */
+  type Any = AnyService;
+  /** A class-backed Service token with a stable tag and instance contract. */
+  type Token<Tag extends string = string, Instance extends AnyService = any> = ServiceToken<Tag, Instance>;
+  /** A constructible Service class with a stable tag and instance contract. */
+  type Class<Tag extends string = string, Instance extends AnyService = AnyService> = ServiceClass<Tag, Instance>;
+  /** Extract the instance represented by a Service token. */
+  type Instance<T extends AnyServiceToken> = ServiceInstance<T>;
+  /** Extract the stable tag represented by a Service instance. */
+  type Tag<S extends AnyService> = ServiceTag<S>;
+  /** A branded Service instance identity with a stable tag. */
+  type Identity<Tag extends string = string> = ServiceIdentity<Tag>;
+  /** Remove the internal identity marker from a Service implementation contract. */
+  type Contract<S extends AnyService> = ServiceContract<S>;
+  /** Extract the Service token represented by a branded Service instance. */
+  type TokenOf<S extends AnyService> = ServiceTokenOf<S>;
+  /** Declaration bridge for the recursive structural `Service.of` signature. */
+  type FactoryOf<Self, Tag extends string> = (this: void, implementation: ServiceContract<Self & ServiceIdentity<Tag>>) => Self;
+  /** Extract Effect Service requirements from a Service instance. */
+  type Requirements<S extends AnyService> = ServiceRequirements<S>;
+}
+//#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/internal/variance.d.ts
+/** Type-level marker for a value produced by `A`. */
+type Covariant<A> = () => A;
+/** Type-level marker that both consumes and produces `A`. */
+type Invariant<A> = (value: A) => A;
+//#endregion
+//#region src/utils/types.d.ts
+type MaybePromise<T> = T | PromiseLike<T>;
+//#endregion
+//#region src/internal/missing-dependencies.d.ts
+declare const MissingDependenciesTypeId: unique symbol;
+type MissingDependencies<Missing extends AnyService> = {
+  readonly [MissingDependenciesTypeId]: Missing;
+};
+//#endregion
+//#region src/layer/metadata.d.ts
+/** Package-private declaration-only carrier for inferred Layer provenance. */
+declare const LayerProvenanceTypeId: unique symbol;
+interface ProviderEntry<out Provided extends AnyService, out RawRequired extends AnyService = never> {
+  readonly provided: Provided;
+  readonly required: RawRequired;
+}
+interface ErasedProvenance<out Provided extends AnyService, out StickyRequired extends AnyService> {
+  readonly provided: Provided;
+  readonly stickyRequired: StickyRequired;
+}
+interface LayerProvenance<out Entries extends ProviderEntry<AnyService, AnyService> = never, out Erased extends ErasedProvenance<AnyService, AnyService> = never> {
+  readonly [LayerProvenanceTypeId]: {
+    readonly entries: Entries;
+    readonly erased: Erased;
+  };
+}
+//#endregion
+//#region src/layer/inference.d.ts
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type IsNever<T> = [T] extends [never] ? true : false;
+type IsUnion<T, Candidate = T> = T extends unknown ? [Candidate] extends [T] ? false : true : never;
+/** Any Layer shape accepted by type-level inference helpers. */
+type LayerInput = Layer<any, any> | Layer<never, any>;
+/** Extract the public Service environment channels from a Layer. */
+type ProvidedEnvironment<L extends LayerInput> = L extends Layer<infer Provided, infer _Required> ? Provided : never;
+type RequiredEnvironment<L extends LayerInput> = L extends Layer<infer _Provided, infer Required> ? Required : never;
+type HasWidenedTag<Services> = IsAny<Services> extends true ? false : Services extends AnyService ? string extends ServiceTagOf<Services> ? true : false : false;
+type SameServiceTag<Left extends AnyService, Right extends AnyService> = [ServiceTagOf<Left>] extends [ServiceTagOf<Right>] ? [ServiceTagOf<Right>] extends [ServiceTagOf<Left>] ? true : false : false;
+type SameServiceContract<Left extends AnyService, Right extends AnyService> = [ServiceContract<Left>] extends [ServiceContract<Right>] ? [ServiceContract<Right>] extends [ServiceContract<Left>] ? true : false : false;
+type SameService<Left extends AnyService, Right extends AnyService> = SameServiceTag<Left, Right> extends true ? SameServiceContract<Left, Right> : false;
+type RequirementProvided<Requirement extends AnyService, Provided extends AnyService> = Provided extends AnyService ? SameService<Requirement, Provided> : false;
+type MissingRequirement<Requirement extends AnyService, Provided> = true extends RequirementProvided<Requirement, Extract<Provided, AnyService>> ? never : Requirement;
+/**
+ * Existing Runtime matching semantics. Widened Service environments are an
+ * explicit execution erasure and therefore satisfy every concrete requirement.
+ */
+type MissingServices<Required extends AnyService, Provided extends AnyService> = ServiceToken<string, Required> extends ServiceToken<string, Provided> ? never : IsAny<Required> extends true ? never : IsAny<Provided> extends true ? never : true extends HasWidenedTag<Required | Provided> ? never : Required extends AnyService ? MissingRequirement<Required, Provided> : never;
+/** Layer matching that keeps widened Service.Any as an external requirement. */
+type LayerExternalRequirements<RawRequired extends AnyService, Provided extends AnyService> = true extends HasWidenedTag<Extract<RawRequired | Provided, AnyService>> ? Extract<RawRequired, AnyService> : MissingServices<RawRequired, Provided>;
+type AnyProviderEntry = ProviderEntry<AnyService, AnyService>;
+type AnyErasedProvenance = ErasedProvenance<AnyService, AnyService>;
+type EntryProvided<Entries> = Entries extends ProviderEntry<infer Provided, any> ? Provided : never;
+type EntryRequired<Entries> = Entries extends ProviderEntry<any, infer Required> ? Required : never;
+type ErasedProvided<Erased> = Erased extends ErasedProvenance<infer Provided, any> ? Provided : never;
+type ErasedRequired<Erased> = Erased extends ErasedProvenance<any, infer Required> ? Required : never;
+/** Extract precise provider entries carried by an inferred Layer. */
+type PreciseEntries<L extends LayerInput> = L extends LayerProvenance<infer Entries, any> ? Entries : never;
+/**
+ * Extract erased provenance, falling back to the public channels for an
+ * explicitly annotated Layer.
+ */
+type ErasedEntries<L extends LayerInput> = L extends LayerProvenance<any, infer Erased> ? Erased : [ProvidedEnvironment<L> | RequiredEnvironment<L>] extends [never] ? never : ErasedProvenance<ProvidedEnvironment<L>, RequiredEnvironment<L>>;
+type LayerMetadata<Entries extends AnyProviderEntry, Erased extends AnyErasedProvenance> = [Entries | Erased] extends [never] ? unknown : LayerProvenance<Entries, Erased>;
+/** Opaque internal result type used by Layer constructors and combinators. */
+type LayerResult<Entries extends AnyProviderEntry, Erased extends AnyErasedProvenance = never> = Layer<EntryProvided<Entries> | ErasedProvided<Erased>, LayerExternalRequirements<EntryRequired<Entries> | ErasedRequired<Erased>, EntryProvided<Entries> | ErasedProvided<Erased>>> & LayerMetadata<Entries, Erased>;
+type LayerChannelPair<L> = L extends Layer<infer Provided, infer Required> ? [Provided, Required] : never;
+type ExactUncheckedArm<L> = LayerChannelPair<L> extends [infer Provided extends AnyService, infer Required extends AnyService] ? IsAny<Provided> extends true ? IsAny<Required> extends true ? true : false : IsNever<Provided> extends true ? IsAny<Required> extends true ? true : false : false : false;
+type HasUncheckedProvidedArm<L> = L extends unknown ? LayerChannelPair<L> extends [infer Provided, infer Required] ? IsAny<Provided> extends true ? IsAny<Required> extends true ? true : false : false : false : never;
+type HasUncheckedEmptyArm<L> = L extends unknown ? LayerChannelPair<L> extends [infer Provided, infer Required] ? IsNever<Provided> extends true ? IsAny<Required> extends true ? true : false : false : false : never;
+type HasNonUncheckedArm<L> = L extends unknown ? ExactUncheckedArm<L> extends true ? false : true : never;
+/** Recognize only the documented exact unchecked Layer sentinels. */
+type IsExactUncheckedLayer<L> = IsUnion<L> extends false ? ExactUncheckedArm<L> : true extends HasNonUncheckedArm<L> ? false : true extends HasUncheckedProvidedArm<L> ? true extends HasUncheckedEmptyArm<L> ? true : false : false;
+type PartialAnyArm<L> = LayerChannelPair<L> extends [infer Provided extends AnyService, infer Required extends AnyService] ? IsAny<Provided> extends true ? IsAny<Required> extends true ? false : true : IsAny<Required> extends true ? IsNever<Provided> extends true ? false : true : false : false;
+/** Detect any Layer constituent with only one erased generic channel. */
+type HasPartialAnyChannel<L> = true extends (L extends unknown ? PartialAnyArm<L> : never) ? true : false;
+/** Detect a concrete union of Layer values, preserving the original shape. */
+type IsConcreteUnion<L> = IsAny<L> extends true ? false : IsUnion<L> extends true ? IsExactUncheckedLayer<L> extends true ? false : true : false;
+type LayerInputState<L> = IsExactUncheckedLayer<L> extends true ? 'unchecked' : HasPartialAnyChannel<L> extends true ? 'invalid-partial-any' : IsConcreteUnion<L> extends true ? 'invalid-union' : 'typed';
+type InvalidLayerErasure = {
+  readonly __betterEffectInvalidLayerErasure: unique symbol;
+};
+type AmbiguousLayerUnion = {
+  readonly __betterEffectAmbiguousLayerUnion: unique symbol;
+};
+/** Validate an original Layer argument without widening it to Layer.Any. */
+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]>; };
+/** 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 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;
+type ApplyPreciseOverrides<Entries extends AnyProviderEntry, Overrides extends readonly LayerInput[]> = Overrides extends readonly [infer Head extends LayerInput, ...infer Tail extends readonly LayerInput[]] ? ApplyPreciseOverrides<ReplacePreciseOne<Entries, Head>, Tail> : Entries;
+type ApplyErasedOverrides<Erased extends AnyErasedProvenance, Overrides extends readonly LayerInput[]> = Overrides extends readonly [infer Head extends LayerInput, ...infer Tail extends readonly LayerInput[]] ? ApplyErasedOverrides<ReplaceErasedOne<Erased, Head> | Extract<ErasedEntries<Head>, AnyErasedProvenance>, Tail> : Erased;
+type HasUncheckedLayerInTuple<Layers extends readonly LayerInput[]> = true extends (Layers[number] extends unknown ? IsExactUncheckedLayer<Layers[number]> : never) ? true : false;
+type MergeLayerResult<Layers extends readonly LayerInput[]> = HasUncheckedLayerInTuple<Layers> extends true ? Layer<any, any> : LayerResult<PreciseEntries<Layers[number]>, ErasedEntries<Layers[number]>>;
+/** 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;
+};
+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>>>);
+/** 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;
+/** 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 ExecutionProgram<A> = () => A | PromiseLike<A>;
+type CompleteExecutionWithRequirements<Provided extends AnyService, A, Required extends AnyService> = [MissingServices<Required, Provided>] extends [never] ? ExecutionProgram<A> : ExecutionProgram<A> & MissingDependencies<MissingServices<Required, Provided>>;
+/** Keep execution callbacks unchanged when their Effect requirements are met. */
+type CompleteExecution<Provided extends AnyService, A> = CompleteExecutionWithRequirements<Provided, A, EffectRequirements<A>>;
+//#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; concrete types are erased at this backend boundary. */
+  readonly acquire: () => MaybePromise<unknown>;
+}
+/** Generator shape used by `Layer.gen` and `Layer.scopedGen`. */
+type LayerGenerator<S extends ServiceClass<any, any>, Yield extends ServiceRequirement<unknown> = ServiceRequirement<unknown>> = () => AsyncGenerator<Yield, ServiceContract<InstanceType<S>>, unknown>;
+/** Service requirements inferred from a provider's methods and generator. */
+type LayerGeneratorRequirements<S extends ServiceClass<any, any>, Yield extends ServiceRequirement<unknown>> = ServiceRequirements<InstanceType<S>> | InferYieldRequirements<Yield>;
+//#endregion
+//#region src/layer/layer.d.ts
+declare const LayerTypeId: unique symbol;
+interface LayerVariance<in out Provided, out Required> {
+  readonly _Provided: Invariant<Provided>;
+  readonly _Required: Covariant<Required>;
+}
+interface LayerProvider extends LayerRegistration {
+  /** Provider storage deliberately erases the concrete instance type. */
+  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 extends AnyService = AnyService> = 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<in out Provided extends AnyService = AnyService, out Required extends AnyService = AnyService> {
+  readonly [LayerTypeId]: LayerVariance<Provided, Required>;
+  /** The provider registrations retained by this Layer. */
+  readonly providers: readonly LayerProvider[];
+  private constructor();
+  /** Create a Layer that lazily acquires a Service instance. */
+  static make<S extends DefaultConstructibleServiceClass<any, any>>(service: S): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>>;
+  static make<S extends ServiceClass<any, any>>(service: S, acquire: () => MaybePromise<ServiceContract<InstanceType<S>>>): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>>;
+  /** Create a Layer from an already-constructed Service instance. */
+  static succeed<S extends ServiceClass<any, any>>(service: S, instance: ServiceContract<InstanceType<S>>): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>>;
+  /** Define a provider with Runtime-root cleanup. */
+  static scoped<S extends ServiceClass<any, any>>(service: S, acquire: () => MaybePromise<ServiceContract<InstanceType<S>>>, release: (instance: InstanceType<S>) => MaybePromise<void>): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>>;
+  /** Define a provider whose acquisition can yield contextual Services. */
+  static scopedGen<S extends ServiceClass<any, any>, Yield extends ServiceRequirement<unknown>>(service: S, factory: LayerGenerator<S, Yield>, release: (instance: InstanceType<S>, outcome: ScopeOutcome) => MaybePromise<void>): LayerResult<ProviderEntry<InstanceType<S>, LayerGeneratorRequirements<S, Yield>>>;
+  /** Define a provider whose acquisition can yield contextual Services. */
+  static gen<S extends ServiceClass<any, any>, Yield extends ServiceRequirement<unknown>>(service: S, factory: LayerGenerator<S, Yield>): LayerResult<ProviderEntry<InstanceType<S>, LayerGeneratorRequirements<S, Yield>>>;
+  /** Compose Layers without replacing providers. */
+  static merge<const Layers extends readonly LayerInput[]>(...layers: Layers & ValidateLayerTuple<Layers>): MergeResult<Layers>;
+  /** 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>;
+}
+/** Type-level aliases for inspecting Layer environments and completeness. */
+declare namespace Layer {
+  /** The widened Layer shape accepted by generic Layer infrastructure. */
+  type Any = LayerInput;
+  /** Extract the branded Service instances provided by a Layer. */
+  type Provided<L extends LayerInput> = ProvidedEnvironment<L>;
+  /** Extract the external Service requirements of a Layer. */
+  type Required<L extends LayerInput> = RequiredEnvironment<L>;
+  /** Validate a Layer's requirements and input shape. */
+  type Complete<L extends LayerInput> = CompleteInput<L>;
+}
+//#endregion
+//#region src/layer/errors.d.ts
+type LayerCause = Extract<ScopeOutcome, {
+  readonly status: 'failure';
+}>['cause'];
+/** 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: LayerCause;
+  readonly cleanupCause?: LayerCause | undefined;
+  constructor(service: ServiceClass<any> | undefined, registrationCause: LayerCause, cleanupCause?: LayerCause | undefined);
+}
+/** 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 { AnyEffect as A, ServiceClass as B, ScopeClosedError as C, ServiceResolver as D, ServiceRuntimeNotConfiguredError as E, EffectSuccess as F, ServiceTag as G, ServiceIdentity as H, EffectYield as I, ServiceToken as K, ServiceRequirement as L, EffectError as M, EffectFromGenerator as N, ServiceRuntime as O, EffectRequirements as P, AnyService as R, ScopeCloseError as S, ServiceNotFoundError as T, ServiceInstance as U, ServiceContract as V, ServiceRequirements as W, DisposableResource as _, DuplicateServiceError as a, ScopeOutcome as b, LayerRegistrationError as c, LayerRegistration as d, CompleteExecution as f, CleanupFailureDiagnostic as g, ProvidedEnvironment as h, RuntimeShutdownDiagnostic as i, Effect as j, Service as k, ServiceTagCollisionError as l, LayerInput as m, CleanupFailureObserver as n, LayerDisposeError as o, CompleteInput as p, ServiceTokenOf as q, RuntimeOptions as r, LayerGeneratorYieldError as s, LayerBackend as t, Layer as u, MaybePromise$1 as v, ScopeRuntimeNotConfiguredError as w, ResourceNotDisposableError as x, ScopeFinalizer as y, AnyServiceToken as z };
+//# sourceMappingURL=index-DMfjhNR_.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-DMfjhNR_.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/internal/variance.ts","../src/utils/types.ts","../src/internal/missing-dependencies.ts","../src/layer/metadata.ts","../src/layer/inference.ts","../src/layer/types.ts","../src/layer/layer.ts","../src/layer/errors.ts","../src/runtime/outcome.ts","../src/layer/backend.ts"],"mappings":"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"}