better-effect 0.12.0 → 0.14.0

package/dist/index-heuaRmXR.d.mts

@@ -1,374 +0,0 @@
-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 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.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<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/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<R>, release: (resource: R, outcome: ScopeOutcome) => MaybePromise<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/runtime/context.d.ts
-/** Contextual state shared by Service, Scope and Layer resolution. */
-interface RuntimeContext {
-  readonly resolver?: ServiceResolver;
-  readonly scope?: Scope;
-  readonly signal?: AbortSignal;
-  readonly resolutionPath: readonly AnyServiceToken[];
-}
-/** 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
-export { ProgramFromGenerator as A, ServiceTag as B, EffectError as C, EffectYield as D, EffectSuccess as E, ServiceContract as F, ServiceToken as H, ServiceIdentity as I, ServiceIdentityTypeId as L, AnyService as M, AnyServiceToken as N, InferYieldRequirements as O, ServiceClass as P, ServiceInstance as R, Effect as S, EffectRequirements as T, ServiceTokenOf as U, ServiceTagOf as V, ScopeCloseError as _, ServiceResolver as a, Service as b, RuntimeContextStorage as c, CleanupFailureDiagnostic as d, DisposableResource as f, ResourceNotDisposableError as g, ScopeOutcome as h, ServiceRuntimeNotConfiguredError as i, ServiceRequirement as j, Program as k, CloseableScope as l, ScopeFinalizer as m, ServiceAcquisitionError as n, ServiceRuntime as o, MaybePromise as p, ServiceNotFoundError as r, RuntimeContext as s, CircularDependencyError as t, Scope as u, ScopeClosedError as v, EffectFromGenerator as w, AnyEffect as x, ScopeRuntimeNotConfiguredError as y, ServiceRequirements as z };
-//# sourceMappingURL=index-heuaRmXR.d.mts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index-heuaRmXR.d.mts","names":[],"sources":["../src/service/types.ts","../src/effect/types.ts","../src/service/service.ts","../src/scope/errors.ts","../src/scope/types.ts","../src/scope/scope.ts","../src/runtime/context.ts","../src/service/runtime.ts","../src/service/errors.ts"],"mappings":"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"}

package/dist/layer-D56fRdLt.mjs

@@ -1,269 +0,0 @@
-import { a as LayerGeneratorYieldError, d as ServiceRuntimeNotConfiguredError, f as captureServiceTag, m as validateServiceTag, p as registerServiceTag, r as DuplicateServiceError, s as ServiceTagCollisionError, t as captureLayerRegistrationTag } from "./registration-drnZk0SY.mjs";
-import { h as RuntimeContextNotConfiguredError, i as getRuntimeContext, l as makeRuntimeContext, n as currentRuntimeContext, u as runRuntimeContext } from "./context-BUEf1qjL.mjs";
-import { a as ResourceNotDisposableError, i as getDisposeFinalizer, l as defaultRuntimeContextStorage } from "./signal-D2UTcaaG.mjs";
-//#region src/service/runtime.ts
-/** Provides the resolver context used by Service tokens during execution. */
-var ServiceRuntime = 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(resolver, program, storage = defaultRuntimeContextStorage) {
-		const current = getRuntimeContext(storage);
-		const context = makeRuntimeContext(resolver, current?.scope, current?.resolver === resolver ? current.resolutionPath : [], current?.signal, current?.resolver === resolver ? current : void 0);
-		return runRuntimeContext(storage, context, program);
-	}
-	/** Return the resolver active in the current execution context. */
-	static current() {
-		let context;
-		try {
-			context = currentRuntimeContext();
-		} catch (cause) {
-			if (cause instanceof RuntimeContextNotConfiguredError) throw new ServiceRuntimeNotConfiguredError();
-			throw cause;
-		}
-		if (!context.resolver) throw new ServiceRuntimeNotConfiguredError();
-		return context.resolver;
-	}
-	/** Resolve a Service token using the active resolver. */
-	static async resolve(token) {
-		captureServiceTag(token);
-		return await ServiceRuntime.current().resolve(token);
-	}
-};
-//#endregion
-//#region src/service/service.ts
-/**
-* 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.
-*/
-function Service() {
-	return function(tag) {
-		validateServiceTag(tag);
-		class BaseService {
-			/** The stable logical identity used by Layers and resolver backends. */
-			static serviceTag = tag;
-			/**
-			* Type-check a structural implementation of this Service.
-			*
-			* This is an identity helper. It returns the supplied value unchanged
-			* and does not invoke a constructor or modify its prototype.
-			*
-			* @example
-			* ```ts
-			* class Database extends Service<Database>()('Database') {
-			*   query(sql: string): string {
-			*     return sql
-			*   }
-			* }
-			*
-			* const database = Database.of({
-			*   query: (sql) => `Result: ${sql}`
-			* })
-			*
-			* database.query('SELECT 1')
-			* // 'Result: SELECT 1'
-			* // database is the original object, not an instance of Database
-			* ```
-			*/
-			static of(implementation) {
-				return implementation;
-			}
-			/** Resolve this Service from the resolver active in the current runtime. */
-			static async *[Symbol.asyncIterator]() {
-				return await ServiceRuntime.resolve(this);
-			}
-		}
-		registerServiceTag(BaseService, tag);
-		return BaseService;
-	};
-}
-//#endregion
-//#region src/layer/internal.ts
-const runLayerGenerator = async (service, factory) => {
-	const iterator = factory();
-	const state = await iterator.next();
-	if (!state.done) try {
-		await iterator.return(void 0);
-	} finally {
-		throw new LayerGeneratorYieldError(service);
-	}
-	return state.value;
-};
-//#endregion
-//#region src/layer/layer.ts
-/**
-* 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)
-* ```
-*/
-var Layer = class Layer {
-	/** The provider registrations retained by this Layer. */
-	providers;
-	constructor(providers) {
-		this.providers = Object.freeze(providers.map((provider) => Object.freeze({
-			...provider,
-			serviceTag: captureLayerRegistrationTag(provider)
-		})));
-	}
-	/** A stable provider-free Layer for composition roots with no Services. */
-	static empty = Object.freeze(new Layer([]));
-	static make(service, acquire) {
-		const serviceTag = captureServiceTag(service);
-		const defaultAcquire = () => {
-			return new service();
-		};
-		const normalizedAcquire = normalizeAcquire(acquire ?? defaultAcquire);
-		return new Layer([{
-			service,
-			serviceTag,
-			acquire: normalizedAcquire
-		}]);
-	}
-	/** Create a Layer from an already-constructed Service instance. */
-	static succeed(service, instance) {
-		const serviceTag = captureServiceTag(service);
-		const normalizedAcquire = normalizeAcquire(() => instance);
-		return new Layer([{
-			service,
-			serviceTag,
-			acquire: normalizedAcquire
-		}]);
-	}
-	/** Alias a source Service under a compatible target contract. */
-	static alias(options) {
-		const { from, to } = options;
-		captureServiceTag(from);
-		return Layer.gen(to, async function* () {
-			return await ServiceRuntime.resolve(from);
-		});
-	}
-	/** Define a provider with Runtime-root cleanup. */
-	static scoped(service, acquire, release) {
-		const serviceTag = captureServiceTag(service);
-		return new Layer([{
-			service,
-			serviceTag,
-			acquire: normalizeAcquire(acquire),
-			release: (instance, outcome) => {
-				return release(instance, outcome);
-			}
-		}]);
-	}
-	/** Define a provider with Runtime-root cleanup through its disposal protocol. */
-	static scopedDisposable(service, acquire) {
-		const acquireWithRelease = async () => {
-			const instance = await acquire();
-			const finalizer = getDisposeFinalizer(instance);
-			if (!finalizer) throw new ResourceNotDisposableError();
-			return {
-				instance,
-				release: finalizer
-			};
-		};
-		const serviceTag = captureServiceTag(service);
-		return new Layer([{
-			service,
-			serviceTag,
-			acquire: async () => (await acquireWithRelease()).instance,
-			acquireWithRelease
-		}]);
-	}
-	/** Define a provider whose acquisition can yield contextual Services. */
-	static scopedGen(service, factory, release) {
-		const serviceTag = captureServiceTag(service);
-		return new Layer([{
-			service,
-			serviceTag,
-			acquire: () => runLayerGenerator(service, factory),
-			release: (instance, outcome) => {
-				return release(instance, outcome);
-			}
-		}]);
-	}
-	/** Define a provider whose acquisition can yield contextual Services. */
-	static gen(service, factory) {
-		const serviceTag = captureServiceTag(service);
-		return new Layer([{
-			service,
-			serviceTag,
-			acquire: () => runLayerGenerator(service, factory)
-		}]);
-	}
-	/** Compose Layers without replacing providers. */
-	static merge(...layers) {
-		const providers = /* @__PURE__ */ new Map();
-		for (const layer of layers) for (const provider of layer.providers) {
-			const service = provider.service;
-			const serviceTag = captureLayerRegistrationTag(provider);
-			const existing = providers.get(serviceTag);
-			if (existing) {
-				if (existing.service !== service) throw new ServiceTagCollisionError(existing.service, service);
-				throw new DuplicateServiceError(service);
-			}
-			providers.set(serviceTag, provider);
-		}
-		return new Layer([...providers.values()]);
-	}
-	/** Mark a Layer composition root as complete without changing its runtime value. */
-	static complete(layer) {
-		return layer;
-	}
-	static override(base, ...overrides) {
-		const providers = /* @__PURE__ */ new Map();
-		for (const provider of base.providers) providers.set(captureLayerRegistrationTag(provider), provider);
-		for (const layer of overrides) for (const provider of layer.providers) providers.set(captureLayerRegistrationTag(provider), provider);
-		return new Layer([...providers.values()]);
-	}
-};
-Object.defineProperty(Layer, "empty", {
-	value: Layer.empty,
-	writable: false,
-	enumerable: true,
-	configurable: false
-});
-const normalizeAcquire = (acquire) => () => {
-	return acquire();
-};
-//#endregion
-export { Service as n, ServiceRuntime as r, Layer as t };
-
-//# sourceMappingURL=layer-D56fRdLt.mjs.map