better-effect 0.12.0 → 0.14.0

package/dist/{outcome-CB43bnFW.d.mts → layer-C2OaqTmB.d.mts}

@@ -1,12 +1,313 @@
-import { F as ServiceContract, H as ServiceToken, L as ServiceIdentityTypeId, M as AnyService, N as AnyServiceToken, O as InferYieldRequirements, P as ServiceClass, T as EffectRequirements, U as ServiceTokenOf, V as ServiceTagOf, a as ServiceResolver, c as RuntimeContextStorage, d as CleanupFailureDiagnostic, f as DisposableResource, h as ScopeOutcome, j as ServiceRequirement, m as ScopeFinalizer, p as MaybePromise$1, u as Scope, z as ServiceRequirements } from "./index-heuaRmXR.mjs";
-//#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;
+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/utils/types.d.ts
-type MaybePromise<T> = T | PromiseLike<T>;
+//#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> = {
@@ -182,11 +483,54 @@ type CompleteExecutionWithRequirements<Provided extends AnyService, A, Required
 /** 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: ServiceClass<any, any>;
+  readonly service: ServiceToken<any, any>;
   /**
    * The canonical tag captured when the provider was created.
    *
@@ -197,104 +541,17 @@ interface LayerRegistration {
   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 ServiceClass<any, any>, Yield extends ServiceRequirement<unknown> = ServiceRequirement<unknown>> = () => AsyncGenerator<Yield, ServiceContract<InstanceType<S>>, unknown>;
+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 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>;
-}
-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>;
-  /** Capture acquisition-local cleanup without retaining the acquired instance. */
-  readonly acquireWithRelease?: () => MaybePromise<CapturedLayerAcquisition>;
-}
-/** 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 ServiceClass<any, any>, To extends ServiceClass<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 provider registrations retained by this Layer. */
-  readonly providers: readonly LayerProvider[];
-  private constructor();
-  /** 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 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>>>>;
-  /** Alias a source Service under a compatible target contract. */
-  static alias<From extends ServiceClass<any, any>, To extends ServiceClass<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 ServiceClass<any, any>>(service: S, acquire: () => MaybePromise<ServiceContract<InstanceType<S>>>, release: (instance: InstanceType<S>, outcome: ScopeOutcome) => MaybePromise<void>): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>>;
-  /** Define a provider with Runtime-root cleanup through its disposal protocol. */
-  static scopedDisposable<S extends ServiceClass<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 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>;
-  /** 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>;
-}
+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. */
@@ -313,51 +570,64 @@ interface LayerBackend extends ServiceResolver {
   disposeAll(options?: LayerBackendDisposeOptions): MaybePromise<void>;
 }
 //#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>);
-}
+//#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>>;
@@ -376,15 +646,57 @@ type RuntimeExecutionStartEvent = RuntimeExecutionMetadata & {
 /** 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 = {
@@ -392,7 +704,13 @@ type RuntimeObserver = {
   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: {
@@ -400,6 +718,12 @@ declare const 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. */
@@ -436,7 +760,228 @@ type RuntimeDisposeOptions = {
   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 { MissingServices as A, CompleteExecution as C, LayerInput as D, ExecutionMissing as E, ValidateOneOverride as F, ValidateOverrides as I, ValidateOverridesWitness as L, ProvidedEnvironment as M, RequiredEnvironment as N, LayerInputState as O, ValidateLayerInput as P, ProviderEntry as R, LayerRegistration as S, CompleteInput as T, LayerRegistrationError as _, RuntimeShutdownDiagnostic as a, LayerBackendDisposeOptions as b, RuntimeExecutionMetadata as c, RuntimeResourceReleaseEvent as d, RuntimeServiceAcquireEvent as f, LayerGeneratorYieldError as g, LayerDisposeError as h, RuntimeRunOptions as i, OverrideLayerResult as j, LayerResult as k, RuntimeExecutionStartEvent as l, DuplicateServiceError as m, RuntimeDisposeOptions as n, RuntimeExecutionAttributes as o, RuntimeServiceResolveEvent as p, RuntimeOptions as r, RuntimeExecutionEndEvent as s, CleanupFailureObserver as t, RuntimeObserver as u, ServiceTagCollisionError as v, CompleteExecutionLayer as w, Layer as x, LayerBackend as y, MissingDependencies as z };
-//# sourceMappingURL=outcome-CB43bnFW.d.mts.map
+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