better-effect 0.5.0 → 0.6.1

package/README.md

@@ -4,7 +4,7 @@
 
 Type your errors with `better-result`. Typecheck the rest of your application wiring with `better-effect`.
 
-Use Services directly inside `Effect.gen`, compose implementations into application environments, and let TypeScript catch missing dependencies before your application starts — while keeping Promises, `better-result`, and your DI backend.
+Use Services directly inside `Effect.fn` Programs (or eager `Effect.gen` workflows), compose implementations into application environments, and let TypeScript catch missing dependencies before your application starts — while keeping Promises, `better-result`, and your DI backend.
 
 ```bash
 bun add better-effect better-result
@@ -34,7 +34,7 @@ class UserRepository extends Service<UserRepository>()('UserRepository') {
 
 const UserRepositoryLive = Layer.make(UserRepository)
 
-await Runtime.make(UserRepositoryLive, backend)
+await Runtime.make(UserRepositoryLive)
 //                 ^^^^^^^^^^^^^^^^^^
 // Type error: Database is required but not provided
 ```
@@ -44,9 +44,17 @@ literal is the Service's stable logical identity. Services with identical
 methods but different tags are different dependencies; use a namespaced tag
 such as `@acme/Database` when identities must be shared across packages.
 
-`UserRepository` used `Database`, so `Database` became part of its environment requirements.
+`UserRepository` used `Database`, so `Database` became part of its environment requirements:
 
-No dependency list was written manually.
+```ts
+type FindUser = Awaited<ReturnType<UserRepository['findUser']>>
+// Effect<User, never, Database>
+```
+
+`Effect<A, E, R>` is a type-only facade over a `better-result` Result, not an Effect TS
+instruction tree. Constructors remain the handles used by `yield*`, Layers and resolver backends;
+the public requirement `R` is a union of tagged Service instances. No dependency list was written
+manually.
 
 Services can also describe a contract without requiring a class instance. Use the
 static `of` helper to type-check a structural implementation; it returns the same
@@ -68,6 +76,15 @@ const AuthorizationLive = Layer.succeed(Authorization, authorization)
 `instanceof Authorization`. For services with constructors, private fields or
 other runtime invariants, use `new Authorization(...)` instead.
 
+Service tokens themselves are always declared through `Service<Self>()(tag)`.
+Every instance carries a required, declaration-only `ServiceIdentity<Tag>`; no
+identity property exists at runtime. `Service.Contract<Authorization>` projects
+the marker-free implementation shape accepted by `Service.of` and all Layer
+provider APIs. Those boundaries return or provide the branded Service type
+without modifying the implementation object. `Service.of(...)` does not create
+an alternate token, so the instance contract stays tied to the constructor used
+by Layers and resolver backends.
+
 Provide it and the environment becomes complete:
 
 ```ts
@@ -75,7 +92,7 @@ const DatabaseLive = Layer.make(Database)
 
 const AppLive = Layer.merge(DatabaseLive, UserRepositoryLive)
 
-const runtime = await Runtime.make(AppLive, backend)
+const runtime = await Runtime.make(AppLive)
 ```
 
 And the contract does not disappear after startup.
@@ -83,15 +100,24 @@ And the contract does not disappear after startup.
 A Runtime also knows which Services exist in its environment:
 
 ```ts
-await runtime.run(() =>
-  Effect.gen(async function* () {
-    const database = yield* Database
+const inspectDatabase = Effect.fn(async function* () {
+  const database = yield* Database
 
-    return Result.ok(database)
-  })
-)
+  return Result.ok(database)
+})
+
+await runtime.run(inspectDatabase)
 ```
 
+`Effect.gen` remains eager for code that already runs inside a resolver and
+Scope. `Effect.fn` captures the generator as a lazy `Program` for Runtime
+boundaries; the callback form remains supported for compatibility.
+
+`Runtime.make(AppLive)` and `Runtime.run(AppLive, program)` use the built-in
+`MapLayerBackend`. Pass `{ backend: new ItiLayerBackend() }` when an external
+container is needed; `MemoryLayerBackend` remains its compatibility alias from
+`better-effect/testing`.
+
 If a program asks that Runtime for a Service its environment does not provide, TypeScript rejects the call.
 
 ```text
@@ -114,6 +140,40 @@ We call this **typechecked wiring**.
 
 The Services your code uses, the implementations your Layers provide, and the programs your Runtime executes participate in the same type-level contract.
 
+A Layer's public type is `Layer<Provided, Required>`. `Provided` is the Service
+instance union produced by the Layer and `Required` is only the external
+requirement union left after composition. Preserve inferred Layers when possible;
+use `satisfies Layer<Provided, Required>` when checking an application boundary
+without erasing provider provenance.
+
+Generic infrastructure that intentionally erases this metadata can use the
+explicit `Layer.Any` sentinel, including for an empty Layer. Bare Layers,
+partial-`any` shapes and concrete unions such as `Layer<A> | Layer<B>` are not
+implicit unchecked boundaries.
+
+### Discover type helpers from their API
+
+Public type helpers are also grouped under the runtime API they describe:
+
+```ts
+import type { Effect, Layer, Runtime, Scope, Service } from 'better-effect'
+
+type Program = ReturnType<UserRepository['findUser']>
+type Success = Effect.Success<Program>
+type Failure = Effect.Error<Program>
+type Dependencies = Effect.Requirements<Program>
+type Services = Layer.Provided<typeof AppLive>
+type AppRuntime = Runtime.For<typeof AppLive>
+type DatabaseTag = Service.Tag<Database> // 'Database'
+type DatabaseToken = Service.TokenOf<Database> // Service.Token<'Database', Database>
+type Outcome = Scope.Outcome
+```
+
+These are declaration-only aliases and add nothing to the JavaScript bundle.
+The associated `Layer` helpers are intentionally namespaced; use
+`Layer.Provided`, `Layer.Required`, `Layer.Complete` and `Layer.Any` rather than
+low-level provider metadata names.
+
 ---
 
 ## Why better-effect?
@@ -181,7 +241,7 @@ Others own connections, sessions, files or other resources.
 const DatabaseLive = Layer.scoped(
   Database,
   () => Database.connect(),
-  (database) => database.close()
+  (database, outcome) => database.close(outcome)
 )
 ```
 
