better-effect 0.6.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
 ```
@@ -92,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.
@@ -100,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
@@ -232,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)
 )
 ```
 
@@ -318,11 +327,11 @@ 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.
+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.
@@ -349,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 { d as LayerRegistration, t as LayerBackend, z as AnyServiceToken } from "../index-DMfjhNR_.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":";;;;;;;;cAsBa,2BAA2B;UAC9B;mBAES;mBAEA;UAET;;EAgBR,SAAS,cAAc;;EAuBvB,QAAQ,UAAU,iBAAiB,OAAO,IAAI,aAAa,KAAK,YAAY,aAAa;;EAyBnF,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,6 +1,5 @@
-import { a as ServiceTagCollisionError, o as ServiceNotFoundError, t as DuplicateServiceError } from "../errors-GR3K_nRu.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 { t as assertServiceCompatibility } from "../internal-identity-C6Awrc33.mjs";
 import { createContainer } from "iti";
 //#region src/adapters/iti.ts
 /**

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'\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"}
+{"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-DMfjhNR_.d.mts → index-R3FdVmdr.d.mts}

@@ -1,184 +1,4 @@
-import { Err, InferErr, InferOk, Result } from "better-result";
-//#region src/service/types.d.ts
-/** Internal type-only identity for the branded Service instance. */
-declare const ServiceIdentityTypeId: unique symbol;
-/** A branded Service instance identity carried by the literal Service tag. */
-interface ServiceIdentity<out Tag extends string = string> {
-  readonly [ServiceIdentityTypeId]: Tag;
-}
-/** The widened Service instance constraint used by contextual APIs. */
-type AnyService = ServiceIdentity<string>;
-/** Remove the internal Service identity marker from an implementation contract. */
-type ServiceContract<S> = S extends unknown ? Omit<S, typeof ServiceIdentityTypeId> : never;
-type ServiceStatics<out Tag extends string, in out Instance extends AnyService> = {
-  readonly name: string;
-  readonly serviceTag: Tag;
-  /** Type-check a structural implementation and return it unchanged. */
-  readonly of: (this: void, implementation: ServiceContract<Instance>) => Instance;
-};
-type AbstractServiceConstructor<out Instance> = abstract new (...args: any[]) => Instance;
-/** A class constructor carrying a Service tag and its instance contract. */
-interface ServiceToken<out Tag extends string = string, in out Instance extends AnyService = any> extends AbstractServiceConstructor<Instance>, ServiceStatics<Tag, Instance> {}
-/** The widened token constraint used by generic Service infrastructure. */
-type AnyServiceToken = ServiceToken<string, any>;
-/** A concrete, constructible Service class accepted by a Layer provider. */
-type ServiceClass<Tag extends string = string, Instance extends AnyService = AnyService> = (new (...args: any[]) => Instance) & ServiceStatics<Tag, Instance>;
-/** Extract the instance type represented by a Service token. */
-type ServiceInstance<T extends AnyServiceToken> = InstanceType<T>;
-/** Extract the literal identity tag represented by a branded Service instance. */
-type ServiceTagOf<S extends AnyService> = S[typeof ServiceIdentityTypeId];
-/** Extract the Service token represented by a branded Service instance. */
-type ServiceTokenOf<S extends AnyService> = S extends AnyService ? ServiceToken<ServiceTagOf<S>, S> : never;
-/** Extract the literal identity tag represented by a Service instance or token. */
-type ServiceTag<T extends AnyService | AnyServiceToken> = T extends AnyService ? ServiceTagOf<T> : T extends AnyServiceToken ? T['serviceTag'] : never;
-type MethodRequirements<T> = { [K in keyof T]: T[K] extends ((...args: any[]) => infer Return) ? EffectRequirements<Return> : never; }[keyof T];
-/**
- * Services required by the Effect-returning methods of a Service class.
- *
- * This type is used automatically by `Layer.make`, `Layer.gen`, and the other
- * provider constructors.
- */
-type ServiceRequirements<S extends AnyService> = MethodRequirements<S>;
-//#endregion
-//#region src/effect/types.d.ts
-/**
- * Type-only identity for a Service requirement yielded by a generator.
- *
- * The declaration has no runtime value. Service iterators return their
- * resolved instances without yielding a marker at runtime.
- */
-declare const ServiceRequirementTypeId: unique symbol;
-/** Type-only identity for requirement metadata attached to Effect results. */
-declare const EffectRequirementsTypeId: unique symbol;
-/**
- * Metadata carried by the yield type of a Service token.
- *
- * This interface is intentionally phantom: it is used only while TypeScript
- * infers a generator's yielded values.
- */
-interface ServiceRequirement<out T> {
-  readonly [ServiceRequirementTypeId]: T;
-}
-/** A `better-result` Result with phantom metadata for required Services. */
-type Effect<A, E, R extends AnyService = never> = Result<A, E> & {
-  readonly [EffectRequirementsTypeId]?: R;
-};
-/** An Effect with erased success, error, and Service requirements. */
-type AnyEffect = Effect<unknown, unknown, AnyService>;
-/** Values that an Effect generator may yield. */
-type EffectYield = Err<never, unknown> | ServiceRequirement<unknown>;
-/** Extract the error channel from Result values yielded by a generator. */
-type InferYieldError<Y> = Y extends Err<never, infer E> ? E : never;
-/** Extract branded Service instances carried by yielded Service requirements. */
-type InferYieldRequirements<Y> = Y extends ServiceRequirement<infer Requirement> ? Requirement extends AnyService ? Requirement : never : never;
-type InferEffectRequirements<T> = T extends unknown ? typeof EffectRequirementsTypeId extends keyof T ? T extends {
-  readonly [EffectRequirementsTypeId]?: infer Requirements extends AnyService;
-} ? Requirements : never : never : never;
-/** Extract phantom Service requirements from an Effect or Promise. */
-type EffectRequirements<T> = InferEffectRequirements<Awaited<T>>;
-/** Extract the success value from an Effect or Promise. */
-type EffectSuccess<T> = Awaited<T> extends Result<infer A, unknown> ? A : never;
-/** Extract the error value from an Effect or Promise. */
-type EffectError<T> = Awaited<T> extends Result<unknown, infer E> ? E : never;
-/** Build the public Effect type produced from a generator. */
-type EffectFromGenerator<Yield, Returned extends Result<any, any>> = Effect<InferOk<Returned>, InferYieldError<Yield> | InferErr<Returned>, InferYieldRequirements<Yield> | EffectRequirements<Returned>>;
-//#endregion
-//#region src/service/service.d.ts
-type ServiceTagLiteral<Tag extends string> = string extends Tag ? never : Tag extends '' ? never : Tag;
-interface ServiceFactory<Self> {
-  <const Tag extends string>(tag: ServiceTagLiteral<Tag>): (abstract new () => ServiceIdentity<Tag>) & {
-    readonly name: string;
-    readonly serviceTag: Tag;
-  } & {
-    readonly of: Service.FactoryOf<Self, Tag>;
-    readonly [Symbol.asyncIterator]: (this: ServiceToken<Tag, Self & ServiceIdentity<Tag>>) => AsyncGenerator<ServiceRequirement<Self>, Self, unknown>;
-  };
-}
-/**
- * Declare a class-backed Service with a stable string-literal identity.
- *
- * The returned class is simultaneously the implementation type, the runtime
- * dependency token, and the value yielded by `yield*` in an Effect generator.
- * The explicit self type preserves exact instance inference, while the second
- * call captures the tag as a literal for Layer composition and diagnostics.
- *
- * @example
- * ```ts
- * class Database extends Service<Database>()('Database') {
- *   query(): string {
- *     return 'ok'
- *   }
- * }
- *
- * const database = yield* Database
- * database.query()
- * ```
- *
- * @typeParam Self The instance type implemented by the declared Service.
- */
-declare function Service<Self>(): ServiceFactory<Self>;
-/** Type-level aliases for Service tokens and their instance contracts. */
-declare namespace Service {
-  /** The widened Service instance constraint. */
-  type Any = AnyService;
-  /** A class-backed Service token with a stable tag and instance contract. */
-  type Token<Tag extends string = string, Instance extends AnyService = any> = ServiceToken<Tag, Instance>;
-  /** A constructible Service class with a stable tag and instance contract. */
-  type Class<Tag extends string = string, Instance extends AnyService = AnyService> = ServiceClass<Tag, Instance>;
-  /** Extract the instance represented by a Service token. */
-  type Instance<T extends AnyServiceToken> = ServiceInstance<T>;
-  /** Extract the stable tag represented by a Service instance. */
-  type Tag<S extends AnyService> = ServiceTag<S>;
-  /** A branded Service instance identity with a stable tag. */
-  type Identity<Tag extends string = string> = ServiceIdentity<Tag>;
-  /** Remove the internal identity marker from a Service implementation contract. */
-  type Contract<S extends AnyService> = ServiceContract<S>;
-  /** Extract the Service token represented by a branded Service instance. */
-  type TokenOf<S extends AnyService> = ServiceTokenOf<S>;
-  /** Declaration bridge for the recursive structural `Service.of` signature. */
-  type FactoryOf<Self, Tag extends string> = (this: void, implementation: ServiceContract<Self & ServiceIdentity<Tag>>) => Self;
-  /** Extract Effect Service requirements from a Service instance. */
-  type Requirements<S extends AnyService> = ServiceRequirements<S>;
-}
-//#endregion
-//#region src/service/runtime.d.ts
-/** Resolves class-backed Service tokens for a runtime execution. */
-interface ServiceResolver {
-  /** Resolve a token to its corresponding Service instance. */
-  resolve<T extends AnyServiceToken>(token: T): InstanceType<T> | PromiseLike<InstanceType<T>>;
-}
-/** Provides the resolver context used by Service tokens during execution. */
-declare class ServiceRuntime {
-  /**
-   * Run a callback with a resolver available to `yield* Service` expressions.
-   *
-   * The context is scoped to the callback and is restored afterward.
-   *
-   * @example
-   * ```ts
-   * const value = ServiceRuntime.run(resolver, () => {
-   *   return ServiceRuntime.resolve(Database)
-   * })
-   * ```
-   */
-  static run<A>(resolver: ServiceResolver, program: () => A): A;
-  /** Return the resolver active in the current execution context. */
-  static current(): ServiceResolver;
-  /** Resolve a Service token using the active resolver. */
-  static resolve<T extends AnyServiceToken>(token: T): Promise<InstanceType<T>>;
-}
-//#endregion
-//#region src/service/errors.d.ts
-/** Thrown when a Service is accessed without an active runtime resolver. */
-declare class ServiceRuntimeNotConfiguredError extends Error {
-  constructor();
-}
-/** Thrown when a runtime has no provider for the requested Service tag. */
-declare class ServiceNotFoundError extends Error {
-  readonly service: AnyServiceToken;
-  constructor(service: AnyServiceToken);
-}
-//#endregion
+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 {
@@ -200,7 +20,7 @@ declare class ResourceNotDisposableError extends Error {
 //#endregion
 //#region src/scope/types.d.ts
 /** A value that may be returned synchronously or asynchronously. */
-type MaybePromise$1<T> = T | PromiseLike<T>;
+type MaybePromise<T> = T | PromiseLike<T>;
 /** Final outcome supplied to Scope finalizers and resource releases. */
 type ScopeOutcome = {
   /** Indicates that the owning program completed successfully. */
@@ -212,7 +32,7 @@ type ScopeOutcome = {
   readonly cause: unknown;
 };
 /** Cleanup callback registered with a Scope. */
-type ScopeFinalizer = (outcome: ScopeOutcome) => MaybePromise$1<void>;
+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. */
@@ -222,11 +42,11 @@ type CleanupFailureDiagnostic = {
 };
 type SyncDisposableResource = {
   [Symbol.dispose]: () => void;
-  [Symbol.asyncDispose]?: () => MaybePromise$1<void>;
+  [Symbol.asyncDispose]?: () => MaybePromise<void>;
 };
 type AsyncDisposableResource = {
   [Symbol.dispose]?: () => void;
-  [Symbol.asyncDispose]: () => MaybePromise$1<void>;
+  [Symbol.asyncDispose]: () => MaybePromise<void>;
 };
 /** A value implementing at least one JavaScript disposal protocol. */
 type DisposableResource = SyncDisposableResource | AsyncDisposableResource;
@@ -237,9 +57,6 @@ type Covariant<A> = () => A;
 /** Type-level marker that both consumes and produces `A`. */
 type Invariant<A> = (value: A) => A;
 //#endregion
-//#region src/utils/types.d.ts
-type MaybePromise<T> = T | PromiseLike<T>;
-//#endregion
 //#region src/internal/missing-dependencies.d.ts
 declare const MissingDependenciesTypeId: unique symbol;
 type MissingDependencies<Missing extends AnyService> = {
@@ -363,19 +180,6 @@ 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/types.d.ts
-/** Runtime-facing provider registration supplied by a Layer backend. */
-interface LayerRegistration {
-  /** The class-backed Service token provided by this registration. */
-  readonly service: ServiceClass<any, any>;
-  /** Lazily acquire the Service instance; concrete types are erased at this backend boundary. */
-  readonly acquire: () => MaybePromise<unknown>;
-}
-/** Generator shape used by `Layer.gen` and `Layer.scopedGen`. */
-type LayerGenerator<S extends ServiceClass<any, any>, Yield extends ServiceRequirement<unknown> = ServiceRequirement<unknown>> = () => AsyncGenerator<Yield, ServiceContract<InstanceType<S>>, unknown>;
-/** Service requirements inferred from a provider's methods and generator. */
-type LayerGeneratorRequirements<S extends ServiceClass<any, any>, Yield extends ServiceRequirement<unknown>> = ServiceRequirements<InstanceType<S>> | InferYieldRequirements<Yield>;
-//#endregion
 //#region src/layer/layer.d.ts
 declare const LayerTypeId: unique symbol;
 interface LayerVariance<in out Provided, out Required> {
@@ -384,7 +188,7 @@ interface LayerVariance<in out Provided, out Required> {
 }
 interface LayerProvider extends LayerRegistration {
   /** Provider storage deliberately erases the concrete instance type. */
-  readonly release?: (instance: unknown, outcome: ScopeOutcome) => MaybePromise<void>;
+  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);
@@ -412,13 +216,13 @@ declare class Layer<in out Provided extends AnyService = AnyService, out Require
   private constructor();
   /** Create a Layer that lazily acquires a Service instance. */
   static make<S extends DefaultConstructibleServiceClass<any, any>>(service: S): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>>;
-  static make<S extends ServiceClass<any, any>>(service: S, acquire: () => MaybePromise<ServiceContract<InstanceType<S>>>): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>>;
+  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<ServiceContract<InstanceType<S>>>, release: (instance: InstanceType<S>) => MaybePromise<void>): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>>;
+  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<void>): LayerResult<ProviderEntry<InstanceType<S>, LayerGeneratorRequirements<S, Yield>>>;
+  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. */
@@ -480,21 +284,14 @@ type RuntimeShutdownDiagnostic = {
   readonly error: LayerDisposeError;
 };
 /** Observer notified about cleanup failures without changing primary results. */
-type CleanupFailureObserver = (diagnostic: CleanupFailureDiagnostic | RuntimeShutdownDiagnostic) => MaybePromise$1<void>;
+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
-//#region src/layer/backend.d.ts
-/** Runtime adapter responsible for registering, resolving, and disposing Layer providers. */
-interface LayerBackend extends ServiceResolver {
-  /** Register one Service provider with the backend. */
-  register(registration: LayerRegistration): MaybePromise<void>;
-  /** Dispose all backend-owned instances and provider registrations. */
-  disposeAll(): MaybePromise<void>;
-}
-//#endregion
-export { AnyEffect as A, ServiceClass as B, ScopeClosedError as C, ServiceResolver as D, ServiceRuntimeNotConfiguredError as E, EffectSuccess as F, ServiceTag as G, ServiceIdentity as H, EffectYield as I, ServiceToken as K, ServiceRequirement as L, EffectError as M, EffectFromGenerator as N, ServiceRuntime as O, EffectRequirements as P, AnyService as R, ScopeCloseError as S, ServiceNotFoundError as T, ServiceInstance as U, ServiceContract as V, ServiceRequirements as W, DisposableResource as _, DuplicateServiceError as a, ScopeOutcome as b, LayerRegistrationError as c, LayerRegistration as d, CompleteExecution as f, CleanupFailureDiagnostic as g, ProvidedEnvironment as h, RuntimeShutdownDiagnostic as i, Effect as j, Service as k, ServiceTagCollisionError as l, LayerInput as m, CleanupFailureObserver as n, LayerDisposeError as o, CompleteInput as p, ServiceTokenOf as q, RuntimeOptions as r, LayerGeneratorYieldError as s, LayerBackend as t, Layer as u, MaybePromise$1 as v, ScopeRuntimeNotConfiguredError as w, ResourceNotDisposableError as x, ScopeFinalizer as y, AnyServiceToken as z };
-//# sourceMappingURL=index-DMfjhNR_.d.mts.map
+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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"}

package/dist/index.d.mts

@@ -1,4 +1,5 @@
-import { A as AnyEffect, B as ServiceClass, C as ScopeClosedError, D as ServiceResolver, E as ServiceRuntimeNotConfiguredError, F as EffectSuccess, G as ServiceTag, H as ServiceIdentity, I as EffectYield, K as ServiceToken, L as ServiceRequirement, M as EffectError, N as EffectFromGenerator, O as ServiceRuntime, P as EffectRequirements, R as AnyService, S as ScopeCloseError, T as ServiceNotFoundError, U as ServiceInstance, V as ServiceContract, W as ServiceRequirements, _ as DisposableResource, a as DuplicateServiceError, b as ScopeOutcome, c as LayerRegistrationError, d as LayerRegistration, f as CompleteExecution, g as CleanupFailureDiagnostic, h as ProvidedEnvironment, i as RuntimeShutdownDiagnostic, j as Effect$1, k as Service, l as ServiceTagCollisionError, m as LayerInput, n as CleanupFailureObserver, o as LayerDisposeError, p as CompleteInput, q as ServiceTokenOf, r as RuntimeOptions, s as LayerGeneratorYieldError, t as LayerBackend, u as Layer, v as MaybePromise$1, w as ScopeRuntimeNotConfiguredError, x as ResourceNotDisposableError, y as ScopeFinalizer, z as AnyServiceToken } from "./index-DMfjhNR_.mjs";
+import { A as ServiceRequirements, C as ServiceRequirement, D as ServiceContract, E as ServiceClass, N as ServiceToken, O as ServiceIdentity, P as ServiceTokenOf, S as ProgramFromGenerator, T as AnyServiceToken, _ as EffectFromGenerator, a as LayerRegistration, b as EffectYield, c as ServiceAcquisitionError, d as ServiceResolver, f as ServiceRuntime, g as EffectError, h as Effect$1, j as ServiceTag, k as ServiceInstance, l as ServiceNotFoundError, m as AnyEffect, n as LayerBackend, p as Service, s as CircularDependencyError, t as MapLayerBackend, u as ServiceRuntimeNotConfiguredError, v as EffectRequirements, w as AnyService, x as Program, y as EffectSuccess } from "./map-layer-backend-7hQkf_QP.mjs";
+import { S as ScopeRuntimeNotConfiguredError, _ as ScopeFinalizer, a as LayerDisposeError, b as ScopeCloseError, c as ServiceTagCollisionError, d as CompleteInput, f as LayerInput, g as MaybePromise$1, h as DisposableResource, i as DuplicateServiceError, l as Layer, m as CleanupFailureDiagnostic, n as RuntimeOptions, o as LayerGeneratorYieldError, p as ProvidedEnvironment, r as RuntimeShutdownDiagnostic, s as LayerRegistrationError, t as CleanupFailureObserver, u as CompleteExecution, v as ScopeOutcome, x as ScopeClosedError, y as ResourceNotDisposableError } from "./index-R3FdVmdr.mjs";
 import { Err, Result, UnhandledException } from "better-result";
 //#region src/scope/scope.d.ts
 /**
@@ -61,10 +62,10 @@ declare namespace Scope {
 }
 //#endregion
 //#region src/effect/combinators.d.ts
-type EffectInput<A, E, Requirements extends AnyService> = Effect$1<A, E, Requirements> | PromiseLike<Effect$1<A, E, Requirements>>;
-type AnyEffectInput = EffectInput<any, any, any>;
-type AnyEffectValue = Effect$1<any, any, any>;
-type AnyAsyncEffectInput = PromiseLike<AnyEffectValue>;
+type EffectInput<A, E> = Result<A, E> | PromiseLike<Result<A, E>>;
+type AnyEffectInput = EffectInput<any, any>;
+type AnyEffectValue = Result<any, any>;
+type AnyAsyncEffectInput = PromiseLike<Result<any, any>>;
 type PreserveAsync<Input, Output> = Input extends PromiseLike<unknown> ? Promise<Output> : Output;
 type MappedResult<Input, B> = Effect$1<B, EffectError<Input>, EffectRequirements<Input>>;
 type ErrorMappedResult<Input, E2> = Effect$1<EffectSuccess<Input>, E2, EffectRequirements<Input>>;
@@ -72,22 +73,22 @@ type ChainedResult<First, Next> = Effect$1<EffectSuccess<Next>, EffectError<Firs
 type ChainedOutput<First, Next> = ChainedResult<First, Next>;
 type AsyncChainedOutput<First, Next> = Promise<ChainedResult<First, Next>>;
 type MapOperation<A, B> = {
-  <Input>(effect: Input & EffectInput<A, any, any>): PreserveAsync<Input, MappedResult<Input, B>>;
+  <Input>(effect: Input & EffectInput<A, any>): PreserveAsync<Input, MappedResult<Input, B>>;
 };
 type MapErrorOperation<E1, E2> = {
-  <Input>(effect: Input & EffectInput<any, E1, any>): PreserveAsync<Input, ErrorMappedResult<Input, E2>>;
+  <Input>(effect: Input & EffectInput<any, E1>): PreserveAsync<Input, ErrorMappedResult<Input, E2>>;
 };
-type AndThenOperation<A, Next> = {
-  <Input>(effect: Input & Effect$1<A, any, any>): ChainedOutput<Input, Next>;
+type AndThenOperation<Next> = {
+  <Input>(effect: Input & AnyEffectValue): ChainedOutput<Input, Next>;
 };
 type AndThenAsyncOperation<A, Next> = {
-  <Input>(effect: Input & EffectInput<A, any, any>): AsyncChainedOutput<Input, Next>;
+  <Input>(effect: Input & EffectInput<A, any>): AsyncChainedOutput<Input, Next>;
 };
 /**
  * Map the successful value of a Result or Effect result.
  *
  * Supports both data-first and data-last forms and preserves asynchronous
- * results and phantom Service requirements.
+ * results and declaration-only Service requirements.
  *
  * @example
  * ```ts
@@ -99,7 +100,7 @@ declare function map<A, B>(fn: (value: A) => B): MapOperation<A, B>;
 declare function map<Input, B>(effect: Input & AnyEffectInput, fn: (value: EffectSuccess<Input>) => B): PreserveAsync<Input, MappedResult<Input, B>>;
 /**
  * Map the error value of a Result or Effect result while preserving its
- * successful value, asynchronous shape, and Service requirements.
+ * successful value, asynchronous shape, and declaration-only Service requirements.
  *
  * @example
  * ```ts
@@ -119,7 +120,7 @@ declare function mapError<Input, E2>(effect: Input & AnyEffectInput, fn: (error:
  * const user = Effect.andThen(Result.ok('u1'), (id) => repository.find(id))
  * ```
  */
-declare function andThen<A, Next extends AnyEffectValue>(next: (value: A) => Next): AndThenOperation<A, Next>;
+declare function andThen<A, Next extends AnyEffectValue>(next: (value: A) => Next): AndThenOperation<Next>;
 declare function andThen<Input, Next extends AnyEffectValue>(effect: Input & AnyEffectValue, next: (value: EffectSuccess<Input>) => Next): ChainedOutput<Input, Next>;
 /**
  * Chain an asynchronous Result-producing operation after a successful result.
@@ -137,14 +138,16 @@ declare function andThenAsync<Input, Next extends AnyAsyncEffectInput>(effect: I
 //#endregion
 //#region src/effect/effect.d.ts
 type Effect<A, E, R extends AnyService = never> = Effect$1<A, E, R>;
+type LazyProgram<A, E, R extends AnyService = never> = Program<A, E, R>;
 type AnyResult = Result<any, any>;
 /**
  * Compose `better-result` operations while preserving Service requirements in
- * a phantom type channel.
+ * a declaration-only type channel.
  *
  * A generator may yield Service tokens and Result operations. It must return a
  * `Result` as its final value; Service yields are resolved by the active
  * Runtime and do not add runtime values to the Result stream.
+ * Use `fn` when generator execution should wait for a Runtime boundary.
  *
  * @example
  * ```ts
@@ -158,6 +161,9 @@ type AnyResult = Result<any, any>;
  */
 declare function gen<Yield extends EffectYield, Returned extends AnyResult>(body: () => Generator<Yield, Returned, unknown>): EffectFromGenerator<Yield, Returned>;
 declare function gen<Yield extends EffectYield, Returned extends AnyResult>(body: () => AsyncGenerator<Yield, Returned, unknown>): Promise<EffectFromGenerator<Yield, Returned>>;
+/** Build a lazy Program without running its generator. */
+declare function fn<Yield extends EffectYield, Returned extends AnyResult>(body: () => Generator<Yield, Returned, unknown>): ProgramFromGenerator<Yield, Returned>;
+declare function fn<Yield extends EffectYield, Returned extends AnyResult>(body: () => AsyncGenerator<Yield, Returned, unknown>): ProgramFromGenerator<Yield, Returned>;
 /**
  * Acquire a resource in the current Scope and register its release callback.
  *
@@ -196,6 +202,8 @@ declare function add<R extends DisposableResource>(resource: R): AsyncGenerator<
 declare const Effect: {
   /** Compose a generator-based Effect program. */
   readonly gen: typeof gen;
+  /** Build a lazy Program from a generator. */
+  readonly fn: typeof fn;
   /** Acquire and register a resource in the current Scope. */
   readonly acquireRelease: typeof acquireRelease;
   /** Register an already-acquired disposable in the current Scope. */
@@ -211,6 +219,8 @@ declare const Effect: {
 };
 /** Type-level aliases for inspecting Effect result channels and requirements. */
 declare namespace Effect {
+  /** A nominal lazy computation that produces an Effect when invoked. */
+  type Program<A, E, R extends AnyService = never> = LazyProgram<A, E, R>;
   /** Extract the success channel from an Effect result or Promise. */
   type Success<T> = EffectSuccess<T>;
   /** Extract the error channel from an Effect result or Promise. */
@@ -297,7 +307,7 @@ type RuntimeFor<L extends LayerInput> = Runtime<Layer.Provided<L>>;
  *
  * @example
  * ```ts
- * const runtime = await Runtime.make(AppLive, new MemoryLayerBackend())
+ * const runtime = await Runtime.make(AppLive)
  * const result = await runtime.run(loadUser('u1'))
  * await runtime.dispose()
  * ```
@@ -312,12 +322,13 @@ declare class Runtime<Provided extends AnyService = any> {
    *
    * @example
    * ```ts
-   * const runtime = await Runtime.make(AppLive, backend)
+   * const runtime = await Runtime.make(AppLive)
    * const result = await runtime.run(program)
    * await runtime.dispose()
    * ```
    */
   static make<L extends LayerInput>(layer: L & CompleteInput<L>, backend: LayerBackend, options?: RuntimeOptions): Promise<Runtime<ProvidedEnvironment<L>>>;
+  static make<L extends LayerInput>(layer: L & CompleteInput<L>, options?: RuntimeOptions): Promise<Runtime<ProvidedEnvironment<L>>>;
   /**
    * Run one program and dispose its Layer resources before resolving.
    *
@@ -325,6 +336,8 @@ declare class Runtime<Provided extends AnyService = any> {
    * Runtime should not outlive the operation.
    */
   static run<A, L extends LayerInput>(layer: L & CompleteInput<L>, backend: LayerBackend, program: CompleteExecution<ProvidedEnvironment<L>, A>, options?: RuntimeOptions): Promise<Awaited<A>>;
+  static run<A, L extends LayerInput>(layer: L & CompleteInput<L>, program: CompleteExecution<ProvidedEnvironment<L>, A>, options?: RuntimeOptions): Promise<Awaited<A>>;
+  static run<A, L extends LayerInput>(layer: L & CompleteInput<L>, options: RuntimeOptions, program: CompleteExecution<ProvidedEnvironment<L>, A>): Promise<Awaited<A>>;
   /** Run one execution in this Runtime's child Scope. */
   run<A>(program: CompleteExecution<Provided, A>): Promise<Awaited<A>>;
   private runUnchecked;
@@ -342,5 +355,5 @@ declare namespace Runtime {
   type ShutdownDiagnostic = RuntimeShutdownDiagnostic;
 }
 //#endregion
-export { type AcquireUseReleaseOptions, type AnyEffect, type AnyService, type AnyServiceToken, type AsyncResult, type CleanupFailureDiagnostic, type CleanupFailureObserver, type CloseableScope, type DisposableResource, DuplicateServiceError, Effect, type EffectError, type EffectRequirements, type EffectSuccess, type EffectYield, Layer, type LayerBackend, LayerDisposeError, LayerGeneratorYieldError, type LayerRegistration, LayerRegistrationError, type ReleaseFailureObserver, type ReleaseOutcome, Resource, ResourceNotDisposableError, ResourceReleaseFailure, Runtime, type RuntimeFor, type RuntimeOptions, type RuntimeShutdownDiagnostic, Scope, ScopeCloseError, ScopeClosedError, type ScopeFinalizer, type ScopeOutcome, ScopeRuntimeNotConfiguredError, Service, type ServiceClass, type ServiceContract, type ServiceIdentity, type ServiceInstance, ServiceNotFoundError, type ServiceRequirement, type ServiceRequirements, type ServiceResolver, ServiceRuntime, ServiceRuntimeNotConfiguredError, type ServiceTag, ServiceTagCollisionError, type ServiceToken, type ServiceTokenOf, pipe };
+export { type AcquireUseReleaseOptions, type AnyEffect, type AnyService, type AnyServiceToken, type AsyncResult, CircularDependencyError, type CleanupFailureDiagnostic, type CleanupFailureObserver, type CloseableScope, type DisposableResource, DuplicateServiceError, Effect, type EffectError, type EffectRequirements, type EffectSuccess, type EffectYield, Layer, type LayerBackend, LayerDisposeError, LayerGeneratorYieldError, type LayerRegistration, LayerRegistrationError, MapLayerBackend, type Program, type ReleaseFailureObserver, type ReleaseOutcome, Resource, ResourceNotDisposableError, ResourceReleaseFailure, Runtime, type RuntimeFor, type RuntimeOptions, type RuntimeShutdownDiagnostic, Scope, ScopeCloseError, ScopeClosedError, type ScopeFinalizer, type ScopeOutcome, ScopeRuntimeNotConfiguredError, Service, ServiceAcquisitionError, type ServiceClass, type ServiceContract, type ServiceIdentity, type ServiceInstance, ServiceNotFoundError, type ServiceRequirement, type ServiceRequirements, type ServiceResolver, ServiceRuntime, ServiceRuntimeNotConfiguredError, type ServiceTag, ServiceTagCollisionError, type ServiceToken, type ServiceTokenOf, pipe };
 //# sourceMappingURL=index.d.mts.map