better-effect 0.13.0 → 0.14.0

package/dist/layer-C2OaqTmB.d.mts

@@ -0,0 +1,987 @@
+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;
+  /** Yield this Service from a synchronous generator factory. */
+  readonly [Symbol.iterator]: () => Generator<ServiceRequirement<Instance>, Instance, unknown>;
+  /** 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 ResultValue = Result<any, any>;
+/** Keep nested Effect errors and Service requirements in one inferred yield. */
+type EffectIterator<A, E, R extends AnyService> = {
+  [Symbol.iterator](): Generator<Err<never, E> & ServiceRequirement<R>, A, unknown>;
+};
+type EffectMethods<A, E, R extends AnyService> = {
+  map<B>(fn: (value: A) => B): Effect<B, E, R>;
+  mapError<E2>(fn: (error: E) => E2): Effect<A, E2, R>;
+  tryRecover<Next extends ResultValue>(fn: (error: E) => Next): Effect<A | EffectSuccess<Next>, EffectError<Next>, R | EffectRequirements<Next>>;
+  tryRecoverAsync<Next extends ResultValue>(fn: (error: E) => Promise<Next>): Promise<Effect<A | EffectSuccess<Next>, EffectError<Next>, R | EffectRequirements<Next>>>;
+  andThen<Next extends ResultValue>(fn: (value: A) => Next): Effect<EffectSuccess<Next>, E | EffectError<Next>, R | EffectRequirements<Next>>;
+  andThenAsync<Next extends ResultValue>(fn: (value: A) => Promise<Next>): Promise<Effect<EffectSuccess<Next>, E | EffectError<Next>, R | EffectRequirements<Next>>>;
+  tap(fn: (value: A) => void): Effect<A, E, R>;
+  tapAsync(fn: (value: A) => PromiseLike<void>): Promise<Effect<A, E, R>>;
+  tapError(fn: (error: E) => void): Effect<A, E, R>;
+  tapErrorAsync(fn: (error: E) => PromiseLike<void>): Promise<Effect<A, E, R>>;
+  tapBoth(handlers: {
+    ok: (value: A) => void;
+    err: (error: E) => void;
+  }): Effect<A, E, R>;
+  tapBothAsync(handlers: {
+    ok: (value: A) => PromiseLike<void>;
+    err: (error: E) => PromiseLike<void>;
+  }): Promise<Effect<A, E, R>>;
+};
+/**
+ * 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;
+/** Type-only identity for lazy Effect programs. */
+declare const ProgramTypeId: unique symbol;
+/** Required declaration-only variance carrier for Effect Service requirements. */
+interface EffectVariance<out R extends AnyService> {
+  readonly requirements: R;
+}
+/** Required declaration-only variance carrier for a lazy Program. */
+interface ProgramVariance<out A, out E, out R extends AnyService> {
+  readonly success: A;
+  readonly error: E;
+  readonly requirements: R;
+}
+/**
+ * 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 required declaration-only metadata for Services. */
+type Effect<A, E, R extends AnyService = never> = EffectMethods<A, E, R> & Result<A, E> & EffectIterator<A, E, R> & {
+  readonly [EffectRequirementsTypeId]: EffectVariance<R>;
+};
+/** A nominal lazy computation that produces an Effect when invoked. */
+type Program<A, E, R extends AnyService = never> = {
+  (): Effect<A, E, R> | Promise<Effect<A, E, R>>;
+  readonly [ProgramTypeId]: ProgramVariance<A, E, 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]: EffectVariance<infer Requirements extends AnyService>;
+} ? Requirements : never : never : never;
+type InferProgramSuccess<T> = T extends {
+  readonly [ProgramTypeId]: ProgramVariance<infer Success, any, any>;
+} ? Success : never;
+type InferProgramError<T> = T extends {
+  readonly [ProgramTypeId]: ProgramVariance<any, infer Error, any>;
+} ? Error : never;
+type InferProgramRequirements<T> = T extends {
+  readonly [ProgramTypeId]: ProgramVariance<any, any, infer Requirements>;
+} ? Requirements : never;
+/** Extract declaration-only Service requirements from an Effect or Promise. */
+type EffectRequirements<T> = T extends unknown ? InferProgramRequirements<T> extends never ? InferEffectRequirements<Awaited<T>> : InferProgramRequirements<T> : never;
+/** Extract the success value from an Effect or Promise. */
+type EffectSuccess<T> = T extends unknown ? InferProgramSuccess<T> extends never ? Awaited<T> extends Result<infer A, unknown> ? A : never : InferProgramSuccess<T> : never;
+/** Extract the error value from an Effect or Promise. */
+type EffectError<T> = T extends unknown ? InferProgramError<T> extends never ? Awaited<T> extends Result<unknown, infer E> ? E : never : InferProgramError<T> : 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>>;
+/** Build the nominal lazy Program produced from a generator. */
+type ProgramFromGenerator<Yield, Returned extends Result<any, any>> = Program<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.iterator]: (this: ServiceToken<Tag, Self & ServiceIdentity<Tag>>) => Generator<ServiceRequirement<Self>, Self, unknown>;
+    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/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/scope/scope.d.ts
+/**
+ * Non-owning lifecycle context for finalizers and child Scopes.
+ *
+ * A Scope can register cleanup and create children, but it cannot close
+ * itself. Use `Scope.make()` or `Scope.run()` when your code owns the Scope.
+ */
+interface Scope {
+  /** Register a finalizer that runs when the owning Scope closes. */
+  addFinalizer(finalizer: ScopeFinalizer): void;
+  /** Acquire a resource and register its outcome-aware release callback. */
+  acquire<R>(acquire: () => MaybePromise$1<R>, release: (resource: R, outcome: ScopeOutcome) => MaybePromise$1<void>): Promise<R>;
+  /** Register an already-acquired disposable resource. */
+  add<R extends DisposableResource>(resource: R): Promise<R>;
+  /** Create a child Scope owned by this Scope. */
+  fork(): CloseableScope;
+}
+/** A Scope whose owner is responsible for calling `close()`. */
+interface CloseableScope extends Scope {
+  /** Close the Scope and run children and finalizers in child-first LIFO order. */
+  close(outcome?: ScopeOutcome): Promise<void>;
+}
+declare const Scope: {
+  /** Create an owned, initially open Scope. */
+  readonly make: () => CloseableScope;
+  /** Return the non-owning Scope available in the current execution context. */
+  readonly current: () => Scope;
+  /** Run a callback with an existing Scope supplied as the current context. */
+  readonly provide: <A>(scope: Scope, program: () => A) => A;
+  /** Resolve the current Scope through `yield* Scope` inside an Effect. */
+  readonly [Symbol.iterator]: () => Generator<never, Scope, unknown>;
+  /**
+   * Run a program in a newly owned Scope.
+   *
+   * Scope is independent from `better-result`, so returned values—including
+   * `Result.err`—close this Scope with a successful outcome. Result-aware
+   * outcome classification belongs to `Runtime.run`.
+   *
+   * @example
+   * ```ts
+   * await Scope.run(async (scope) => {
+   *   const connection = await scope.acquire(connect, (connection) => connection.close())
+   *   return connection.query()
+   * })
+   * ```
+   */
+  readonly run: <A>(program: (scope: Scope) => A | PromiseLike<A>) => Promise<Awaited<A>>;
+};
+/** Type-level aliases for Scope ownership, outcomes, and cleanup contracts. */
+declare namespace Scope {
+  /** A Scope whose owner is responsible for calling `close()`. */
+  type Closeable = CloseableScope;
+  /** The outcome supplied to Scope finalizers and resource releases. */
+  type Outcome = ScopeOutcome;
+  /** A cleanup callback registered with a Scope. */
+  type Finalizer = ScopeFinalizer;
+  /** A value implementing a JavaScript disposal protocol. */
+  type Disposable = DisposableResource;
+}
+//#endregion
+//#region src/internal/missing-dependencies.d.ts
+type MissingDependencies<Missing extends AnyService> = {
+  /** Names the Services that must be supplied before execution. */
+  readonly missingServices: 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$1<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 PossibleProvidedEnvironment<L extends LayerInput> = EntryProvided<PreciseEntries<L>> | ErasedProvided<ErasedEntries<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, VisibleProvided extends AnyService = EntryProvided<Entries> | ErasedProvided<Erased>> = Layer<VisibleProvided, LayerExternalRequirements<EntryRequired<Entries> | ErasedRequired<Erased>, VisibleProvided>> & 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$1<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$1<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]>; };
+type HasMatchingServiceTag<Left extends AnyService, Right extends AnyService> = [Extract<ServiceTagOf<Left>, ServiceTagOf<Right>>] extends [never] ? false : true;
+/** Remove compatible Services from a union while retaining all other identities. */
+type RemoveCompatibleServices<Provided extends AnyService, Replacements extends AnyService> = Provided extends AnyService ? HasMatchingServiceTag<Provided, Replacements> extends true ? true extends (Replacements extends AnyService ? SameService<Provided, Replacements> : false) ? never : Provided : Provided : never;
+type HasCompatibleService<Provided extends AnyService, Replacements extends AnyService> = HasMatchingServiceTag<Provided, Replacements> extends true ? true extends (Replacements extends AnyService ? SameService<Provided, Replacements> : false) ? true : false : false;
+type RemoveCompatibleEntries<Entries extends AnyProviderEntry, Replacements extends AnyService> = Entries extends ProviderEntry<infer Provided, any> ? HasCompatibleService<Provided, Replacements> extends true ? never : Entries : never;
+type ReplacePreciseOne<Entries extends AnyProviderEntry, Replacement extends LayerInput> = RemoveCompatibleEntries<Entries, Extract<ProvidedEnvironment<Replacement>, AnyService>> | PreciseEntries<Replacement>;
+type ReplaceErasedOne<Erased extends AnyErasedProvenance, Replacement extends LayerInput> = Erased extends ErasedProvenance<infer Provided, infer StickyRequired> ? ErasedProvenance<RemoveCompatibleServices<Provided, Extract<ProvidedEnvironment<Replacement>, AnyService>>, StickyRequired> : never;
+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 HasMatchingService<Candidate extends AnyService, Available extends AnyService> = true extends (Available extends AnyService ? SameService<Candidate, Available> : never) ? true : false;
+type GuaranteedServiceCandidates<Candidates extends AnyService, Branches extends LayerInput> = Candidates extends AnyService ? false extends (Branches extends LayerInput ? HasMatchingService<Candidates, Extract<ProvidedEnvironment<Branches>, AnyService>> : never) ? never : Candidates : never;
+type GuaranteedProvided<Branch extends LayerInput, Branches extends LayerInput = Branch> = Branch extends LayerInput ? GuaranteedServiceCandidates<Extract<ProvidedEnvironment<Branch>, AnyService>, Branches> : never;
+type HasUncheckedLayerInTuple<Layers extends readonly LayerInput[]> = true extends { [Index in keyof Layers]: IsExactUncheckedLayer<Layers[Index]>; }[number] ? 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 ApplyVisibleOverrides<CurrentProvided extends AnyService, Overrides extends readonly LayerInput[]> = Overrides extends readonly [infer Head extends LayerInput, ...infer Tail extends readonly LayerInput[]] ? ApplyVisibleOverrides<RemoveCompatibleServices<CurrentProvided, Extract<ProvidedEnvironment<Head>, AnyService>> | Extract<ProvidedEnvironment<Head>, AnyService>, Tail> : CurrentProvided;
+type OverrideLayerBranches<Base extends LayerInput, Overrides extends readonly LayerInput[]> = Overrides extends readonly LayerInput[] ? Layer<ApplyVisibleOverrides<Extract<ProvidedEnvironment<Base>, AnyService>, Overrides>, never> : never;
+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>, Extract<GuaranteedProvided<OverrideLayerBranches<Base, Overrides>>, AnyService>>;
+/** 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> = HasMatchingServiceTag<CurrentProvided, ReplacementProvided> extends true ? CurrentProvided extends AnyService ? ReplacementProvided extends AnyService ? IncompatibleOverridePair<CurrentProvided, ReplacementProvided> : never : 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);
+type UnionToIntersection<Union> = (Union extends unknown ? (value: Union) => void : never) extends ((value: infer Intersection) => void) ? Intersection : never;
+type ValidationFailuresToConstraint<Failures> = [Failures] extends [never] ? unknown : UnionToIntersection<Failures>;
+type ValidateOverrideTuple<Overrides extends readonly LayerInput[]> = { [Index in keyof Overrides]: ValidateOverrideLayerInput<Overrides[Index]>; };
+type ValidateOverrideTupleFailures<Overrides extends readonly LayerInput[]> = ValidationFailuresToConstraint<Overrides extends readonly LayerInput[] ? ValidationFailureWitness<{ [Index in keyof Overrides]: ValidateOverrideLayerInput<Overrides[Index]>; }> : never>;
+type ServiceAtTag<Services, Tag extends string> = Tag extends keyof Services ? Extract<Services[Tag], AnyService> : never;
+type ServiceTagMap<Services extends AnyService> = { [Tag in ServiceTagOf<Services>]: Extract<Services, {
+  readonly [ServiceIdentityTypeId]: Tag;
+}>; };
+type ExactMapOverrideMatch<Current, Replacement extends AnyService> = [MapServicesAtTag<Current, ServiceTagOf<Replacement>>] extends [never] ? true : [MapServicesAtTag<Current, ServiceTagOf<Replacement>>] extends [Replacement] ? [Replacement] extends [MapServicesAtTag<Current, ServiceTagOf<Replacement>>] ? true : false : false;
+type CanSkipBaseOverride<Current, Replacement extends AnyService> = false extends (Replacement extends AnyService ? [MapServicesAtTag<Current, ServiceTagOf<Replacement>>] extends [never] ? false : ExactMapOverrideMatch<Current, Replacement> : never) ? false : true;
+type MapServicesAtTag<Maps, Tag extends string> = Maps extends unknown ? ServiceAtTag<Maps, Tag> : never;
+type IncompatibleOverridePairsForValidation<CurrentProvided extends AnyService, Replacement extends AnyService> = CurrentProvided extends AnyService ? Replacement extends AnyService ? IncompatibleOverridePair<CurrentProvided, Replacement> : never : never;
+type ApplyValidationOverride<CurrentProvided extends AnyService, ReplacementProvided extends AnyService> = RemoveCompatibleServices<CurrentProvided, ReplacementProvided> | ReplacementProvided;
+type ValidateOverridePair<CurrentProvided extends AnyService, ReplacementProvided extends AnyService> = IncompatibleOverridePairsForValidation<CurrentProvided, ReplacementProvided> extends (infer Incompatible) ? [Incompatible] extends [never] ? unknown : IncompatibleLayerOverride<Extract<Incompatible, AnyServiceToken>> : never;
+/**
+ * Validate overrides while carrying only the current provided union.
+ * Rebuilding the full Layer provenance for every step is quadratic and can
+ * exhaust TypeScript's instantiation depth on otherwise simple override lists.
+ */
+type ValidateOverridesFromStateForArm<Overrides extends readonly LayerInput[], BaseMap, CurrentProvided extends AnyService, CurrentChanged extends boolean, CurrentUnchecked extends boolean> = Overrides extends readonly [infer Head extends LayerInput, ...infer Tail extends readonly LayerInput[]] ? CurrentUnchecked extends true ? ValidateOverridesFromStateForArm<Tail, BaseMap, AnyService, true, true> : IsExactUncheckedLayer<Head> extends true ? ValidateOverridesFromStateForArm<Tail, BaseMap, AnyService, true, true> : CurrentChanged extends false ? CanSkipBaseOverride<BaseMap, Extract<ProvidedEnvironment<Head>, AnyService>> extends true ? ValidateOverridesFromStateForArm<Tail, BaseMap, CurrentProvided, false, false> : ValidateOverridePair<CurrentProvided, Extract<ProvidedEnvironment<Head>, AnyService>> & ValidateOverridesFromStateForArm<Tail, BaseMap, ApplyValidationOverride<CurrentProvided, Extract<ProvidedEnvironment<Head>, AnyService>>, true, false> : ValidateOverridePair<CurrentProvided, Extract<ProvidedEnvironment<Head>, AnyService>> & ValidateOverridesFromStateForArm<Tail, BaseMap, ApplyValidationOverride<CurrentProvided, Extract<ProvidedEnvironment<Head>, AnyService>>, true, false> : unknown;
+/** Validate every possible override tuple arm instead of accepting one valid arm. */
+type ValidateOverridesFromState<Overrides extends readonly LayerInput[], BaseMap, CurrentProvided extends AnyService, CurrentChanged extends boolean, CurrentUnchecked extends boolean> = ValidationFailuresToConstraint<Overrides extends readonly LayerInput[] ? ValidationFailureWitness<ValidateOverridesFromStateForArm<Overrides, BaseMap, CurrentProvided, CurrentChanged, CurrentUnchecked>> : never>;
+/** 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<PossibleProvidedEnvironment<Current>, AnyService>, Extract<PossibleProvidedEnvironment<Replacement>, AnyService>>] extends [never] ? unknown : IncompatibleLayerOverride<IncompatibleOverridePairs<Extract<PossibleProvidedEnvironment<Current>, AnyService>, Extract<PossibleProvidedEnvironment<Replacement>, AnyService>>>);
+type IsTuple<Values extends readonly unknown[]> = number extends Values['length'] ? false : true;
+type InvalidWidenedOverrideList = {
+  readonly __betterEffectWidenedOverrideList: unique symbol;
+};
+/** Validate ordered overrides against the state produced by earlier overrides. */
+type ValidateOverrides<Base extends LayerInput, Overrides extends readonly LayerInput[]> = [Overrides] extends [never] ? unknown : IsTuple<Overrides> extends false ? IsExactUncheckedLayer<Base> extends true ? unknown : InvalidWidenedOverrideList : ValidateOverrideLayerInput<Base> & ValidateOverrideTuple<Overrides> & ValidationFailuresToConstraint<Overrides extends readonly LayerInput[] ? [Overrides] extends [readonly []] ? never : ValidationFailureWitness<ValidateOverrideTuple<Overrides> & ValidateOverrideTupleFailures<Overrides> & ValidateOverridesFromState<Overrides, ServiceTagMap<Extract<PossibleProvidedEnvironment<Base>, AnyService>>, Extract<PossibleProvidedEnvironment<Base>, AnyService>, false, IsExactUncheckedLayer<Base>>> : never>;
+type ValidationFailureWitness<Value> = Value extends {
+  readonly __betterEffectIncompatibleLayerOverride: infer Tokens;
+} ? {
+  readonly __betterEffectIncompatibleLayerOverride: Tokens;
+} : Value extends {
+  readonly __betterEffectInvalidLayerErasure: unique symbol;
+} ? Value : Value extends {
+  readonly __betterEffectAmbiguousLayerUnion: unique symbol;
+} ? Value : Value extends {
+  readonly __betterEffectWidenedProvidedEnvironment: unique symbol;
+} ? Value : Value extends {
+  readonly __betterEffectWidenedOverrideList: unique symbol;
+} ? Value : Value extends readonly (infer Element)[] ? ValidationFailureWitness<Element> : never;
+/** Reduce Layer override validation to a usable call-site diagnostic witness. */
+type ValidateOverridesWitness<Base extends LayerInput, Overrides extends readonly LayerInput[]> = ValidationFailureWitness<ValidateOverrides<Base, Overrides>> extends (infer Failure) ? [Failure] extends [never] ? unknown : Failure : never;
+/** A Layer accepted by Runtime boundaries after completeness validation. */
+type CompleteInput<L extends LayerInput> = ValidateLayerInput<L> & (LayerInputState<L> extends 'unchecked' ? L : LayerInputState<L> extends 'typed' ? [RequiredEnvironment<L>] extends [never] ? L : L & MissingDependencies<Extract<RequiredEnvironment<L>, AnyService>> : L);
+type ExecutionRequirementsMissing<RootProvided extends AnyService, Request extends LayerInput> = MissingServices<Extract<RequiredEnvironment<Request>, AnyService>, Extract<RootProvided, AnyService>>;
+/** Validate a per-execution Layer against the Runtime root environment. */
+type CompleteExecutionLayer<RootProvided extends AnyService, Request extends LayerInput> = ValidateLayerInput<Request> & (LayerInputState<Request> extends 'unchecked' ? Request : LayerInputState<Request> extends 'typed' ? [ExecutionRequirementsMissing<RootProvided, Request>] extends [never] ? Request : Request & MissingDependencies<ExecutionRequirementsMissing<RootProvided, Request>> : Request);
+/** Services required by an execution result that are not in its environment. */
+type ExecutionMissing<Provided extends AnyService, ProgramResult> = MissingServices<EffectRequirements<ProgramResult>, Provided>;
+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/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: AnyServiceToken;
+  constructor(service: AnyServiceToken);
+}
+/** 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: AnyServiceToken | undefined;
+  readonly registrationCause: LayerCause;
+  readonly cleanupCause?: LayerCause;
+  constructor(service: AnyServiceToken | undefined, registrationCause: LayerCause, cleanupCause?: LayerCause);
+}
+/** 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: AnyServiceToken;
+  constructor(service: AnyServiceToken);
+}
+//#endregion
+//#region src/utils/types.d.ts
+type MaybePromise<T> = T | PromiseLike<T>;
+//#endregion
+//#region src/layer/types.d.ts
+/** Callback that stops a resource from admitting new work. */
+type LayerQuiesce<Instance = unknown> = (instance: Instance, reason: RuntimeShutdownReason) => MaybePromise<void>;
+/** Lifecycle callbacks for a resource owned by a Runtime root Scope. */
+type LayerLifecycle<Instance> = {
+  readonly quiesce?: LayerQuiesce<Instance>;
+  readonly release: (instance: Instance, outcome: ScopeOutcome) => MaybePromise<void>;
+};
+/** Runtime-facing provider registration supplied by a Layer backend. */
+interface LayerRegistration {
+  /** The class-backed Service token provided by this registration. */
+  readonly service: ServiceToken<any, any>;
+  /**
+   * The canonical tag captured when the provider was created.
+   *
+   * This remains optional for direct backend registrations created against the
+   * pre-inspection API; backends capture the token tag synchronously when it is
+   * omitted.
+   */
+  readonly serviceTag?: string;
+  /** Lazily acquire the Service instance; concrete types are erased at this backend boundary. */
+  readonly acquire: () => MaybePromise<unknown>;
+  /** Optional Runtime-root quiesce hook retained by Layer-created registrations. */
+  readonly quiesce?: LayerQuiesce;
+}
+/** Generator shape used by `Layer.gen` and `Layer.scopedGen`. */
+type LayerGenerator<S extends ServiceToken<any, any>, Yield extends ServiceRequirement<unknown> = ServiceRequirement<unknown>> = () => Generator<Yield, ServiceContract<InstanceType<S>>, unknown> | AsyncGenerator<Yield, ServiceContract<InstanceType<S>>, unknown>;
+/** Service requirements inferred from a provider's methods and generator. */
+type LayerGeneratorRequirements<S extends ServiceToken<any, any>, Yield extends ServiceRequirement<unknown>> = ServiceRequirements<InstanceType<S>> | InferYieldRequirements<Yield>;
+/** Generator shape used by lifecycle-only Layer entries. */
+type LayerDiscardGenerator<Yield extends ServiceRequirement<unknown>, Acquired> = () => Generator<Yield, Acquired, unknown> | AsyncGenerator<Yield, Acquired, unknown>;
+/** Service requirements inferred from a lifecycle-only generator. */
+type LayerDiscardRequirements<Yield extends ServiceRequirement<unknown>> = InferYieldRequirements<Yield>;
+//#endregion
+//#region src/layer/backend.d.ts
+/** Observation hook invoked for acquisitions that disposal will await. */
+type LayerBackendDisposeOptions = {
+  /**
+   * Receives the in-flight acquisition Promises when disposal begins. The callback
+   * is invoked synchronously and awaited before the backend clears its state.
+   */
+  readonly onPendingAcquisitions?: (acquisitions: readonly Promise<unknown>[]) => void | PromiseLike<void>;
+};
+/** 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(options?: LayerBackendDisposeOptions): MaybePromise<void>;
+}
+//#endregion
+//#region src/effect/task.d.ts
+type AnyProgram$1 = Program<any, any, AnyService>;
+/** The live state of a Scope-owned task. */
+type ScopedTaskState = 'running' | 'succeeded' | 'failed' | 'defected' | 'interrupted';
+/** The terminal observation of a Scope-owned task. */
+type ScopedTaskExit<A, E> = {
+  readonly status: 'succeeded';
+  readonly value: A;
+  readonly cleanupFailure?: ScopeCloseError;
+} | {
+  readonly status: 'failed';
+  readonly error: E;
+  readonly cleanupFailure?: ScopeCloseError;
+} | {
+  readonly status: 'defected';
+  readonly cause: unknown;
+  readonly cleanupFailure?: ScopeCloseError;
+} | {
+  readonly status: 'interrupted';
+  readonly reason: unknown;
+  readonly cleanupFailure?: ScopeCloseError;
+};
+/** A small, immutable handle for a task owned by the current Scope. */
+type ScopedTask<out A, out E> = {
+  readonly state: ScopedTaskState;
+  await(): Promise<Result<A, E>>;
+  awaitExit(): Promise<ScopedTaskExit<A, E>>;
+  interrupt(reason?: unknown): Promise<void>;
+};
+/** Start a nominal Program as a child task supervised by the current Scope. */
+declare function forkScoped<Input extends AnyProgram$1>(program: Input): Effect<ScopedTask<EffectSuccess<Input>, EffectError<Input>>, never, EffectRequirements<Input>>;
+//#endregion
+//#region src/runtime/observer.d.ts
+/** Observable Runtime shutdown phase. */
+type RuntimeShutdownPhase = 'shutdown-requested' | 'quiesce-start' | 'quiesce-end' | 'drain-start' | 'drain-end' | 'abort-active' | 'release-start' | 'release-end' | 'shutdown-complete' | 'shutdown-failure';
+/** Detached metadata for one Runtime shutdown phase. */
+type RuntimeShutdownEvent = {
+  readonly phase: RuntimeShutdownPhase;
+  readonly reason: RuntimeShutdownReason;
+  readonly activeExecutions?: number;
+  readonly durationMs?: number;
+  readonly error?: unknown;
+};
+/** Event emitted after a Service resolution attempt settles. */
+type RuntimeServiceResolveEvent = {
+  readonly service: AnyServiceToken;
+  readonly resolutionPath: readonly AnyServiceToken[];
+  readonly outcome: ScopeOutcome;
+  /** Runtime execution owner, omitted for warmup and other root activity. */
+  readonly executionId?: string;
+};
+/** Event emitted after a provider acquisition attempt settles. */
+type RuntimeServiceAcquireEvent = {
+  readonly service: AnyServiceToken;
+  readonly resolutionPath: readonly AnyServiceToken[];
+  readonly outcome: ScopeOutcome;
+  /** Runtime execution owner, omitted for warmup and other root activity. */
+  readonly executionId?: string;
+};
+/** Values supplied to one Runtime execution for diagnostic correlation. */
+type RuntimeExecutionAttributes = Readonly<Record<string, unknown>>;
+/** Metadata shared by the start and end events for one execution. */
+type RuntimeExecutionMetadata = {
+  readonly executionId: string;
+  readonly name?: string;
+  readonly attributes?: RuntimeExecutionAttributes;
+  /** Monotonic host timestamp captured immediately before the Program starts. */
+  readonly startedAt: number;
+};
+/** Event emitted immediately before a program starts in an execution Scope. */
+type RuntimeExecutionStartEvent = RuntimeExecutionMetadata & {
+  readonly scope: Scope;
+};
+/** Event emitted after a program and its execution Scope settle. */
+type RuntimeExecutionEndEvent = RuntimeExecutionMetadata & {
+  readonly scope: Scope;
+  /** The program outcome used to run execution-scope cleanup. */
+  readonly outcome: ScopeOutcome;
+  /** Execution-scope cleanup failure, without changing the primary program outcome. */
+  readonly cleanupFailure?: ScopeCloseError;
+  /** Monotonic elapsed time for the Program and its execution cleanup. */
+  readonly durationMs: number;
+};
+/** Metadata shared by the start and end events for one Scope-owned task. */
+type RuntimeTaskMetadata = {
+  readonly taskId: string;
+  /** The execution that created the task, omitted for root lifecycle tasks. */
+  readonly parentExecutionId?: string;
+  readonly name?: string;
+  readonly startedAt: number;
+};
+/** Event emitted immediately before a Scope-owned task starts. */
+type RuntimeTaskStartEvent = RuntimeTaskMetadata & {
+  readonly state: 'running';
+};
+/** Event emitted after a Scope-owned task settles and its child Scope closes. */
+type RuntimeTaskEndEvent = RuntimeTaskMetadata & {
+  readonly state: Exclude<ScopedTaskState, 'running'>;
+  /** Child Scope cleanup failure, without changing the task's primary state. */
+  readonly cleanupFailure?: ScopeCloseError;
+};
+/** Event emitted after a Layer provider release callback settles. */
+type RuntimeResourceReleaseEvent = {
+  readonly service: AnyServiceToken;
+  readonly outcome: ScopeOutcome;
+  readonly error?: unknown;
+  /** Runtime execution owner, omitted for Runtime-root cleanup. */
+  readonly executionId?: string;
+};
+/** Metadata shared by lifecycle-only Layer events. */
+type RuntimeLifecycleEventMetadata = {
+  readonly kind: 'lifecycle';
+  /** Stable identity for one lifecycle entry; no acquired resource is retained. */
+  readonly lifecycleId: symbol;
+  readonly name?: string;
+};
+/** Event emitted immediately before a lifecycle-only entry is acquired. */
+type RuntimeLifecycleStartEvent = RuntimeLifecycleEventMetadata;
+/** Event emitted after a lifecycle-only entry's acquisition settles. */
+type RuntimeLifecycleEndEvent = RuntimeLifecycleEventMetadata & {
+  readonly outcome: ScopeOutcome;
+  readonly error?: unknown;
+};
+/** Event emitted after a lifecycle-only entry's release callback settles. */
+type RuntimeLifecycleReleaseEvent = RuntimeLifecycleEventMetadata & {
+  readonly outcome: ScopeOutcome;
+  readonly error?: unknown;
+};
+/** Optional best-effort hooks for Runtime lifecycle and resolution events. */
+type RuntimeObserver = {
+  readonly onServiceResolve?: (event: RuntimeServiceResolveEvent) => MaybePromise<void>;
+  readonly onServiceAcquire?: (event: RuntimeServiceAcquireEvent) => MaybePromise<void>;
+  readonly onExecutionStart?: (event: RuntimeExecutionStartEvent) => MaybePromise<void>;
+  readonly onExecutionEnd?: (event: RuntimeExecutionEndEvent) => MaybePromise<void>;
+  readonly onTaskStart?: (event: RuntimeTaskStartEvent) => MaybePromise<void>;
+  readonly onTaskEnd?: (event: RuntimeTaskEndEvent) => MaybePromise<void>;
+  readonly onResourceRelease?: (event: RuntimeResourceReleaseEvent) => MaybePromise<void>;
+  readonly onLifecycleStart?: (event: RuntimeLifecycleStartEvent) => MaybePromise<void>;
+  readonly onLifecycleEnd?: (event: RuntimeLifecycleEndEvent) => MaybePromise<void>;
+  readonly onLifecycleRelease?: (event: RuntimeLifecycleReleaseEvent) => MaybePromise<void>;
+  readonly onShutdown?: (event: RuntimeShutdownEvent) => MaybePromise<void>;
+};
+/** Compose best-effort Runtime observers into one observer. */
+declare const RuntimeObserver: {
+  compose: (...observers: readonly RuntimeObserver[]) => RuntimeObserver;
+};
+//#endregion
+//#region src/runtime/outcome.d.ts
+/** Metadata explaining why a Runtime shutdown was requested. */
+type RuntimeShutdownReason = {
+  readonly kind: 'dispose' | 'signal' | 'external-abort' | 'main-settled';
+  readonly signal?: 'SIGINT' | 'SIGTERM';
+  readonly cause?: unknown;
+};
+/** 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 = {
+  /** Backend used to register and resolve the Layer. Defaults to MapLayerBackend. */
+  readonly backend?: LayerBackend;
+  /** Resolve every Layer provider before Runtime.make resolves. */
+  readonly warmup?: boolean;
+  /** Best-effort lifecycle and Service resolution observers. */
+  readonly observers?: readonly RuntimeObserver[];
+  /** Optional observer for best-effort cleanup diagnostics. */
+  readonly onCleanupFailure?: CleanupFailureObserver;
+  /** Context storage used by Service, Scope and Layer resolution. */
+  readonly contextStorage?: RuntimeContextStorage;
+  /** Optional signal exposed through the RuntimeContext. */
+  readonly signal?: AbortSignal;
+};
+/** Optional signal and diagnostic attributes supplied to one Runtime execution. */
+type RuntimeRunOptions = {
+  readonly signal?: AbortSignal;
+  /** Copied once and exposed as a readonly event view. */
+  readonly attributes?: RuntimeExecutionAttributes;
+};
+/** Cooperative shutdown policy for a managed Runtime. */
+type RuntimeDisposeOptions = {
+  /** Time to let active executions settle before requesting cancellation. */
+  readonly gracePeriod?: number;
+  /** Abort active execution signals after the grace period expires. */
+  readonly abortAfterGracePeriod?: boolean;
+  /** Boundary metadata supplied to Layer quiesce callbacks. */
+  readonly reason?: RuntimeShutdownReason;
+};
+//#endregion
+//#region src/runtime/executor.d.ts
+/** The value published by one managed execution before its work completes. */
+type RuntimeManagedPlan<A> = {
+  readonly readiness: A | PromiseLike<A>;
+  readonly completion: PromiseLike<void>;
+  readonly cancel?: (reason?: unknown) => PromiseLike<void>;
+};
+/** A non-owning handle for an execution whose readiness is separate from completion. */
+type RuntimeManagedExecution<A> = {
+  readonly readiness: Promise<Awaited<A>>;
+  readonly completion: Promise<void>;
+  readonly signal: AbortSignal;
+  readonly run: <B>(program: () => B | PromiseLike<B>) => Promise<Awaited<B>>;
+  readonly cancel: (reason?: unknown) => Promise<void>;
+};
+/**
+ * A non-owning view of a Runtime that can start isolated executions.
+ *
+ * The view deliberately contains only execution operations. Runtime disposal,
+ * warmup, inspection, backend access and Scope ownership stay on `Runtime`.
+ */
+interface RuntimeExecutor<in out Provided extends AnyService = any> {
+  readonly run: <A>(program: CompleteExecution<Provided, A>, options?: RuntimeRunOptions) => Promise<Awaited<A>>;
+  readonly runWith: <Request extends LayerInput, A>(layer: Request & CompleteExecutionLayer<Provided, Request>, program: CompleteExecution<Provided | ProvidedEnvironment<Request>, A>, options?: RuntimeRunOptions) => Promise<Awaited<A>>;
+  readonly runWithManaged: <Request extends LayerInput, A>(layer: Request & CompleteExecutionLayer<Provided, Request>, program: CompleteExecution<Provided | ProvidedEnvironment<Request>, RuntimeManagedPlan<A>>, options?: RuntimeRunOptions) => RuntimeManagedExecution<A>;
+}
+/** Yieldable request for the executor active in the current Runtime context. */
+interface RuntimeExecutorRequest<Provided extends AnyService> {
+  [Symbol.iterator](): Generator<ServiceRequirement<Provided>, RuntimeExecutor<Provided>, unknown>;
+  [Symbol.asyncIterator](): AsyncGenerator<ServiceRequirement<Provided>, RuntimeExecutor<Provided>, unknown>;
+}
+//#endregion
+//#region src/runtime/context.d.ts
+/** Contextual state shared by Service, Scope and Layer resolution. */
+interface RuntimeContext {
+  readonly resolver?: ServiceResolver;
+  readonly scope?: Scope;
+  readonly signal?: AbortSignal;
+  /** Non-owning executor view for the Runtime root of this context. */
+  readonly executor?: RuntimeExecutor<AnyService>;
+  readonly resolutionPath: readonly AnyServiceToken[];
+  /** Runtime execution owner, omitted for warmup and Runtime-root activity. */
+  readonly executionId?: string;
+}
+/** Host-specific storage for the current RuntimeContext. */
+interface RuntimeContextStorage {
+  run<A>(context: RuntimeContext, program: () => A): A;
+  current(): RuntimeContext;
+}
+//#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, storage?: RuntimeContextStorage): 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);
+}
+/** Thrown when resolving a Service re-enters a Service already in its path. */
+declare class CircularDependencyError extends Error {
+  readonly path: readonly AnyServiceToken[];
+  constructor(path: readonly AnyServiceToken[]);
+}
+/** Thrown when a registered Service provider fails during lazy acquisition. */
+declare class ServiceAcquisitionError extends Error {
+  readonly service: AnyServiceToken;
+  readonly cause: unknown;
+  constructor(service: AnyServiceToken, resolutionPath: readonly AnyServiceToken[], cause: unknown);
+  readonly resolutionPath: readonly AnyServiceToken[];
+}
+//#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/layer/layer.d.ts
+declare const LayerTypeId: unique symbol;
+interface LayerVariance<in out Provided, out Required> {
+  readonly _Provided: Invariant<Provided>;
+  readonly _Required: Covariant<Required>;
+}
+type CapturedLayerAcquisition = {
+  readonly instance: unknown;
+  readonly release: ScopeFinalizer;
+};
+interface LayerProvider extends LayerRegistration {
+  /** The tag captured before this provider can cross an asynchronous boundary. */
+  readonly serviceTag: string;
+  /** Provider storage deliberately erases the concrete instance type. */
+  readonly release?: (instance: unknown, outcome: ScopeOutcome) => MaybePromise<void>;
+  readonly quiesce?: LayerQuiesce;
+  /** Capture acquisition-local cleanup without retaining the acquired instance. */
+  readonly acquireWithRelease?: () => MaybePromise<CapturedLayerAcquisition>;
+}
+type AnyProgram = Program<any, any, AnyService>;
+type EffectDiscardValidation<P extends AnyProgram> = [EffectSuccess<P>] extends [void] ? [EffectError<P>] extends [never] ? unknown : {
+  readonly __betterEffectDiscardTypedFailure: unique symbol;
+} : {
+  readonly __betterEffectDiscardSuccessMustBeVoid: unique symbol;
+};
+/** 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);
+type IsUnion<Type, Candidate = Type> = Type extends unknown ? [Candidate] extends [Type] ? false : true : never;
+type InvalidUnionAliasToken = {
+  readonly __betterEffectUnionLayerAliasToken: unique symbol;
+};
+type RejectUnionAliasToken<Token> = IsUnion<Token> extends true ? InvalidUnionAliasToken : unknown;
+type LayerAliasOptions<From extends ServiceToken<any, any>, To extends ServiceToken<any, any>> = {
+  readonly from: From;
+  readonly to: To;
+} & RejectUnionAliasToken<From> & RejectUnionAliasToken<To> & ([ServiceContract<InstanceType<From>>] extends [ServiceContract<InstanceType<To>>] ? unknown : {
+  readonly __betterEffectIncompatibleLayerAlias: unique symbol;
+});
+/**
+ * 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 Service provider registrations retained by this Layer. */
+  readonly providers: readonly LayerProvider[];
+  private constructor();
+  private static makeLifecycleLayer;
+  /** A stable provider-free Layer for composition roots with no Services. */
+  static readonly empty: Layer<never, never>;
+  /** 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 ServiceToken<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 ServiceToken<any, any>>(service: S, instance: ServiceContract<InstanceType<S>>): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>>;
+  /** Alias a source Service under a compatible target contract. */
+  static alias<From extends ServiceToken<any, any>, To extends ServiceToken<any, any>>(options: LayerAliasOptions<From, To>): LayerResult<ProviderEntry<InstanceType<To>, InstanceType<From> | ServiceRequirements<InstanceType<To>>>>;
+  /** Define a provider with Runtime-root cleanup. */
+  static scoped<S extends ServiceToken<any, any>>(service: S, acquire: () => MaybePromise<ServiceContract<InstanceType<S>>>, release: (instance: InstanceType<S>, outcome: ScopeOutcome) => MaybePromise<void>): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>>;
+  static scoped<S extends ServiceToken<any, any>>(service: S, acquire: () => MaybePromise<ServiceContract<InstanceType<S>>>, lifecycle: LayerLifecycle<InstanceType<S>>): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>>;
+  /** Define a provider with Runtime-root cleanup through its disposal protocol. */
+  static scopedDisposable<S extends ServiceToken<any, any>>(service: S, acquire: () => MaybePromise<ServiceContract<InstanceType<S>> & DisposableResource>): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>>;
+  /** Define a provider whose acquisition can yield contextual Services. */
+  static scopedGen<S extends ServiceToken<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>>>;
+  static scopedGen<S extends ServiceToken<any, any>, Yield extends ServiceRequirement<unknown>>(service: S, factory: LayerGenerator<S, Yield>, lifecycle: LayerLifecycle<InstanceType<S>>): LayerResult<ProviderEntry<InstanceType<S>, LayerGeneratorRequirements<S, Yield>>>;
+  /** Define a provider whose acquisition can yield contextual Services. */
+  static gen<S extends ServiceToken<any, any>, Yield extends ServiceRequirement<unknown>>(service: S, factory: LayerGenerator<S, Yield>): LayerResult<ProviderEntry<InstanceType<S>, LayerGeneratorRequirements<S, Yield>>>;
+  /** Define a lifecycle-only entry with direct acquisition and root cleanup. */
+  static scopedDiscard<Yield extends ServiceRequirement<unknown>, Acquired>(acquire: LayerDiscardGenerator<Yield, Acquired>, release: (instance: Acquired, outcome: ScopeOutcome) => MaybePromise<void>): LayerResult<ProviderEntry<never, LayerDiscardRequirements<Yield>>>;
+  static scopedDiscard<Yield extends ServiceRequirement<unknown>, Acquired>(acquire: LayerDiscardGenerator<Yield, Acquired>, lifecycle: LayerLifecycle<Acquired>): LayerResult<ProviderEntry<never, LayerDiscardRequirements<Yield>>>;
+  static scopedDiscard<Acquired>(acquire: () => MaybePromise<Acquired>, release: (instance: Acquired, outcome: ScopeOutcome) => MaybePromise<void>): LayerResult<ProviderEntry<never, never>>;
+  static scopedDiscard<Acquired>(acquire: () => MaybePromise<Acquired>, lifecycle: LayerLifecycle<Acquired>): LayerResult<ProviderEntry<never, never>>;
+  /** Define a lifecycle-only entry whose acquisition can yield contextual Services. */
+  static scopedDiscardGen<Yield extends ServiceRequirement<unknown>, Acquired>(acquire: LayerDiscardGenerator<Yield, Acquired>, release: (instance: Acquired, outcome: ScopeOutcome) => MaybePromise<void>): LayerResult<ProviderEntry<never, LayerDiscardRequirements<Yield>>>;
+  static scopedDiscardGen<Yield extends ServiceRequirement<unknown>, Acquired>(acquire: LayerDiscardGenerator<Yield, Acquired>, lifecycle: LayerLifecycle<Acquired>): LayerResult<ProviderEntry<never, LayerDiscardRequirements<Yield>>>;
+  /** Run a no-failure Effect Program as a lifecycle-only entry. */
+  static effectDiscard<P extends AnyProgram>(program: P & EffectDiscardValidation<P>): LayerResult<ProviderEntry<never, Extract<EffectRequirements<P>, AnyService>>>;
+  /** Compose Layers without replacing providers. */
+  static merge<const Layers extends readonly LayerInput[]>(...layers: Layers & ValidateLayerTuple<Layers>): MergeResult<Layers>;
+  /** Mark a Layer composition root as complete without changing its runtime value. */
+  static complete<L extends LayerInput>(layer: L & CompleteInput<L>): L;
+  /** Replace providers in a base Layer, using tag identity and compatible contracts. */
+  static override<Base extends LayerInput>(base: Base & ValidateLayerInput<Base>): OverrideLayerResult<Base, readonly []>;
+  static override<Base extends LayerInput, const Overrides extends readonly [LayerInput, ...LayerInput[]]>(base: Base & ValidateLayerInput<Base>, ...overrides: Overrides & ValidateOverrides<Base, Overrides>): OverrideLayerResult<Base, Overrides>;
+  static override<Base extends LayerInput, const Overrides extends readonly LayerInput[]>(base: Base & ValidateLayerInput<Base>, ...overrides: Overrides & 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>;
+  /** Extract the Services still missing from a Layer composition. */
+  type Missing<L extends LayerInput> = RequiredEnvironment<L>;
+  /** Validate a Layer's requirements and input shape. */
+  type Complete<L extends LayerInput> = CompleteInput<L>;
+}
+//#endregion
+export { CompleteInput as $, RuntimeServiceAcquireEvent as A, EffectRequirements as At, forkScoped as B, ServiceContract as Bt, RuntimeExecutionStartEvent as C, ScopeClosedError as Ct, RuntimeLifecycleStartEvent as D, Effect as Dt, RuntimeLifecycleReleaseEvent as E, AnyEffect as Et, RuntimeTaskMetadata as F, ProgramFromGenerator as Ft, LayerRegistration as G, ServiceTagOf as Gt, LayerBackendDisposeOptions as H, ServiceInstance as Ht, RuntimeTaskStartEvent as I, ServiceRequirement as It, LayerGeneratorYieldError as J, DuplicateServiceError as K, ServiceToken as Kt, ScopedTask as L, AnyService as Lt, RuntimeShutdownEvent as M, EffectYield as Mt, RuntimeShutdownPhase as N, InferYieldRequirements as Nt, RuntimeObserver as O, EffectError as Ot, RuntimeTaskEndEvent as P, Program as Pt, CompleteExecutionLayer as Q, ScopedTaskExit as R, AnyServiceToken as Rt, RuntimeExecutionMetadata as S, ScopeCloseError as St, RuntimeLifecycleEventMetadata as T, Service as Tt, LayerLifecycle as U, ServiceRequirements as Ut, LayerBackend as V, ServiceIdentity as Vt, LayerQuiesce as W, ServiceTag as Wt, ServiceTagCollisionError as X, LayerRegistrationError as Y, CompleteExecution as Z, RuntimeRunOptions as _, DisposableResource as _t, ServiceRuntimeNotConfiguredError as a, OverrideLayerResult as at, RuntimeExecutionAttributes as b, ScopeOutcome as bt, RuntimeContext as c, ValidateLayerInput as ct, RuntimeExecutorRequest as d, ValidateOverridesWitness as dt, ExecutionMissing as et, RuntimeManagedExecution as f, ProviderEntry as ft, RuntimeOptions as g, CleanupFailureDiagnostic as gt, RuntimeDisposeOptions as h, Scope as ht, ServiceNotFoundError as i, MissingServices as it, RuntimeServiceResolveEvent as j, EffectSuccess as jt, RuntimeResourceReleaseEvent as k, EffectFromGenerator as kt, RuntimeContextStorage as l, ValidateOneOverride as lt, CleanupFailureObserver as m, CloseableScope as mt, CircularDependencyError as n, LayerInputState as nt, ServiceResolver as o, ProvidedEnvironment as ot, RuntimeManagedPlan as p, MissingDependencies as pt, LayerDisposeError as q, ServiceTokenOf as qt, ServiceAcquisitionError as r, LayerResult as rt, ServiceRuntime as s, RequiredEnvironment as st, Layer as t, LayerInput as tt, RuntimeExecutor as u, ValidateOverrides as ut, RuntimeShutdownDiagnostic as v, MaybePromise$1 as vt, RuntimeLifecycleEndEvent as w, ScopeRuntimeNotConfiguredError as wt, RuntimeExecutionEndEvent as x, ResourceNotDisposableError as xt, RuntimeShutdownReason as y, ScopeFinalizer as yt, ScopedTaskState as z, ServiceClass as zt };
+//# sourceMappingURL=layer-C2OaqTmB.d.mts.map