@@ -193,9 +253,11 @@ Resources acquired during an individual execution belong to that execution inste
 
 `better-effect` is not a replacement implementation of Effect.
 
-It does not introduce a fiber runtime, scheduler, streams, queues or a public `Effect<A, E, R>` abstraction.
+It does not introduce a fiber runtime, scheduler, streams, queues or a lazy runtime instruction tree.
 
-`Effect.gen` builds on `better-result` generator composition while carrying Service requirements through the TypeScript type system.
+Its public `Effect<A, E, R>` is only a type-level Result facade. `Effect.gen` builds on
+`better-result` generator composition while carrying Service instance requirements through the
+TypeScript type system.
 
 Dependency resolution stays behind a pluggable backend.
 
@@ -265,13 +327,14 @@ Application resources live with the Runtime. Execution resources live with the e
 
 ### better-result underneath
 
-**Result → Result.gen → Effect.gen → pipe**
+**Result → Result.gen → Effect.gen / Effect.fn → pipe**
 
 Keep `better-result` as the source of truth for typed successes, failures, short-circuiting
 and generator control flow. `Effect.gen` delegates to `Result.gen`; it adds only the
-phantom Service requirements that TypeScript needs to check the application environment.
-At runtime, an `EffectResult` is still a `better-result` Result; the requirements exist
-only in the type.
+declaration-only Service requirements that TypeScript needs to check the application environment.
+At runtime, an `Effect<A, E, R>` is still a `better-result` Result; the requirements exist
+only in the type. `Effect.Requirements`, `Layer.Provided`, `Layer.Required` and
+`Runtime.For` expose tagged Service instance unions.
 
 For a linear workflow, `pipe` composes the same kind of program without introducing a
 second Result model or a lazy Effect runtime:
@@ -295,5 +358,6 @@ or already an `Err`. The pipeline carries the requirements of every step, so Run
 still rejects it when its Layer does not provide every required Service.
 
 Use `Effect.gen` for larger workflows with several intermediate values, branches or
-procedural logic. Use `pipe` for concise, linear composition; both are ways to compose
-`better-result` programs while keeping dependency checking in the `better-effect` layer.
+procedural logic that already has a resolver. Use `Effect.fn` when the workflow should
+start at a Runtime boundary. Use `pipe` for concise, linear composition; all three
+keep dependency checking in the `better-effect` layer.

package/dist/adapters/iti.d.mts

@@ -1,4 +1,5 @@
-import { V as AnyServiceToken, t as LayerBackend, v as LayerRegistration } from "../index-D77AvuBl.mjs";
+import { T as AnyServiceToken, a as LayerRegistration, n as LayerBackend } from "../map-layer-backend-7hQkf_QP.mjs";
+import "../index-R3FdVmdr.mjs";
 //#region src/adapters/iti.d.ts
 /**
  * ITI-backed Layer backend.

package/dist/adapters/iti.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"iti.d.mts","names":[],"sources":["../../src/adapters/iti.ts"],"mappings":";;;;;;;;cAmBa,2BAA2B;UAC9B;mBAES;mBAEA;UAET;;EAgBR,SAAS,cAAc;;EAuBvB,QAAQ,UAAU,iBAAiB,OAAO,IAAI,aAAa,KAAK,YAAY,aAAa;;EAuBnF,cAAc"}
+{"version":3,"file":"iti.d.mts","names":[],"sources":["../../src/adapters/iti.ts"],"mappings":";;;;;;;;;cAsBa,2BAA2B;UAC9B;mBAES;mBAEA;UAET;;EAgBR,SAAS,cAAc;;EAuBvB,QAAQ,UAAU,iBAAiB,OAAO,IAAI,aAAa,KAAK,YAAY,aAAa;;EAyBnF,cAAc"}

package/dist/adapters/iti.mjs

@@ -1,5 +1,5 @@
-import { a as ServiceTagCollisionError, o as ServiceNotFoundError, t as DuplicateServiceError } from "../errors-GR3K_nRu.mjs";
-import { t as assertServiceCompatibility } from "../internal-identity-BnZC3Au-.mjs";
+import { l as ServiceNotFoundError, n as DuplicateServiceError, o as ServiceTagCollisionError, t as assertServiceCompatibility } from "../internal-identity-Cm4-KIUj.mjs";
+import { t as isPromiseLike } from "../runtime-CDcCF5cb.mjs";
 import { createContainer } from "iti";
 //#region src/adapters/iti.ts
 /**
@@ -33,15 +33,15 @@ var ItiLayerBackend = class {
 	}
 	/** Resolve a registered Service through the ITI container. */
 	resolve(token) {
-		if (!this.registered.has(token.serviceTag)) throw new ServiceNotFoundError(token);
 		const registered = this.registered.get(token.serviceTag);
+		if (registered === void 0) throw new ServiceNotFoundError(token);
 		const key = this.keyFor(token);
 		const resolved = this.container.get(key);
 		const validate = (instance) => {
 			assertServiceCompatibility(token, registered, instance);
 			return instance;
 		};
-		if (resolved && typeof resolved.then === "function") return Promise.resolve(resolved).then(validate);
+		if (isPromiseLike(resolved)) return Promise.resolve(resolved).then(validate);
 		return validate(resolved);
 	}
 	/** Dispose all ITI-managed provider instances. */

package/dist/adapters/iti.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"iti.mjs","names":[],"sources":["../../src/adapters/iti.ts"],"sourcesContent":["import { createContainer } from 'iti'\n\nimport {\n  DuplicateServiceError,\n  ServiceTagCollisionError,\n  type LayerBackend,\n  type LayerRegistration\n} from '../layer'\n\nimport { ServiceNotFoundError, type AnyServiceToken } from '../service'\n\nimport { assertServiceCompatibility } from '../layer/internal-identity'\n\n/**\n * ITI-backed Layer backend.\n *\n * Install `iti` as the optional peer dependency and pass an instance to\n * `Runtime.make` when using ITI's container implementation.\n */\nexport class ItiLayerBackend implements LayerBackend {\n  private container: any = createContainer()\n\n  private readonly keys = new Map<string, string>()\n\n  private readonly registered = new Map<string, AnyServiceToken>()\n\n  private keyFor(token: AnyServiceToken): string {\n    const tag = token.serviceTag\n    const existing = this.keys.get(tag)\n\n    if (existing) {\n      return existing\n    }\n\n    const key = `better-effect:${tag}`\n\n    this.keys.set(tag, key)\n\n    return key\n  }\n\n  /** Register a Layer provider under its deterministic Service-tag key. */\n  register(registration: LayerRegistration): void {\n    const token = registration.service\n    const tag = token.serviceTag\n    const existing = this.registered.get(tag)\n\n    if (existing === token) {\n      throw new DuplicateServiceError(token)\n    }\n\n    if (existing) {\n      throw new ServiceTagCollisionError(existing, token)\n    }\n\n    const key = this.keyFor(token)\n\n    this.container = this.container.add({\n      [key]: registration.acquire\n    })\n\n    this.registered.set(tag, token)\n  }\n\n  /** Resolve a registered Service through the ITI container. */\n  resolve<T extends AnyServiceToken>(token: T): InstanceType<T> | PromiseLike<InstanceType<T>> {\n    if (!this.registered.has(token.serviceTag)) {\n      throw new ServiceNotFoundError(token)\n    }\n\n    const registered = this.registered.get(token.serviceTag)\n    const key = this.keyFor(token)\n    const resolved = this.container.get(key) as unknown\n\n    const validate = (instance: unknown): InstanceType<T> => {\n      assertServiceCompatibility(token, registered!, instance)\n\n      return instance as InstanceType<T>\n    }\n\n    if (resolved && typeof (resolved as PromiseLike<unknown>).then === 'function') {\n      return Promise.resolve(resolved).then(validate)\n    }\n\n    return validate(resolved)\n  }\n\n  /** Dispose all ITI-managed provider instances. */\n  async disposeAll(): Promise<void> {\n    await this.container.disposeAll()\n  }\n}\n"],"mappings":";;;;;;;;;;AAmBA,IAAa,kBAAb,MAAqD;CACnD,YAAyB,gBAAgB;CAEzC,uBAAwB,IAAI,IAAoB;CAEhD,6BAA8B,IAAI,IAA6B;CAE/D,OAAe,OAAgC;EAC7C,MAAM,MAAM,MAAM;EAClB,MAAM,WAAW,KAAK,KAAK,IAAI,GAAG;EAElC,IAAI,UACF,OAAO;EAGT,MAAM,MAAM,iBAAiB;EAE7B,KAAK,KAAK,IAAI,KAAK,GAAG;EAEtB,OAAO;CACT;;CAGA,SAAS,cAAuC;EAC9C,MAAM,QAAQ,aAAa;EAC3B,MAAM,MAAM,MAAM;EAClB,MAAM,WAAW,KAAK,WAAW,IAAI,GAAG;EAExC,IAAI,aAAa,OACf,MAAM,IAAI,sBAAsB,KAAK;EAGvC,IAAI,UACF,MAAM,IAAI,yBAAyB,UAAU,KAAK;EAGpD,MAAM,MAAM,KAAK,OAAO,KAAK;EAE7B,KAAK,YAAY,KAAK,UAAU,IAAI,GACjC,MAAM,aAAa,QACtB,CAAC;EAED,KAAK,WAAW,IAAI,KAAK,KAAK;CAChC;;CAGA,QAAmC,OAA0D;EAC3F,IAAI,CAAC,KAAK,WAAW,IAAI,MAAM,UAAU,GACvC,MAAM,IAAI,qBAAqB,KAAK;EAGtC,MAAM,aAAa,KAAK,WAAW,IAAI,MAAM,UAAU;EACvD,MAAM,MAAM,KAAK,OAAO,KAAK;EAC7B,MAAM,WAAW,KAAK,UAAU,IAAI,GAAG;EAEvC,MAAM,YAAY,aAAuC;GACvD,2BAA2B,OAAO,YAAa,QAAQ;GAEvD,OAAO;EACT;EAEA,IAAI,YAAY,OAAQ,SAAkC,SAAS,YACjE,OAAO,QAAQ,QAAQ,QAAQ,CAAC,CAAC,KAAK,QAAQ;EAGhD,OAAO,SAAS,QAAQ;CAC1B;;CAGA,MAAM,aAA4B;EAChC,MAAM,KAAK,UAAU,WAAW;CAClC;AACF"}
+{"version":3,"file":"iti.mjs","names":[],"sources":["../../src/adapters/iti.ts"],"sourcesContent":["import { createContainer } from 'iti'\n\nimport {\n  DuplicateServiceError,\n  ServiceTagCollisionError,\n  type LayerBackend,\n  type LayerRegistration\n} from '../layer'\n\nimport { ServiceNotFoundError, type AnyServiceToken } from '../service'\n\nimport { assertServiceCompatibility } from '../layer/internal-identity'\nimport { isPromiseLike } from '../utils/runtime'\n\ntype LayerAcquiredValue = Awaited<ReturnType<LayerRegistration['acquire']>>\n\n/**\n * ITI-backed Layer backend.\n *\n * Install `iti` as the optional peer dependency and pass an instance to\n * `Runtime.make` when using ITI's container implementation.\n */\nexport class ItiLayerBackend implements LayerBackend {\n  private container: any = createContainer()\n\n  private readonly keys = new Map<string, string>()\n\n  private readonly registered = new Map<string, AnyServiceToken>()\n\n  private keyFor(token: AnyServiceToken): string {\n    const tag = token.serviceTag\n    const existing = this.keys.get(tag)\n\n    if (existing) {\n      return existing\n    }\n\n    const key = `better-effect:${tag}`\n\n    this.keys.set(tag, key)\n\n    return key\n  }\n\n  /** Register a Layer provider under its deterministic Service-tag key. */\n  register(registration: LayerRegistration): void {\n    const token = registration.service\n    const tag = token.serviceTag\n    const existing = this.registered.get(tag)\n\n    if (existing === token) {\n      throw new DuplicateServiceError(token)\n    }\n\n    if (existing) {\n      throw new ServiceTagCollisionError(existing, token)\n    }\n\n    const key = this.keyFor(token)\n\n    this.container = this.container.add({\n      [key]: registration.acquire\n    })\n\n    this.registered.set(tag, token)\n  }\n\n  /** Resolve a registered Service through the ITI container. */\n  resolve<T extends AnyServiceToken>(token: T): InstanceType<T> | PromiseLike<InstanceType<T>> {\n    const registered = this.registered.get(token.serviceTag)\n\n    if (registered === undefined) {\n      throw new ServiceNotFoundError(token)\n    }\n\n    const key = this.keyFor(token)\n    const resolved = this.container.get(key)\n\n    const validate = (instance: LayerAcquiredValue): InstanceType<T> => {\n      assertServiceCompatibility(token, registered, instance)\n\n      // SAFETY: The registered tag and compatibility check establish the constructor-to-instance relationship after ITI erases it.\n      return instance as InstanceType<T>\n    }\n\n    if (isPromiseLike(resolved)) {\n      return Promise.resolve(resolved).then(validate)\n    }\n\n    return validate(resolved)\n  }\n\n  /** Dispose all ITI-managed provider instances. */\n  async disposeAll(): Promise<void> {\n    await this.container.disposeAll()\n  }\n}\n"],"mappings":";;;;;;;;;;AAsBA,IAAa,kBAAb,MAAqD;CACnD,YAAyB,gBAAgB;CAEzC,uBAAwB,IAAI,IAAoB;CAEhD,6BAA8B,IAAI,IAA6B;CAE/D,OAAe,OAAgC;EAC7C,MAAM,MAAM,MAAM;EAClB,MAAM,WAAW,KAAK,KAAK,IAAI,GAAG;EAElC,IAAI,UACF,OAAO;EAGT,MAAM,MAAM,iBAAiB;EAE7B,KAAK,KAAK,IAAI,KAAK,GAAG;EAEtB,OAAO;CACT;;CAGA,SAAS,cAAuC;EAC9C,MAAM,QAAQ,aAAa;EAC3B,MAAM,MAAM,MAAM;EAClB,MAAM,WAAW,KAAK,WAAW,IAAI,GAAG;EAExC,IAAI,aAAa,OACf,MAAM,IAAI,sBAAsB,KAAK;EAGvC,IAAI,UACF,MAAM,IAAI,yBAAyB,UAAU,KAAK;EAGpD,MAAM,MAAM,KAAK,OAAO,KAAK;EAE7B,KAAK,YAAY,KAAK,UAAU,IAAI,GACjC,MAAM,aAAa,QACtB,CAAC;EAED,KAAK,WAAW,IAAI,KAAK,KAAK;CAChC;;CAGA,QAAmC,OAA0D;EAC3F,MAAM,aAAa,KAAK,WAAW,IAAI,MAAM,UAAU;EAEvD,IAAI,eAAe,KAAA,GACjB,MAAM,IAAI,qBAAqB,KAAK;EAGtC,MAAM,MAAM,KAAK,OAAO,KAAK;EAC7B,MAAM,WAAW,KAAK,UAAU,IAAI,GAAG;EAEvC,MAAM,YAAY,aAAkD;GAClE,2BAA2B,OAAO,YAAY,QAAQ;GAGtD,OAAO;EACT;EAEA,IAAI,cAAc,QAAQ,GACxB,OAAO,QAAQ,QAAQ,QAAQ,CAAC,CAAC,KAAK,QAAQ;EAGhD,OAAO,SAAS,QAAQ;CAC1B;;CAGA,MAAM,aAA4B;EAChC,MAAM,KAAK,UAAU,WAAW;CAClC;AACF"}

package/dist/index-R3FdVmdr.d.mts

@@ -0,0 +1,297 @@
+import { A as ServiceRequirements, C as ServiceRequirement, D as ServiceContract, E as ServiceClass, M as ServiceTagOf, N as ServiceToken, P as ServiceTokenOf, T as AnyServiceToken, a as LayerRegistration, i as LayerGeneratorRequirements, n as LayerBackend, o as MaybePromise$1, r as LayerGenerator, v as EffectRequirements, w as AnyService } from "./map-layer-backend-7hQkf_QP.mjs";
+//#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<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<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<void>;
+};
+type AsyncDisposableResource = {
+  [Symbol.dispose]?: () => void;
+  [Symbol.asyncDispose]: () => MaybePromise<void>;
+};
+/** A value implementing at least one JavaScript disposal protocol. */
+type DisposableResource = SyncDisposableResource | AsyncDisposableResource;
+//#endregion
+//#region src/internal/variance.d.ts
+/** Type-level marker for a value produced by `A`. */
+type Covariant<A> = () => A;
+/** Type-level marker that both consumes and produces `A`. */
+type Invariant<A> = (value: A) => A;
+//#endregion
+//#region src/internal/missing-dependencies.d.ts
+declare const MissingDependenciesTypeId: unique symbol;
+type MissingDependencies<Missing extends AnyService> = {
+  readonly [MissingDependenciesTypeId]: Missing;
+};
+//#endregion
+//#region src/layer/metadata.d.ts
+/** Package-private declaration-only carrier for inferred Layer provenance. */
+declare const LayerProvenanceTypeId: unique symbol;
+interface ProviderEntry<out Provided extends AnyService, out RawRequired extends AnyService = never> {
+  readonly provided: Provided;
+  readonly required: RawRequired;
+}
+interface ErasedProvenance<out Provided extends AnyService, out StickyRequired extends AnyService> {
+  readonly provided: Provided;
+  readonly stickyRequired: StickyRequired;
+}
+interface LayerProvenance<out Entries extends ProviderEntry<AnyService, AnyService> = never, out Erased extends ErasedProvenance<AnyService, AnyService> = never> {
+  readonly [LayerProvenanceTypeId]: {
+    readonly entries: Entries;
+    readonly erased: Erased;
+  };
+}
+//#endregion
+//#region src/layer/inference.d.ts
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type IsNever<T> = [T] extends [never] ? true : false;
+type IsUnion<T, Candidate = T> = T extends unknown ? [Candidate] extends [T] ? false : true : never;
+/** Any Layer shape accepted by type-level inference helpers. */
+type LayerInput = Layer<any, any> | Layer<never, any>;
+/** Extract the public Service environment channels from a Layer. */
+type ProvidedEnvironment<L extends LayerInput> = L extends Layer<infer Provided, infer _Required> ? Provided : never;
+type RequiredEnvironment<L extends LayerInput> = L extends Layer<infer _Provided, infer Required> ? Required : never;
+type HasWidenedTag<Services> = IsAny<Services> extends true ? false : Services extends AnyService ? string extends ServiceTagOf<Services> ? true : false : false;
+type SameServiceTag<Left extends AnyService, Right extends AnyService> = [ServiceTagOf<Left>] extends [ServiceTagOf<Right>] ? [ServiceTagOf<Right>] extends [ServiceTagOf<Left>] ? true : false : false;
+type SameServiceContract<Left extends AnyService, Right extends AnyService> = [ServiceContract<Left>] extends [ServiceContract<Right>] ? [ServiceContract<Right>] extends [ServiceContract<Left>] ? true : false : false;
+type SameService<Left extends AnyService, Right extends AnyService> = SameServiceTag<Left, Right> extends true ? SameServiceContract<Left, Right> : false;
+type RequirementProvided<Requirement extends AnyService, Provided extends AnyService> = Provided extends AnyService ? SameService<Requirement, Provided> : false;
+type MissingRequirement<Requirement extends AnyService, Provided> = true extends RequirementProvided<Requirement, Extract<Provided, AnyService>> ? never : Requirement;
+/**
+ * Existing Runtime matching semantics. Widened Service environments are an
+ * explicit execution erasure and therefore satisfy every concrete requirement.
+ */
+type MissingServices<Required extends AnyService, Provided extends AnyService> = ServiceToken<string, Required> extends ServiceToken<string, Provided> ? never : IsAny<Required> extends true ? never : IsAny<Provided> extends true ? never : true extends HasWidenedTag<Required | Provided> ? never : Required extends AnyService ? MissingRequirement<Required, Provided> : never;
+/** Layer matching that keeps widened Service.Any as an external requirement. */
+type LayerExternalRequirements<RawRequired extends AnyService, Provided extends AnyService> = true extends HasWidenedTag<Extract<RawRequired | Provided, AnyService>> ? Extract<RawRequired, AnyService> : MissingServices<RawRequired, Provided>;
+type AnyProviderEntry = ProviderEntry<AnyService, AnyService>;
+type AnyErasedProvenance = ErasedProvenance<AnyService, AnyService>;
+type EntryProvided<Entries> = Entries extends ProviderEntry<infer Provided, any> ? Provided : never;
+type EntryRequired<Entries> = Entries extends ProviderEntry<any, infer Required> ? Required : never;
+type ErasedProvided<Erased> = Erased extends ErasedProvenance<infer Provided, any> ? Provided : never;
+type ErasedRequired<Erased> = Erased extends ErasedProvenance<any, infer Required> ? Required : never;
+/** Extract precise provider entries carried by an inferred Layer. */
+type PreciseEntries<L extends LayerInput> = L extends LayerProvenance<infer Entries, any> ? Entries : never;
+/**
+ * Extract erased provenance, falling back to the public channels for an
+ * explicitly annotated Layer.
+ */
+type ErasedEntries<L extends LayerInput> = L extends LayerProvenance<any, infer Erased> ? Erased : [ProvidedEnvironment<L> | RequiredEnvironment<L>] extends [never] ? never : ErasedProvenance<ProvidedEnvironment<L>, RequiredEnvironment<L>>;
+type LayerMetadata<Entries extends AnyProviderEntry, Erased extends AnyErasedProvenance> = [Entries | Erased] extends [never] ? unknown : LayerProvenance<Entries, Erased>;
+/** Opaque internal result type used by Layer constructors and combinators. */
+type LayerResult<Entries extends AnyProviderEntry, Erased extends AnyErasedProvenance = never> = Layer<EntryProvided<Entries> | ErasedProvided<Erased>, LayerExternalRequirements<EntryRequired<Entries> | ErasedRequired<Erased>, EntryProvided<Entries> | ErasedProvided<Erased>>> & LayerMetadata<Entries, Erased>;
+type LayerChannelPair<L> = L extends Layer<infer Provided, infer Required> ? [Provided, Required] : never;
+type ExactUncheckedArm<L> = LayerChannelPair<L> extends [infer Provided extends AnyService, infer Required extends AnyService] ? IsAny<Provided> extends true ? IsAny<Required> extends true ? true : false : IsNever<Provided> extends true ? IsAny<Required> extends true ? true : false : false : false;
+type HasUncheckedProvidedArm<L> = L extends unknown ? LayerChannelPair<L> extends [infer Provided, infer Required] ? IsAny<Provided> extends true ? IsAny<Required> extends true ? true : false : false : false : never;
+type HasUncheckedEmptyArm<L> = L extends unknown ? LayerChannelPair<L> extends [infer Provided, infer Required] ? IsNever<Provided> extends true ? IsAny<Required> extends true ? true : false : false : false : never;
+type HasNonUncheckedArm<L> = L extends unknown ? ExactUncheckedArm<L> extends true ? false : true : never;
+/** Recognize only the documented exact unchecked Layer sentinels. */
+type IsExactUncheckedLayer<L> = IsUnion<L> extends false ? ExactUncheckedArm<L> : true extends HasNonUncheckedArm<L> ? false : true extends HasUncheckedProvidedArm<L> ? true extends HasUncheckedEmptyArm<L> ? true : false : false;
+type PartialAnyArm<L> = LayerChannelPair<L> extends [infer Provided extends AnyService, infer Required extends AnyService] ? IsAny<Provided> extends true ? IsAny<Required> extends true ? false : true : IsAny<Required> extends true ? IsNever<Provided> extends true ? false : true : false : false;
+/** Detect any Layer constituent with only one erased generic channel. */
+type HasPartialAnyChannel<L> = true extends (L extends unknown ? PartialAnyArm<L> : never) ? true : false;
+/** Detect a concrete union of Layer values, preserving the original shape. */
+type IsConcreteUnion<L> = IsAny<L> extends true ? false : IsUnion<L> extends true ? IsExactUncheckedLayer<L> extends true ? false : true : false;
+type LayerInputState<L> = IsExactUncheckedLayer<L> extends true ? 'unchecked' : HasPartialAnyChannel<L> extends true ? 'invalid-partial-any' : IsConcreteUnion<L> extends true ? 'invalid-union' : 'typed';
+type InvalidLayerErasure = {
+  readonly __betterEffectInvalidLayerErasure: unique symbol;
+};
+type AmbiguousLayerUnion = {
+  readonly __betterEffectAmbiguousLayerUnion: unique symbol;
+};
+/** Validate an original Layer argument without widening it to Layer.Any. */
+type ValidateLayerInput<L extends LayerInput> = LayerInputState<L> extends 'invalid-partial-any' ? InvalidLayerErasure : LayerInputState<L> extends 'invalid-union' ? AmbiguousLayerUnion : unknown;
+/** Validate every original element of a merge tuple. */
+type ValidateLayerTuple<Layers extends readonly LayerInput[]> = { [Index in keyof Layers]: ValidateLayerInput<Layers[Index]>; };
+/** Remove compatible Services from a union while retaining all other identities. */
+type RemoveCompatibleServices<Provided extends AnyService, Replacements extends AnyService> = Provided extends AnyService ? true extends (Replacements extends AnyService ? SameService<Provided, Replacements> : false) ? never : Provided : never;
+type HasCompatibleService<Provided extends AnyService, Replacements extends AnyService> = true extends (Replacements extends AnyService ? SameService<Provided, Replacements> : false) ? true : false;
+type RemoveCompatibleEntries<Entries extends AnyProviderEntry, Replacements extends AnyService> = Entries extends ProviderEntry<infer Provided, any> ? HasCompatibleService<Provided, Replacements> extends true ? never : Entries : never;
+type ReplacePreciseOne<Entries extends AnyProviderEntry, Replacement extends LayerInput> = RemoveCompatibleEntries<Entries, Extract<ProvidedEnvironment<Replacement>, AnyService>> | PreciseEntries<Replacement>;
+type ReplaceErasedOne<Erased extends AnyErasedProvenance, Replacement extends LayerInput> = Erased extends ErasedProvenance<infer Provided, infer StickyRequired> ? ErasedProvenance<RemoveCompatibleServices<Provided, Extract<ProvidedEnvironment<Replacement>, AnyService>>, StickyRequired> : never;
+type ApplyPreciseOverrides<Entries extends AnyProviderEntry, Overrides extends readonly LayerInput[]> = Overrides extends readonly [infer Head extends LayerInput, ...infer Tail extends readonly LayerInput[]] ? ApplyPreciseOverrides<ReplacePreciseOne<Entries, Head>, Tail> : Entries;
+type ApplyErasedOverrides<Erased extends AnyErasedProvenance, Overrides extends readonly LayerInput[]> = Overrides extends readonly [infer Head extends LayerInput, ...infer Tail extends readonly LayerInput[]] ? ApplyErasedOverrides<ReplaceErasedOne<Erased, Head> | Extract<ErasedEntries<Head>, AnyErasedProvenance>, Tail> : Erased;
+type HasUncheckedLayerInTuple<Layers extends readonly LayerInput[]> = true extends (Layers[number] extends unknown ? IsExactUncheckedLayer<Layers[number]> : never) ? true : false;
+type MergeLayerResult<Layers extends readonly LayerInput[]> = HasUncheckedLayerInTuple<Layers> extends true ? Layer<any, any> : LayerResult<PreciseEntries<Layers[number]>, ErasedEntries<Layers[number]>>;
+/** Internal result type for Layer.merge. */
+type MergeResult<Layers extends readonly LayerInput[]> = MergeLayerResult<Layers>;
+type OverrideLayerResultUnchecked<Base extends LayerInput, Overrides extends readonly LayerInput[]> = HasUncheckedLayerInTuple<[Base, ...Overrides]> extends true ? Layer<any, any> : LayerResult<ApplyPreciseOverrides<PreciseEntries<Base>, Overrides>, ApplyErasedOverrides<ErasedEntries<Base>, Overrides>>;
+/** Internal result type for Layer.override. */
+type OverrideResult<Base extends LayerInput, Replacement extends LayerInput> = OverrideLayerResultUnchecked<Base, readonly [Replacement]>;
+/** Internal result type for an ordered override tuple. */
+type OverrideLayerResult<Base extends LayerInput, Overrides extends readonly LayerInput[]> = OverrideLayerResultUnchecked<Base, Overrides>;
+type IncompatibleOverridePair<Current extends AnyService, Replacement extends AnyService> = SameServiceTag<Current, Replacement> extends true ? SameServiceContract<Current, Replacement> extends true ? never : ServiceTokenOf<Replacement> : never;
+/** Fully distributive same-tag incompatible override comparison. */
+type IncompatibleOverridePairs<CurrentProvided extends AnyService, ReplacementProvided extends AnyService> = CurrentProvided extends AnyService ? ReplacementProvided extends AnyService ? IncompatibleOverridePair<CurrentProvided, ReplacementProvided> : never : never;
+type IncompatibleLayerOverride<Tokens extends AnyServiceToken> = {
+  readonly __betterEffectIncompatibleLayerOverride: Tokens;
+};
+type InvalidWidenedProvidedEnvironment = {
+  readonly __betterEffectWidenedProvidedEnvironment: unique symbol;
+};
+type ValidateOverrideLayerInput<L extends LayerInput> = IsExactUncheckedLayer<L> extends true ? unknown : ValidateLayerInput<L> & (true extends HasWidenedTag<Extract<ProvidedEnvironment<L>, AnyService>> ? InvalidWidenedProvidedEnvironment : unknown);
+/** Validate one override against the currently accumulated Layer state. */
+type ValidateOneOverride<Current extends LayerInput, Replacement extends LayerInput> = ValidateOverrideLayerInput<Current> & ValidateOverrideLayerInput<Replacement> & (IsExactUncheckedLayer<Current> extends true ? unknown : IsExactUncheckedLayer<Replacement> extends true ? unknown : [IncompatibleOverridePairs<Extract<ProvidedEnvironment<Current>, AnyService>, Extract<ProvidedEnvironment<Replacement>, AnyService>>] extends [never] ? unknown : IncompatibleLayerOverride<IncompatibleOverridePairs<Extract<ProvidedEnvironment<Current>, AnyService>, Extract<ProvidedEnvironment<Replacement>, AnyService>>>);
+/** Validate ordered overrides against the state produced by earlier overrides. */
+type ValidateOverrides<Base extends LayerInput, Overrides extends readonly LayerInput[]> = Overrides extends readonly [infer Head extends LayerInput, ...infer Tail extends readonly LayerInput[]] ? ValidateOneOverride<Base, Head> & ValidateOverrides<OverrideResult<Base, Head>, Tail> : unknown;
+/** A Layer accepted by Runtime boundaries after completeness validation. */
+type CompleteInput<L extends LayerInput> = ValidateLayerInput<L> & (LayerInputState<L> extends 'unchecked' ? L : LayerInputState<L> extends 'typed' ? [RequiredEnvironment<L>] extends [never] ? L : L & MissingDependencies<Extract<RequiredEnvironment<L>, AnyService>> : L);
+type ExecutionProgram<A> = () => A | PromiseLike<A>;
+type CompleteExecutionWithRequirements<Provided extends AnyService, A, Required extends AnyService> = [MissingServices<Required, Provided>] extends [never] ? ExecutionProgram<A> : ExecutionProgram<A> & MissingDependencies<MissingServices<Required, Provided>>;
+/** Keep execution callbacks unchanged when their Effect requirements are met. */
+type CompleteExecution<Provided extends AnyService, A> = CompleteExecutionWithRequirements<Provided, A, EffectRequirements<A>>;
+//#endregion
+//#region src/layer/layer.d.ts
+declare const LayerTypeId: unique symbol;
+interface LayerVariance<in out Provided, out Required> {
+  readonly _Provided: Invariant<Provided>;
+  readonly _Required: Covariant<Required>;
+}
+interface LayerProvider extends LayerRegistration {
+  /** Provider storage deliberately erases the concrete instance type. */
+  readonly release?: (instance: unknown, outcome: ScopeOutcome) => MaybePromise$1<void>;
+}
+/** A Service class whose constructor can be called without arguments. */
+type DefaultConstructibleServiceClass<Tag extends string = string, Instance extends AnyService = AnyService> = ServiceClass<Tag, Instance> & (new () => Instance);
+/**
+ * Declarative collection of Service providers.
+ *
+ * A Layer describes how to acquire implementations; it does not execute
+ * providers until a `Runtime` is created. Use `merge` to compose distinct
+ * providers and `override` when replacing an existing provider intentionally.
+ *
+ * @example
+ * ```ts
+ * const AppLive = Layer.merge(
+ *   Layer.succeed(Database, database),
+ *   Layer.make(UserRepository)
+ * )
+ *
+ * const runtime = await Runtime.make(AppLive, backend)
+ * ```
+ */
+declare class Layer<in out Provided extends AnyService = AnyService, out Required extends AnyService = AnyService> {
+  readonly [LayerTypeId]: LayerVariance<Provided, Required>;
+  /** The provider registrations retained by this Layer. */
+  readonly providers: readonly LayerProvider[];
+  private constructor();
+  /** Create a Layer that lazily acquires a Service instance. */
+  static make<S extends DefaultConstructibleServiceClass<any, any>>(service: S): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>>;
+  static make<S extends ServiceClass<any, any>>(service: S, acquire: () => MaybePromise$1<ServiceContract<InstanceType<S>>>): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>>;
+  /** Create a Layer from an already-constructed Service instance. */
+  static succeed<S extends ServiceClass<any, any>>(service: S, instance: ServiceContract<InstanceType<S>>): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>>;
+  /** Define a provider with Runtime-root cleanup. */
+  static scoped<S extends ServiceClass<any, any>>(service: S, acquire: () => MaybePromise$1<ServiceContract<InstanceType<S>>>, release: (instance: InstanceType<S>, outcome: ScopeOutcome) => MaybePromise$1<void>): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>>;
+  /** Define a provider whose acquisition can yield contextual Services. */
+  static scopedGen<S extends ServiceClass<any, any>, Yield extends ServiceRequirement<unknown>>(service: S, factory: LayerGenerator<S, Yield>, release: (instance: InstanceType<S>, outcome: ScopeOutcome) => MaybePromise$1<void>): LayerResult<ProviderEntry<InstanceType<S>, LayerGeneratorRequirements<S, Yield>>>;
+  /** Define a provider whose acquisition can yield contextual Services. */
+  static gen<S extends ServiceClass<any, any>, Yield extends ServiceRequirement<unknown>>(service: S, factory: LayerGenerator<S, Yield>): LayerResult<ProviderEntry<InstanceType<S>, LayerGeneratorRequirements<S, Yield>>>;
+  /** Compose Layers without replacing providers. */
+  static merge<const Layers extends readonly LayerInput[]>(...layers: Layers & ValidateLayerTuple<Layers>): MergeResult<Layers>;
+  /** Replace providers in a base Layer, using tag identity and compatible contracts. */
+  static override<Base extends LayerInput, const Overrides extends readonly LayerInput[]>(base: Base & ValidateLayerInput<Base>, ...overrides: Overrides & ValidateOverrides<Base, Overrides>): OverrideLayerResult<Base, Overrides>;
+}
+/** Type-level aliases for inspecting Layer environments and completeness. */
+declare namespace Layer {
+  /** The widened Layer shape accepted by generic Layer infrastructure. */
+  type Any = LayerInput;
+  /** Extract the branded Service instances provided by a Layer. */
+  type Provided<L extends LayerInput> = ProvidedEnvironment<L>;
+  /** Extract the external Service requirements of a Layer. */
+  type Required<L extends LayerInput> = RequiredEnvironment<L>;
+  /** Validate a Layer's requirements and input shape. */
+  type Complete<L extends LayerInput> = CompleteInput<L>;
+}
+//#endregion
+//#region src/layer/errors.d.ts
+type LayerCause = Extract<ScopeOutcome, {
+  readonly status: 'failure';
+}>['cause'];
+/** Thrown when a Layer registers the same Service tag more than once. */
+declare class DuplicateServiceError extends Error {
+  readonly service: ServiceClass<any>;
+  constructor(service: ServiceClass<any>);
+}
+/** Thrown when one Service tag is associated with incompatible constructors. */
+declare class ServiceTagCollisionError extends Error {
+  readonly existing: AnyServiceToken;
+  readonly incoming: AnyServiceToken;
+  constructor(existing: AnyServiceToken, incoming: AnyServiceToken);
+}
+/** Thrown when a backend fails while registering a Layer provider. */
+declare class LayerRegistrationError extends Error {
+  readonly service: ServiceClass<any> | undefined;
+  readonly registrationCause: LayerCause;
+  readonly cleanupCause?: LayerCause | undefined;
+  constructor(service: ServiceClass<any> | undefined, registrationCause: LayerCause, cleanupCause?: LayerCause | undefined);
+}
+/** Thrown when one or more Layer-owned resources fail during disposal. */
+declare class LayerDisposeError extends Error {
+  readonly causes: readonly unknown[];
+  constructor(causes: readonly unknown[]);
+}
+/** Thrown when a Layer generator yields a value other than a Service requirement. */
+declare class LayerGeneratorYieldError extends Error {
+  readonly service: ServiceClass<any>;
+  constructor(service: ServiceClass<any>);
+}
+//#endregion
+//#region src/runtime/outcome.d.ts
+/** Aggregated cleanup information reported during Runtime shutdown. */
+type RuntimeShutdownDiagnostic = {
+  /** Final outcome supplied to the Runtime root Scope. */
+  readonly outcome: ScopeOutcome;
+  /** Aggregated root-Scope and backend cleanup failure. */
+  readonly error: LayerDisposeError;
+};
+/** Observer notified about cleanup failures without changing primary results. */
+type CleanupFailureObserver = (diagnostic: CleanupFailureDiagnostic | RuntimeShutdownDiagnostic) => MaybePromise<void>;
+/** Optional Runtime configuration for cleanup diagnostics. */
+type RuntimeOptions = {
+  /** Backend used to register and resolve the Layer. Defaults to MapLayerBackend. */
+  readonly backend?: LayerBackend;
+  /** Optional observer for best-effort cleanup diagnostics. */
+  readonly onCleanupFailure?: CleanupFailureObserver;
+};
+//#endregion
+export { ScopeRuntimeNotConfiguredError as S, ScopeFinalizer as _, LayerDisposeError as a, ScopeCloseError as b, ServiceTagCollisionError as c, CompleteInput as d, LayerInput as f, MaybePromise as g, DisposableResource as h, DuplicateServiceError as i, Layer as l, CleanupFailureDiagnostic as m, RuntimeOptions as n, LayerGeneratorYieldError as o, ProvidedEnvironment as p, RuntimeShutdownDiagnostic as r, LayerRegistrationError as s, CleanupFailureObserver as t, CompleteExecution as u, ScopeOutcome as v, ScopeClosedError as x, ResourceNotDisposableError as y };
+//# sourceMappingURL=index-R3FdVmdr.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-R3FdVmdr.d.mts","names":[],"sources":["../src/scope/errors.ts","../src/scope/types.ts","../src/internal/variance.ts","../src/internal/missing-dependencies.ts","../src/layer/metadata.ts","../src/layer/inference.ts","../src/layer/layer.ts","../src/layer/errors.ts","../src/runtime/outcome.ts"],"mappings":"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"}