better-effect 0.12.0 → 0.14.0

package/dist/layer-2kjHVv4N.mjs

@@ -0,0 +1,343 @@
+import { a as LayerGeneratorYieldError, d as ServiceRuntimeNotConfiguredError, f as captureServiceTag, r as DuplicateServiceError, s as ServiceTagCollisionError, t as captureLayerRegistrationTag } from "./registration-Bwe2GbVu.mjs";
+import { d as setDefaultRuntimeContextStorage, h as RuntimeContextNotConfiguredError, i as getRuntimeContext, l as makeRuntimeContext, n as currentRuntimeContext, u as runRuntimeContext } from "./context-DSGSqcJj.mjs";
+import { n as nodeRuntimeContextStorage } from "./node-context-g3bCcY9t.mjs";
+import { Result } from "better-result";
+//#region src/runtime/default.ts
+/** The Node/Bun storage used by the main Runtime entrypoint. */
+const defaultRuntimeContextStorage = nodeRuntimeContextStorage;
+setDefaultRuntimeContextStorage(defaultRuntimeContextStorage);
+//#endregion
+//#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 sameResolver = current?.resolver === resolver;
+		const context = makeRuntimeContext(resolver, current?.scope, sameResolver ? current.resolutionPath : [], current?.signal, current, current?.executionId);
+		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/scope/errors.ts
+/** Thrown when Scope context is accessed outside an active Scope execution. */
+var ScopeRuntimeNotConfiguredError = class extends Error {
+	constructor() {
+		super("No Scope is available in the current execution context");
+		this.name = "ScopeRuntimeNotConfiguredError";
+	}
+};
+/** Thrown when a resource or finalizer is added after Scope closure begins. */
+var ScopeClosedError = class extends Error {
+	constructor() {
+		super("Cannot add resources or finalizers to a closed Scope");
+		this.name = "ScopeClosedError";
+	}
+};
+/** Aggregates finalizer failures encountered while closing a Scope. */
+var ScopeCloseError = class extends Error {
+	causes;
+	constructor(causes) {
+		super(`Failed to close Scope (${causes.length} finalizer${causes.length === 1 ? "" : "s"} failed)`);
+		this.causes = causes;
+		this.name = "ScopeCloseError";
+	}
+};
+/** Thrown when a value has neither Symbol.dispose nor Symbol.asyncDispose. */
+var ResourceNotDisposableError = class extends Error {
+	constructor() {
+		super("Resource does not implement Symbol.dispose or Symbol.asyncDispose");
+		this.name = "ResourceNotDisposableError";
+	}
+};
+//#endregion
+//#region src/scope/disposable.ts
+const SCOPE_SUCCESS = { status: "success" };
+/** Return a Scope finalizer for a value's async or sync disposal protocol. */
+const getDisposeFinalizer = (resource) => {
+	const candidate = Object(resource);
+	const asyncDispose = candidate[Symbol.asyncDispose];
+	if (asyncDispose instanceof Function) return () => asyncDispose.call(resource);
+	const dispose = candidate[Symbol.dispose];
+	if (dispose instanceof Function) return () => dispose.call(resource);
+};
+/** Dispose a value immediately when it implements a disposal protocol. */
+const disposeResource = (resource) => {
+	return getDisposeFinalizer(resource)?.(SCOPE_SUCCESS);
+};
+//#endregion
+//#region src/layer/internal.ts
+const runLayerGenerator = async (service, factory) => {
+	const iterator = factory();
+	let state = await iterator.next();
+	while (!state.done) {
+		const token = serviceTokenFromYield(state.value);
+		if (token === void 0) try {
+			await iterator.return(void 0);
+		} finally {
+			throw new LayerGeneratorYieldError(service);
+		}
+		state = await iterator.next(await ServiceRuntime.resolve(token));
+	}
+	return state.value;
+};
+/** Run a lifecycle-only generator in the active ServiceRuntime context. */
+const runLayerDiscardGenerator = async (factory) => runLayerDiscardIterator(factory());
+/** Resolve Service yields from an erased lifecycle-only generator. */
+const runLayerDiscardIterator = async (iterator) => {
+	let state = await iterator.next();
+	while (!state.done) {
+		const token = serviceTokenFromYield(state.value);
+		if (token === void 0) try {
+			await iterator.return(void 0);
+		} finally {
+			throw new TypeError("Layer.scopedDiscard generator yielded an unsupported value");
+		}
+		state = await iterator.next(await ServiceRuntime.resolve(token));
+	}
+	return state.value;
+};
+const serviceTokenFromYield = (value) => {
+	try {
+		captureServiceTag(value);
+		return value;
+	} catch {
+		return;
+	}
+};
+//#endregion
+//#region src/layer/layer.ts
+const layerEntries = /* @__PURE__ */ new WeakMap();
+const isLifecycleEntry = (entry) => "kind" in entry && entry.kind === "lifecycle";
+/** Read all entries while keeping lifecycle storage out of the public declaration. */
+const getLayerEntries = (layer) => layerEntries.get(layer) ?? layer.providers;
+/**
+* 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 Service provider registrations retained by this Layer. */
+	providers;
+	constructor(entries) {
+		const frozenEntries = Object.freeze(entries.map((entry) => {
+			if (isLifecycleEntry(entry)) return Object.freeze({ ...entry });
+			return Object.freeze({
+				...entry,
+				serviceTag: captureLayerRegistrationTag(entry)
+			});
+		}));
+		layerEntries.set(this, frozenEntries);
+		this.providers = Object.freeze(frozenEntries.filter((entry) => !isLifecycleEntry(entry)));
+	}
+	static makeLifecycleLayer(acquire, release, quiesce) {
+		const entry = {
+			kind: "lifecycle",
+			id: Symbol("better-effect.lifecycle"),
+			acquire,
+			release
+		};
+		if (quiesce !== void 0) entry.quiesce = quiesce;
+		return new Layer([entry]);
+	}
+	/** 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);
+		});
+	}
+	static scoped(service, acquire, lifecycleOrRelease) {
+		const serviceTag = captureServiceTag(service);
+		const normalized = normalizeLifecycle(lifecycleOrRelease);
+		const provider = {
+			service,
+			serviceTag,
+			acquire: normalizeAcquire(acquire),
+			release: (instance, outcome) => {
+				return normalized.release(instance, outcome);
+			}
+		};
+		if (normalized.quiesce !== void 0) provider.quiesce = (instance, reason) => normalized.quiesce(instance, reason);
+		return new Layer([provider]);
+	}
+	/** 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
+		}]);
+	}
+	static scopedGen(service, factory, lifecycleOrRelease) {
+		const serviceTag = captureServiceTag(service);
+		const normalized = normalizeLifecycle(lifecycleOrRelease);
+		const provider = {
+			service,
+			serviceTag,
+			acquire: () => runLayerGenerator(service, factory),
+			release: (instance, outcome) => {
+				return normalized.release(instance, outcome);
+			}
+		};
+		if (normalized.quiesce !== void 0) provider.quiesce = (instance, reason) => normalized.quiesce(instance, reason);
+		return new Layer([provider]);
+	}
+	/** 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)
+		}]);
+	}
+	static scopedDiscard(acquire, releaseOrLifecycle) {
+		const lifecycle = normalizeLifecycle(releaseOrLifecycle);
+		return Layer.makeLifecycleLayer(() => {
+			const acquired = acquire();
+			if (isIteratorLike(acquired)) return runLayerDiscardIterator(acquired);
+			return acquired;
+		}, lifecycle.release, lifecycle.quiesce);
+	}
+	static scopedDiscardGen(acquire, lifecycleOrRelease) {
+		const normalized = normalizeLifecycle(lifecycleOrRelease);
+		return Layer.makeLifecycleLayer(() => runLayerDiscardGenerator(acquire), (instance, outcome) => {
+			return normalized.release(instance, outcome);
+		}, normalized.quiesce === void 0 ? void 0 : (instance, reason) => normalized.quiesce(instance, reason));
+	}
+	/** Run a no-failure Effect Program as a lifecycle-only entry. */
+	static effectDiscard(program) {
+		return Layer.makeLifecycleLayer(async () => {
+			const result = await program();
+			if (Result.isError(result)) throw result.error;
+		}, async () => {});
+	}
+	/** Compose Layers without replacing providers. */
+	static merge(...layers) {
+		const entries = /* @__PURE__ */ new Map();
+		for (const layer of layers) for (const entry of getLayerEntries(layer)) {
+			if (isLifecycleEntry(entry)) {
+				entries.set(entry.id, entry);
+				continue;
+			}
+			const service = entry.service;
+			const serviceTag = captureLayerRegistrationTag(entry);
+			const existing = entries.get(serviceTag);
+			if (existing) {
+				if (isLifecycleEntry(existing)) throw new Error("Layer lifecycle entry identity collided with a Service tag");
+				if (existing.service !== service) throw new ServiceTagCollisionError(existing.service, service);
+				throw new DuplicateServiceError(service);
+			}
+			entries.set(serviceTag, entry);
+		}
+		return new Layer([...entries.values()]);
+	}
+	/** Mark a Layer composition root as complete without changing its runtime value. */
+	static complete(layer) {
+		return layer;
+	}
+	static override(base, ...overrides) {
+		const entries = /* @__PURE__ */ new Map();
+		for (const entry of getLayerEntries(base)) entries.set(isLifecycleEntry(entry) ? entry.id : captureLayerRegistrationTag(entry), entry);
+		for (const layer of overrides) for (const entry of getLayerEntries(layer)) entries.set(isLifecycleEntry(entry) ? entry.id : captureLayerRegistrationTag(entry), entry);
+		return new Layer([...entries.values()]);
+	}
+};
+Object.defineProperty(Layer, "empty", {
+	value: Layer.empty,
+	writable: false,
+	enumerable: true,
+	configurable: false
+});
+const normalizeAcquire = (acquire) => () => {
+	return acquire();
+};
+const normalizeLifecycle = (lifecycle) => {
+	if (typeof lifecycle === "function") return { release: lifecycle };
+	return lifecycle;
+};
+const isIteratorLike = (value) => {
+	if (!(value instanceof Object) || !("next" in value)) return false;
+	return value.next instanceof Function;
+};
+//#endregion
+export { ResourceNotDisposableError as a, ScopeRuntimeNotConfiguredError as c, getDisposeFinalizer as i, ServiceRuntime as l, getLayerEntries as n, ScopeCloseError as o, disposeResource as r, ScopeClosedError as s, Layer as t, defaultRuntimeContextStorage as u };
+
+//# sourceMappingURL=layer-2kjHVv4N.mjs.map

package/dist/layer-2kjHVv4N.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"layer-2kjHVv4N.mjs","names":["Constructor"],"sources":["../src/runtime/default.ts","../src/service/runtime.ts","../src/scope/errors.ts","../src/scope/disposable.ts","../src/layer/internal.ts","../src/layer/layer.ts"],"sourcesContent":["import { nodeRuntimeContextStorage } from './node-context'\n\nimport { setDefaultRuntimeContextStorage } from './context'\n\n/** The Node/Bun storage used by the main Runtime entrypoint. */\nexport const defaultRuntimeContextStorage = nodeRuntimeContextStorage\n\nsetDefaultRuntimeContextStorage(defaultRuntimeContextStorage)\n","import { ServiceRuntimeNotConfiguredError } from './errors'\nimport { captureServiceTag } from './tag'\n\nimport { RuntimeContextNotConfiguredError } from '../runtime/errors'\n\nimport {\n  currentRuntimeContext,\n  getRuntimeContext,\n  makeRuntimeContext,\n  runRuntimeContext\n} from '../runtime/context'\n\nimport { defaultRuntimeContextStorage } from '../runtime/default'\n\nimport type { AnyServiceToken } from './types'\n\nimport type { RuntimeContextStorage } from '../runtime/context'\n\n/** Resolves class-backed Service tokens for a runtime execution. */\nexport interface ServiceResolver {\n  /** Resolve a token to its corresponding Service instance. */\n  resolve<T extends AnyServiceToken>(token: T): InstanceType<T> | PromiseLike<InstanceType<T>>\n}\n\n/** Provides the resolver context used by Service tokens during execution. */\nexport class ServiceRuntime {\n  /**\n   * Run a callback with a resolver available to `yield* Service` expressions.\n   *\n   * The context is scoped to the callback and is restored afterward.\n   *\n   * @example\n   * ```ts\n   * const value = ServiceRuntime.run(resolver, () => {\n   *   return ServiceRuntime.resolve(Database)\n   * })\n   * ```\n   */\n  static run<A>(\n    resolver: ServiceResolver,\n    program: () => A,\n    storage: RuntimeContextStorage = defaultRuntimeContextStorage\n  ): A {\n    const current = getRuntimeContext(storage)\n    const sameResolver = current?.resolver === resolver\n    const context = makeRuntimeContext(\n      resolver,\n      current?.scope,\n      sameResolver ? current.resolutionPath : [],\n      current?.signal,\n      current,\n      current?.executionId\n    )\n\n    return runRuntimeContext(storage, context, program)\n  }\n\n  /** Return the resolver active in the current execution context. */\n  static current(): ServiceResolver {\n    let context\n\n    try {\n      context = currentRuntimeContext()\n    } catch (cause) {\n      if (cause instanceof RuntimeContextNotConfiguredError) {\n        throw new ServiceRuntimeNotConfiguredError()\n      }\n\n      throw cause\n    }\n\n    if (!context.resolver) {\n      throw new ServiceRuntimeNotConfiguredError()\n    }\n\n    return context.resolver\n  }\n\n  /** Resolve a Service token using the active resolver. */\n  static async resolve<T extends AnyServiceToken>(token: T): Promise<InstanceType<T>> {\n    captureServiceTag(token)\n    const resolver = ServiceRuntime.current()\n\n    return await resolver.resolve(token)\n  }\n}\n","/** Thrown when Scope context is accessed outside an active Scope execution. */\nexport class ScopeRuntimeNotConfiguredError extends Error {\n  constructor() {\n    super('No Scope is available in the current execution context')\n\n    this.name = 'ScopeRuntimeNotConfiguredError'\n  }\n}\n\n/** Thrown when a resource or finalizer is added after Scope closure begins. */\nexport class ScopeClosedError extends Error {\n  constructor() {\n    super('Cannot add resources or finalizers to a closed Scope')\n\n    this.name = 'ScopeClosedError'\n  }\n}\n\n/** Aggregates finalizer failures encountered while closing a Scope. */\nexport class ScopeCloseError extends Error {\n  constructor(readonly causes: readonly unknown[]) {\n    super(\n      `Failed to close Scope (${causes.length} finalizer${causes.length === 1 ? '' : 's'} failed)`\n    )\n\n    this.name = 'ScopeCloseError'\n  }\n}\n\n/** Thrown when a value has neither Symbol.dispose nor Symbol.asyncDispose. */\nexport class ResourceNotDisposableError extends Error {\n  constructor() {\n    super('Resource does not implement Symbol.dispose or Symbol.asyncDispose')\n\n    this.name = 'ResourceNotDisposableError'\n  }\n}\n","import type { ScopeFinalizer } from './types'\n\nconst SCOPE_SUCCESS = { status: 'success' } as const\n\ntype Disposer = (...args: never[]) => void | PromiseLike<void>\n\ntype DisposableCandidate = {\n  [Symbol.dispose]?: Disposer\n\n  [Symbol.asyncDispose]?: Disposer\n}\n\n/** Return a Scope finalizer for a value's async or sync disposal protocol. */\nexport const getDisposeFinalizer = <Resource>(resource: Resource): ScopeFinalizer | undefined => {\n  // SAFETY: Object() provides a property-bearing view for protocol lookup; each method is checked for callability before invocation.\n  const candidate = Object(resource) as DisposableCandidate\n  const asyncDispose = candidate[Symbol.asyncDispose]\n\n  if (asyncDispose instanceof Function) {\n    return () => asyncDispose.call(resource)\n  }\n\n  const dispose = candidate[Symbol.dispose]\n\n  if (dispose instanceof Function) {\n    return () => dispose.call(resource)\n  }\n\n  return undefined\n}\n\n/** Dispose a value immediately when it implements a disposal protocol. */\nexport const disposeResource = <Resource>(resource: Resource): void | PromiseLike<void> => {\n  const finalizer = getDisposeFinalizer(resource)\n\n  return finalizer?.(SCOPE_SUCCESS)\n}\n","import { LayerGeneratorYieldError } from './errors'\n\nimport { ServiceRuntime } from '../service'\nimport { captureServiceTag } from '../service/tag'\n\nimport type { ServiceRequirement } from '../effect/types'\nimport type { AnyServiceToken, ServiceToken } from '../service'\n\nimport type { LayerDiscardGenerator, LayerGenerator } from './types'\n\nexport const runLayerGenerator = async <\n  S extends ServiceToken<any, any>,\n  Yield extends ServiceRequirement<unknown>\n>(\n  service: S,\n  factory: LayerGenerator<S, Yield>\n): Promise<InstanceType<S>> => {\n  const iterator = factory()\n\n  let state = await iterator.next()\n\n  while (!state.done) {\n    const token = serviceTokenFromYield(state.value)\n\n    if (token === undefined) {\n      try {\n        // SAFETY: The iterator is closed only to discard an invalid yield; its return value is ignored.\n        await iterator.return(undefined as never)\n      } finally {\n        // oxlint-disable-next-line no-unsafe-finally\n        throw new LayerGeneratorYieldError(service)\n      }\n    }\n\n    state = await iterator.next(await ServiceRuntime.resolve(token))\n  }\n\n  // SAFETY: The public generator boundary accepts only the requested Service contract.\n  return state.value as InstanceType<S>\n}\n\n/** Runtime-erased iterator accepted by lifecycle-only generator constructors. */\nexport type LayerDiscardIterator<Acquired = unknown> =\n  | Generator<ServiceRequirement<unknown>, Acquired, unknown>\n  | AsyncGenerator<ServiceRequirement<unknown>, Acquired, unknown>\n\n/** Run a lifecycle-only generator in the active ServiceRuntime context. */\nexport const runLayerDiscardGenerator = async <Yield extends ServiceRequirement<unknown>, Acquired>(\n  factory: LayerDiscardGenerator<Yield, Acquired>\n): Promise<Acquired> => runLayerDiscardIterator(factory())\n\n/** Resolve Service yields from an erased lifecycle-only generator. */\n// oxlint-disable-next-line anti-slop/no-unknown-returns -- the iterator result is restored by the typed generator caller.\nexport const runLayerDiscardIterator = async <Acquired>(\n  iterator: LayerDiscardIterator<Acquired>\n): Promise<Acquired> => {\n  let state = await iterator.next()\n\n  while (!state.done) {\n    const token = serviceTokenFromYield(state.value)\n\n    if (token === undefined) {\n      try {\n        // SAFETY: The iterator is closed only to discard an invalid yield; its return value is ignored.\n        await iterator.return(undefined as never)\n      } finally {\n        // oxlint-disable-next-line no-unsafe-finally\n        throw new TypeError('Layer.scopedDiscard generator yielded an unsupported value')\n      }\n    }\n\n    state = await iterator.next(await ServiceRuntime.resolve(token))\n  }\n\n  return state.value\n}\n\n// oxlint-disable-next-line anti-slop/no-unknown-parameters -- Sync Layer generators expose Service tokens only through a runtime-erased yield.\nconst serviceTokenFromYield = (value: unknown): AnyServiceToken | undefined => {\n  try {\n    captureServiceTag(value)\n\n    // SAFETY: A valid Service token is the only runtime value emitted by the sync Service iterator.\n    return value as AnyServiceToken\n  } catch {\n    return undefined\n  }\n}\n","import { Result } from 'better-result'\n\nimport type {\n  EffectError,\n  EffectRequirements,\n  EffectSuccess,\n  Program,\n  ServiceRequirement\n} from '../effect/types'\nimport { ServiceRuntime } from '../service'\nimport { captureServiceTag } from '../service/tag'\nimport type {\n  AnyService,\n  ServiceClass,\n  ServiceContract,\n  ServiceRequirements,\n  ServiceToken\n} from '../service'\nimport { ResourceNotDisposableError } from '../scope'\nimport { getDisposeFinalizer } from '../scope/disposable'\n\nimport type { DisposableResource, ScopeFinalizer, ScopeOutcome } from '../scope'\nimport type { Covariant, Invariant } from '../internal/variance'\nimport type { MaybePromise } from '../utils/types'\n\nimport { DuplicateServiceError, ServiceTagCollisionError } from './errors'\nimport {\n  runLayerDiscardGenerator,\n  runLayerDiscardIterator,\n  runLayerGenerator,\n  type LayerDiscardIterator\n} from './internal'\nimport { captureLayerRegistrationTag } from './registration'\n\nimport type {\n  LayerInput,\n  CompleteInput,\n  LayerResult,\n  MergeResult,\n  OverrideLayerResult,\n  ValidateLayerInput,\n  ValidateLayerTuple,\n  ValidateOverrides,\n  ProvidedEnvironment,\n  RequiredEnvironment\n} from './inference'\nimport type { ProviderEntry } from './metadata'\nimport type {\n  LayerDiscardGenerator,\n  LayerDiscardRequirements,\n  LayerLifecycle,\n  LayerGenerator,\n  LayerGeneratorRequirements,\n  LayerQuiesce,\n  LayerRegistration\n} from './types'\n\ndeclare const LayerTypeId: unique symbol\n\ninterface LayerVariance<in out Provided, out Required> {\n  readonly _Provided: Invariant<Provided>\n  readonly _Required: Covariant<Required>\n}\n\ntype CapturedLayerAcquisition = {\n  readonly instance: unknown\n  readonly release: ScopeFinalizer\n}\n\ninterface LayerProvider extends LayerRegistration {\n  /** The tag captured before this provider can cross an asynchronous boundary. */\n  readonly serviceTag: string\n\n  /** Provider storage deliberately erases the concrete instance type. */\n  // oxlint-disable-next-line anti-slop/no-unknown-parameters\n  readonly release?: (instance: unknown, outcome: ScopeOutcome) => MaybePromise<void>\n\n  readonly quiesce?: LayerQuiesce\n\n  /** Capture acquisition-local cleanup without retaining the acquired instance. */\n  readonly acquireWithRelease?: () => MaybePromise<CapturedLayerAcquisition>\n}\n\ntype MutableLayerProvider = Omit<LayerProvider, 'quiesce'> & {\n  quiesce?: LayerQuiesce\n}\n\ntype LifecycleCallback<Instance> =\n  | ((instance: Instance, outcome: ScopeOutcome) => MaybePromise<void>)\n  | LayerLifecycle<Instance>\n\n/** Internal lifecycle entry that deliberately has no Service identity. */\nexport interface LayerLifecycleEntry {\n  readonly kind: 'lifecycle'\n  readonly id: symbol\n  readonly acquire: () => MaybePromise<unknown>\n  // oxlint-disable-next-line anti-slop/no-unknown-parameters -- Lifecycle resources are intentionally opaque to the Layer runtime.\n  readonly release: (instance: unknown, outcome: ScopeOutcome) => MaybePromise<void>\n  readonly quiesce?: LayerQuiesce\n}\n\ntype MutableLayerLifecycleEntry = Omit<LayerLifecycleEntry, 'quiesce'> & {\n  quiesce?: LayerQuiesce\n}\n\ntype LayerEntry = LayerProvider | LayerLifecycleEntry\n\nconst layerEntries = new WeakMap<object, readonly LayerEntry[]>()\n\nconst isLifecycleEntry = (entry: LayerEntry): entry is LayerLifecycleEntry =>\n  'kind' in entry && entry.kind === 'lifecycle'\n\n/** Read all entries while keeping lifecycle storage out of the public declaration. */\nexport const getLayerEntries = (layer: LayerInput): readonly LayerEntry[] =>\n  layerEntries.get(layer) ?? layer.providers\n\ntype AnyProgram = Program<any, any, AnyService>\n\ntype EffectDiscardValidation<P extends AnyProgram> = [EffectSuccess<P>] extends [void]\n  ? [EffectError<P>] extends [never]\n    ? unknown\n    : {\n        readonly __betterEffectDiscardTypedFailure: unique symbol\n      }\n  : {\n      readonly __betterEffectDiscardSuccessMustBeVoid: unique symbol\n    }\n\n/** A Service class whose constructor can be called without arguments. */\ntype DefaultConstructibleServiceClass<\n  Tag extends string = string,\n  Instance extends AnyService = AnyService\n> = ServiceClass<Tag, Instance> & (new () => Instance)\n\ntype IsUnion<Type, Candidate = Type> = Type extends unknown\n  ? [Candidate] extends [Type]\n    ? false\n    : true\n  : never\n\ntype InvalidUnionAliasToken = {\n  readonly __betterEffectUnionLayerAliasToken: unique symbol\n}\n\ntype RejectUnionAliasToken<Token> = IsUnion<Token> extends true ? InvalidUnionAliasToken : unknown\n\ntype LayerAliasOptions<From extends ServiceToken<any, any>, To extends ServiceToken<any, any>> = {\n  readonly from: From\n  readonly to: To\n} & RejectUnionAliasToken<From> &\n  RejectUnionAliasToken<To> &\n  ([ServiceContract<InstanceType<From>>] extends [ServiceContract<InstanceType<To>>]\n    ? unknown\n    : {\n        readonly __betterEffectIncompatibleLayerAlias: unique symbol\n      })\n\n/**\n * Declarative collection of Service providers.\n *\n * A Layer describes how to acquire implementations; it does not execute\n * providers until a `Runtime` is created. Use `merge` to compose distinct\n * providers and `override` when replacing an existing provider intentionally.\n *\n * @example\n * ```ts\n * const AppLive = Layer.merge(\n *   Layer.succeed(Database, database),\n *   Layer.make(UserRepository)\n * )\n *\n * const runtime = await Runtime.make(AppLive, backend)\n * ```\n */\nexport class Layer<\n  in out Provided extends AnyService = AnyService,\n  out Required extends AnyService = AnyService\n> {\n  declare readonly [LayerTypeId]: LayerVariance<Provided, Required>\n\n  /** The Service provider registrations retained by this Layer. */\n  readonly providers: readonly LayerProvider[]\n\n  private constructor(entries: readonly LayerEntry[]) {\n    const frozenEntries = Object.freeze(\n      entries.map((entry) => {\n        if (isLifecycleEntry(entry)) {\n          return Object.freeze({ ...entry })\n        }\n\n        return Object.freeze({\n          ...entry,\n          serviceTag: captureLayerRegistrationTag(entry)\n        })\n      })\n    )\n\n    layerEntries.set(this, frozenEntries)\n    this.providers = Object.freeze(\n      frozenEntries.filter((entry): entry is LayerProvider => !isLifecycleEntry(entry))\n    )\n  }\n\n  private static makeLifecycleLayer<RawRequired extends AnyService>(\n    acquire: () => MaybePromise<unknown>,\n    // oxlint-disable-next-line anti-slop/no-unknown-parameters -- Lifecycle resources are intentionally opaque to the Layer runtime.\n    release: (instance: unknown, outcome: ScopeOutcome) => MaybePromise<void>,\n    quiesce?: LayerQuiesce\n  ): LayerResult<ProviderEntry<never, RawRequired>> {\n    // SAFETY: Lifecycle entries have no public Service environment; the typed requirements are declaration-only provenance.\n    const entry: MutableLayerLifecycleEntry = {\n      kind: 'lifecycle',\n      id: Symbol('better-effect.lifecycle'),\n      acquire,\n      release\n    }\n\n    if (quiesce !== undefined) {\n      entry.quiesce = quiesce\n    }\n\n    // SAFETY: Lifecycle entries carry only declaration-level requirements, erased by the Layer storage boundary.\n    return new Layer([entry]) as LayerResult<ProviderEntry<never, RawRequired>>\n  }\n\n  /** A stable provider-free Layer for composition roots with no Services. */\n  static readonly empty: Layer<never, never> = Object.freeze(new Layer<never, never>([]))\n\n  /** Create a Layer that lazily acquires a Service instance. */\n  static make<S extends DefaultConstructibleServiceClass<any, any>>(\n    service: S\n  ): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>>\n\n  static make<S extends ServiceToken<any, any>>(\n    service: S,\n    acquire: () => MaybePromise<ServiceContract<InstanceType<S>>>\n  ): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>>\n\n  static make<S extends ServiceToken<any, any>>(\n    service: S,\n    acquire?: () => MaybePromise<ServiceContract<InstanceType<S>>>\n  ): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>> {\n    const serviceTag = captureServiceTag(service)\n    const defaultAcquire = (): InstanceType<S> => {\n      // SAFETY: The no-argument overload constrains `service` to a default constructible class.\n      // oxlint-disable-next-line anti-slop/no-chained-type-assertions -- the overload supplies the erased constructor guarantee.\n      const Constructor = service as unknown as new () => InstanceType<S>\n\n      return new Constructor()\n    }\n\n    const normalizedAcquire = normalizeAcquire<S>(acquire ?? defaultAcquire)\n\n    // SAFETY: Runtime storage erases only the concrete provider metadata; the public constructor result restores its typed provenance.\n    return new Layer([\n      {\n        service,\n        serviceTag,\n        acquire: normalizedAcquire\n      }\n    ]) as LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>>\n  }\n\n  /** Create a Layer from an already-constructed Service instance. */\n  static succeed<S extends ServiceToken<any, any>>(\n    service: S,\n    instance: ServiceContract<InstanceType<S>>\n  ): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>> {\n    const serviceTag = captureServiceTag(service)\n    const normalizedAcquire = normalizeAcquire<S>(() => instance)\n\n    // SAFETY: The structural instance has been checked against the requested Service contract.\n    return new Layer([\n      {\n        service,\n        serviceTag,\n        acquire: normalizedAcquire\n      }\n    ]) as LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>>\n  }\n\n  /** Alias a source Service under a compatible target contract. */\n  static alias<From extends ServiceToken<any, any>, To extends ServiceToken<any, any>>(\n    options: LayerAliasOptions<From, To>\n  ): LayerResult<\n    ProviderEntry<InstanceType<To>, InstanceType<From> | ServiceRequirements<InstanceType<To>>>\n  > {\n    const { from, to } = options\n    void captureServiceTag(from)\n\n    // Keep alias acquisition in the normal Layer generator path so Runtime supplies the active resolver and resolution diagnostics.\n    // oxlint-disable-next-line require-yield\n    const alias = Layer.gen(to, async function* () {\n      const source = await ServiceRuntime.resolve(from)\n\n      // SAFETY: LayerAliasOptions checks that the source implementation satisfies the target contract.\n      return source as ServiceContract<InstanceType<To>>\n    })\n\n    // SAFETY: The alias factory resolves the declared source token before returning the target contract.\n    return alias as LayerResult<\n      ProviderEntry<InstanceType<To>, InstanceType<From> | ServiceRequirements<InstanceType<To>>>\n    >\n  }\n\n  /** Define a provider with Runtime-root cleanup. */\n  static scoped<S extends ServiceToken<any, any>>(\n    service: S,\n    acquire: () => MaybePromise<ServiceContract<InstanceType<S>>>,\n    release: (instance: InstanceType<S>, outcome: ScopeOutcome) => MaybePromise<void>\n  ): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>>\n\n  static scoped<S extends ServiceToken<any, any>>(\n    service: S,\n    acquire: () => MaybePromise<ServiceContract<InstanceType<S>>>,\n    lifecycle: LayerLifecycle<InstanceType<S>>\n  ): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>>\n\n  static scoped<S extends ServiceToken<any, any>>(\n    service: S,\n    acquire: () => MaybePromise<ServiceContract<InstanceType<S>>>,\n    lifecycleOrRelease: LifecycleCallback<InstanceType<S>>\n  ): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>> {\n    const serviceTag = captureServiceTag(service)\n    const normalized = normalizeLifecycle(lifecycleOrRelease)\n\n    const provider: MutableLayerProvider = {\n      service,\n      serviceTag,\n      acquire: normalizeAcquire<S>(acquire),\n      release: (instance, outcome) => {\n        // SAFETY: The backend invokes release with the instance acquired for this token.\n        return normalized.release(instance as InstanceType<S>, outcome)\n      }\n    }\n\n    if (normalized.quiesce !== undefined) {\n      // SAFETY: The lifecycle overload constrains this erased instance to InstanceType<S>.\n      provider.quiesce = (instance, reason) =>\n        normalized.quiesce!(instance as InstanceType<S>, reason)\n    }\n\n    // SAFETY: The public callbacks constrain acquisition and release to the requested Service.\n    return new Layer([provider]) as LayerResult<\n      ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>\n    >\n  }\n\n  /** Define a provider with Runtime-root cleanup through its disposal protocol. */\n  static scopedDisposable<S extends ServiceToken<any, any>>(\n    service: S,\n    acquire: () => MaybePromise<ServiceContract<InstanceType<S>> & DisposableResource>\n  ): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>> {\n    const acquireWithRelease = async (): Promise<CapturedLayerAcquisition> => {\n      const instance = await acquire()\n      const finalizer = getDisposeFinalizer(instance)\n\n      if (!finalizer) {\n        throw new ResourceNotDisposableError()\n      }\n\n      return { instance, release: finalizer }\n    }\n\n    const serviceTag = captureServiceTag(service)\n\n    // SAFETY: The public callback constrains the acquired value and this runtime-only carrier is erased at the Layer boundary.\n    return new Layer([\n      {\n        service,\n        serviceTag,\n        acquire: async () => (await acquireWithRelease()).instance,\n        acquireWithRelease\n      }\n    ]) as LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>>\n  }\n\n  /** Define a provider whose acquisition can yield contextual Services. */\n  static scopedGen<S extends ServiceToken<any, any>, Yield extends ServiceRequirement<unknown>>(\n    service: S,\n    factory: LayerGenerator<S, Yield>,\n    release: (instance: InstanceType<S>, outcome: ScopeOutcome) => MaybePromise<void>\n  ): LayerResult<ProviderEntry<InstanceType<S>, LayerGeneratorRequirements<S, Yield>>>\n\n  static scopedGen<S extends ServiceToken<any, any>, Yield extends ServiceRequirement<unknown>>(\n    service: S,\n    factory: LayerGenerator<S, Yield>,\n    lifecycle: LayerLifecycle<InstanceType<S>>\n  ): LayerResult<ProviderEntry<InstanceType<S>, LayerGeneratorRequirements<S, Yield>>>\n\n  static scopedGen<S extends ServiceToken<any, any>, Yield extends ServiceRequirement<unknown>>(\n    service: S,\n    factory: LayerGenerator<S, Yield>,\n    lifecycleOrRelease: LifecycleCallback<InstanceType<S>>\n  ): LayerResult<ProviderEntry<InstanceType<S>, LayerGeneratorRequirements<S, Yield>>> {\n    const serviceTag = captureServiceTag(service)\n    const normalized = normalizeLifecycle(lifecycleOrRelease)\n\n    const provider: MutableLayerProvider = {\n      service,\n      serviceTag,\n      acquire: () => runLayerGenerator(service, factory),\n      release: (instance, outcome) => {\n        // SAFETY: The backend invokes release with the instance acquired for this token.\n        return normalized.release(instance as InstanceType<S>, outcome)\n      }\n    }\n\n    if (normalized.quiesce !== undefined) {\n      // SAFETY: The lifecycle overload constrains this erased instance to InstanceType<S>.\n      provider.quiesce = (instance, reason) =>\n        normalized.quiesce!(instance as InstanceType<S>, reason)\n    }\n\n    // SAFETY: The generator and release callback are checked against the requested Service.\n    return new Layer([provider]) as LayerResult<\n      ProviderEntry<InstanceType<S>, LayerGeneratorRequirements<S, Yield>>\n    >\n  }\n\n  /** Define a provider whose acquisition can yield contextual Services. */\n  static gen<S extends ServiceToken<any, any>, Yield extends ServiceRequirement<unknown>>(\n    service: S,\n    factory: LayerGenerator<S, Yield>\n  ): LayerResult<ProviderEntry<InstanceType<S>, LayerGeneratorRequirements<S, Yield>>> {\n    const serviceTag = captureServiceTag(service)\n\n    // SAFETY: The generator result is normalized to the requested Service at the runtime boundary.\n    return new Layer([\n      {\n        service,\n        serviceTag,\n        acquire: () => runLayerGenerator(service, factory)\n      }\n    ]) as LayerResult<ProviderEntry<InstanceType<S>, LayerGeneratorRequirements<S, Yield>>>\n  }\n\n  /** Define a lifecycle-only entry with direct acquisition and root cleanup. */\n  static scopedDiscard<Yield extends ServiceRequirement<unknown>, Acquired>(\n    acquire: LayerDiscardGenerator<Yield, Acquired>,\n    release: (instance: Acquired, outcome: ScopeOutcome) => MaybePromise<void>\n  ): LayerResult<ProviderEntry<never, LayerDiscardRequirements<Yield>>>\n\n  static scopedDiscard<Yield extends ServiceRequirement<unknown>, Acquired>(\n    acquire: LayerDiscardGenerator<Yield, Acquired>,\n    lifecycle: LayerLifecycle<Acquired>\n  ): LayerResult<ProviderEntry<never, LayerDiscardRequirements<Yield>>>\n\n  static scopedDiscard<Acquired>(\n    acquire: () => MaybePromise<Acquired>,\n    release: (instance: Acquired, outcome: ScopeOutcome) => MaybePromise<void>\n  ): LayerResult<ProviderEntry<never, never>>\n\n  static scopedDiscard<Acquired>(\n    acquire: () => MaybePromise<Acquired>,\n    lifecycle: LayerLifecycle<Acquired>\n  ): LayerResult<ProviderEntry<never, never>>\n\n  static scopedDiscard(\n    acquire:\n      | (() => MaybePromise<unknown>)\n      | LayerDiscardGenerator<ServiceRequirement<unknown>, unknown>,\n    // oxlint-disable-next-line anti-slop/no-unknown-parameters -- Lifecycle resources are intentionally opaque to the Layer runtime.\n    releaseOrLifecycle: LifecycleCallback<unknown>\n  ): LayerResult<ProviderEntry<never, AnyService>> {\n    const lifecycle = normalizeLifecycle(releaseOrLifecycle)\n\n    return Layer.makeLifecycleLayer(\n      () => {\n        const acquired = acquire()\n\n        if (isIteratorLike(acquired)) {\n          return runLayerDiscardIterator(acquired)\n        }\n\n        return acquired\n      },\n      lifecycle.release,\n      lifecycle.quiesce\n    )\n  }\n\n  /** Define a lifecycle-only entry whose acquisition can yield contextual Services. */\n  static scopedDiscardGen<Yield extends ServiceRequirement<unknown>, Acquired>(\n    acquire: LayerDiscardGenerator<Yield, Acquired>,\n    release: (instance: Acquired, outcome: ScopeOutcome) => MaybePromise<void>\n  ): LayerResult<ProviderEntry<never, LayerDiscardRequirements<Yield>>>\n\n  static scopedDiscardGen<Yield extends ServiceRequirement<unknown>, Acquired>(\n    acquire: LayerDiscardGenerator<Yield, Acquired>,\n    lifecycle: LayerLifecycle<Acquired>\n  ): LayerResult<ProviderEntry<never, LayerDiscardRequirements<Yield>>>\n\n  static scopedDiscardGen<Yield extends ServiceRequirement<unknown>, Acquired>(\n    acquire: LayerDiscardGenerator<Yield, Acquired>,\n    lifecycleOrRelease: LifecycleCallback<Acquired>\n  ): LayerResult<ProviderEntry<never, LayerDiscardRequirements<Yield>>> {\n    const normalized = normalizeLifecycle(lifecycleOrRelease)\n\n    // SAFETY: Lifecycle generator requirements are carried only in declaration metadata; runtime storage is intentionally erased.\n    return Layer.makeLifecycleLayer(\n      () => runLayerDiscardGenerator(acquire),\n      (instance, outcome) => {\n        // SAFETY: The overload constrains this resource to Acquired before the erased Layer boundary.\n        return normalized.release(instance as Acquired, outcome)\n      },\n      normalized.quiesce === undefined\n        ? undefined\n        : (instance, reason) => normalized.quiesce!(instance as Acquired, reason)\n    ) as LayerResult<ProviderEntry<never, LayerDiscardRequirements<Yield>>>\n  }\n\n  /** Run a no-failure Effect Program as a lifecycle-only entry. */\n  static effectDiscard<P extends AnyProgram>(\n    program: P & EffectDiscardValidation<P>\n  ): LayerResult<ProviderEntry<never, Extract<EffectRequirements<P>, AnyService>>> {\n    // SAFETY: The public validation preserves the no-failure Program contract while the Layer entry erases its unit resource.\n    return Layer.makeLifecycleLayer<Extract<EffectRequirements<P>, AnyService>>(\n      async () => {\n        const result = await program()\n\n        if (Result.isError(result)) {\n          throw result.error\n        }\n      },\n      async () => {}\n    ) as LayerResult<ProviderEntry<never, Extract<EffectRequirements<P>, AnyService>>>\n  }\n\n  /** Compose Layers without replacing providers. */\n  static merge<const Layers extends readonly LayerInput[]>(\n    ...layers: Layers & ValidateLayerTuple<Layers>\n  ): MergeResult<Layers> {\n    const entries = new Map<string | symbol, LayerEntry>()\n\n    for (const layer of layers) {\n      for (const entry of getLayerEntries(layer)) {\n        if (isLifecycleEntry(entry)) {\n          entries.set(entry.id, entry)\n          continue\n        }\n\n        const service = entry.service\n        const serviceTag = captureLayerRegistrationTag(entry)\n        const existing = entries.get(serviceTag)\n\n        if (existing) {\n          if (isLifecycleEntry(existing)) {\n            throw new Error('Layer lifecycle entry identity collided with a Service tag')\n          }\n\n          if (existing.service !== service) {\n            throw new ServiceTagCollisionError(existing.service, service)\n          }\n\n          throw new DuplicateServiceError(service)\n        }\n\n        entries.set(serviceTag, entry)\n      }\n    }\n\n    // SAFETY: The heterogeneous provider list is erased only at this internal storage boundary.\n    return new Layer([...entries.values()]) as MergeResult<Layers>\n  }\n\n  /** Mark a Layer composition root as complete without changing its runtime value. */\n  static complete<L extends LayerInput>(layer: L & CompleteInput<L>): L {\n    return layer\n  }\n\n  /** Replace providers in a base Layer, using tag identity and compatible contracts. */\n  static override<Base extends LayerInput>(\n    base: Base & ValidateLayerInput<Base>\n  ): OverrideLayerResult<Base, readonly []>\n\n  static override<\n    Base extends LayerInput,\n    const Overrides extends readonly [LayerInput, ...LayerInput[]]\n  >(\n    base: Base & ValidateLayerInput<Base>,\n    ...overrides: Overrides & ValidateOverrides<Base, Overrides>\n  ): OverrideLayerResult<Base, Overrides>\n\n  static override<Base extends LayerInput, const Overrides extends readonly LayerInput[]>(\n    base: Base & ValidateLayerInput<Base>,\n    ...overrides: Overrides & ValidateOverrides<Base, Overrides>\n  ): OverrideLayerResult<Base, Overrides>\n\n  static override(base: LayerInput, ...overrides: readonly LayerInput[]): Layer<any, any> {\n    const entries = new Map<string | symbol, LayerEntry>()\n\n    for (const entry of getLayerEntries(base)) {\n      entries.set(isLifecycleEntry(entry) ? entry.id : captureLayerRegistrationTag(entry), entry)\n    }\n\n    for (const layer of overrides) {\n      for (const entry of getLayerEntries(layer)) {\n        entries.set(isLifecycleEntry(entry) ? entry.id : captureLayerRegistrationTag(entry), entry)\n      }\n    }\n\n    // SAFETY: Runtime provider replacement preserves the computed override metadata.\n    return new Layer([...entries.values()]) as Layer<any, any>\n  }\n}\n\n// TypeScript's `readonly` does not affect the runtime property descriptor. Keep\n// the class field's enumerable behavior while locking the singleton binding.\nObject.defineProperty(Layer, 'empty', {\n  value: Layer.empty,\n  writable: false,\n  enumerable: true,\n  configurable: false\n})\n\nconst normalizeAcquire =\n  <S extends ServiceToken<any, any>>(\n    acquire: () => MaybePromise<ServiceContract<InstanceType<S>>>\n  ): (() => MaybePromise<InstanceType<S>>) =>\n  () => {\n    // SAFETY: ServiceContract removes only the declaration-only identity; runtime values are unchanged.\n    return acquire() as MaybePromise<InstanceType<S>>\n  }\n\nconst normalizeLifecycle = <Instance>(\n  lifecycle: LifecycleCallback<Instance>\n): LayerLifecycle<Instance> => {\n  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- lifecycle callbacks are a deliberately supported function-or-object API.\n  if (typeof lifecycle === 'function') {\n    return { release: lifecycle }\n  }\n\n  return lifecycle\n}\n\n// oxlint-disable-next-line anti-slop/no-unknown-parameters -- Lifecycle factories are runtime-erased at this boundary.\nconst isIteratorLike = (value: unknown): value is LayerDiscardIterator => {\n  if (!(value instanceof Object) || !('next' in value)) {\n    return false\n  }\n\n  return value.next instanceof Function\n}\n\n/** Type-level aliases for inspecting Layer environments and completeness. */\nexport declare namespace Layer {\n  /** The widened Layer shape accepted by generic Layer infrastructure. */\n  export type Any = LayerInput\n\n  /** Extract the branded Service instances provided by a Layer. */\n  export type Provided<L extends LayerInput> = ProvidedEnvironment<L>\n\n  /** Extract the external Service requirements of a Layer. */\n  export type Required<L extends LayerInput> = RequiredEnvironment<L>\n\n  /** Extract the Services still missing from a Layer composition. */\n  export type Missing<L extends LayerInput> = RequiredEnvironment<L>\n\n  /** Validate a Layer's requirements and input shape. */\n  export type Complete<L extends LayerInput> = CompleteInput<L>\n}\n"],"mappings":";;;;;;AAKA,MAAa,+BAA+B;AAE5C,gCAAgC,4BAA4B;;;;ACkB5D,IAAa,iBAAb,MAAa,eAAe;;;;;;;;;;;;;CAa1B,OAAO,IACL,UACA,SACA,UAAiC,8BAC9B;EACH,MAAM,UAAU,kBAAkB,OAAO;EACzC,MAAM,eAAe,SAAS,aAAa;EAC3C,MAAM,UAAU,mBACd,UACA,SAAS,OACT,eAAe,QAAQ,iBAAiB,CAAC,GACzC,SAAS,QACT,SACA,SAAS,WACX;EAEA,OAAO,kBAAkB,SAAS,SAAS,OAAO;CACpD;;CAGA,OAAO,UAA2B;EAChC,IAAI;EAEJ,IAAI;GACF,UAAU,sBAAsB;EAClC,SAAS,OAAO;GACd,IAAI,iBAAiB,kCACnB,MAAM,IAAI,iCAAiC;GAG7C,MAAM;EACR;EAEA,IAAI,CAAC,QAAQ,UACX,MAAM,IAAI,iCAAiC;EAG7C,OAAO,QAAQ;CACjB;;CAGA,aAAa,QAAmC,OAAoC;EAClF,kBAAkB,KAAK;EAGvB,OAAO,MAFU,eAAe,QAEZ,CAAC,CAAC,QAAQ,KAAK;CACrC;AACF;;;;ACpFA,IAAa,iCAAb,cAAoD,MAAM;CACxD,cAAc;EACZ,MAAM,wDAAwD;EAE9D,KAAK,OAAO;CACd;AACF;;AAGA,IAAa,mBAAb,cAAsC,MAAM;CAC1C,cAAc;EACZ,MAAM,sDAAsD;EAE5D,KAAK,OAAO;CACd;AACF;;AAGA,IAAa,kBAAb,cAAqC,MAAM;CACpB;CAArB,YAAY,QAAqC;EAC/C,MACE,0BAA0B,OAAO,OAAO,YAAY,OAAO,WAAW,IAAI,KAAK,IAAI,SACrF;EAHmB,KAAA,SAAA;EAKnB,KAAK,OAAO;CACd;AACF;;AAGA,IAAa,6BAAb,cAAgD,MAAM;CACpD,cAAc;EACZ,MAAM,mEAAmE;EAEzE,KAAK,OAAO;CACd;AACF;;;AClCA,MAAM,gBAAgB,EAAE,QAAQ,UAAU;;AAW1C,MAAa,uBAAiC,aAAmD;CAE/F,MAAM,YAAY,OAAO,QAAQ;CACjC,MAAM,eAAe,UAAU,OAAO;CAEtC,IAAI,wBAAwB,UAC1B,aAAa,aAAa,KAAK,QAAQ;CAGzC,MAAM,UAAU,UAAU,OAAO;CAEjC,IAAI,mBAAmB,UACrB,aAAa,QAAQ,KAAK,QAAQ;AAItC;;AAGA,MAAa,mBAA6B,aAAiD;CAGzF,OAFkB,oBAAoB,QAEvB,CAAC,GAAG,aAAa;AAClC;;;AC1BA,MAAa,oBAAoB,OAI/B,SACA,YAC6B;CAC7B,MAAM,WAAW,QAAQ;CAEzB,IAAI,QAAQ,MAAM,SAAS,KAAK;CAEhC,OAAO,CAAC,MAAM,MAAM;EAClB,MAAM,QAAQ,sBAAsB,MAAM,KAAK;EAE/C,IAAI,UAAU,KAAA,GACZ,IAAI;GAEF,MAAM,SAAS,OAAO,KAAA,CAAkB;EAC1C,UAAU;GAER,MAAM,IAAI,yBAAyB,OAAO;EAC5C;EAGF,QAAQ,MAAM,SAAS,KAAK,MAAM,eAAe,QAAQ,KAAK,CAAC;CACjE;CAGA,OAAO,MAAM;AACf;;AAQA,MAAa,2BAA2B,OACtC,YACsB,wBAAwB,QAAQ,CAAC;;AAIzD,MAAa,0BAA0B,OACrC,aACsB;CACtB,IAAI,QAAQ,MAAM,SAAS,KAAK;CAEhC,OAAO,CAAC,MAAM,MAAM;EAClB,MAAM,QAAQ,sBAAsB,MAAM,KAAK;EAE/C,IAAI,UAAU,KAAA,GACZ,IAAI;GAEF,MAAM,SAAS,OAAO,KAAA,CAAkB;EAC1C,UAAU;GAER,MAAM,IAAI,UAAU,4DAA4D;EAClF;EAGF,QAAQ,MAAM,SAAS,KAAK,MAAM,eAAe,QAAQ,KAAK,CAAC;CACjE;CAEA,OAAO,MAAM;AACf;AAGA,MAAM,yBAAyB,UAAgD;CAC7E,IAAI;EACF,kBAAkB,KAAK;EAGvB,OAAO;CACT,QAAQ;EACN;CACF;AACF;;;ACoBA,MAAM,+BAAe,IAAI,QAAuC;AAEhE,MAAM,oBAAoB,UACxB,UAAU,SAAS,MAAM,SAAS;;AAGpC,MAAa,mBAAmB,UAC9B,aAAa,IAAI,KAAK,KAAK,MAAM;;;;;;;;;;;;;;;;;;AA4DnC,IAAa,QAAb,MAAa,MAGX;;CAIA;CAEA,YAAoB,SAAgC;EAClD,MAAM,gBAAgB,OAAO,OAC3B,QAAQ,KAAK,UAAU;GACrB,IAAI,iBAAiB,KAAK,GACxB,OAAO,OAAO,OAAO,EAAE,GAAG,MAAM,CAAC;GAGnC,OAAO,OAAO,OAAO;IACnB,GAAG;IACH,YAAY,4BAA4B,KAAK;GAC/C,CAAC;EACH,CAAC,CACH;EAEA,aAAa,IAAI,MAAM,aAAa;EACpC,KAAK,YAAY,OAAO,OACtB,cAAc,QAAQ,UAAkC,CAAC,iBAAiB,KAAK,CAAC,CAClF;CACF;CAEA,OAAe,mBACb,SAEA,SACA,SACgD;EAEhD,MAAM,QAAoC;GACxC,MAAM;GACN,IAAI,OAAO,yBAAyB;GACpC;GACA;EACF;EAEA,IAAI,YAAY,KAAA,GACd,MAAM,UAAU;EAIlB,OAAO,IAAI,MAAM,CAAC,KAAK,CAAC;CAC1B;;CAGA,OAAgB,QAA6B,OAAO,OAAO,IAAI,MAAoB,CAAC,CAAC,CAAC;CAYtF,OAAO,KACL,SACA,SACmF;EACnF,MAAM,aAAa,kBAAkB,OAAO;EAC5C,MAAM,uBAAwC;GAK5C,OAAO,IAAIA,QAAY;EACzB;EAEA,MAAM,oBAAoB,iBAAoB,WAAW,cAAc;EAGvE,OAAO,IAAI,MAAM,CACf;GACE;GACA;GACA,SAAS;EACX,CACF,CAAC;CACH;;CAGA,OAAO,QACL,SACA,UACmF;EACnF,MAAM,aAAa,kBAAkB,OAAO;EAC5C,MAAM,oBAAoB,uBAA0B,QAAQ;EAG5D,OAAO,IAAI,MAAM,CACf;GACE;GACA;GACA,SAAS;EACX,CACF,CAAC;CACH;;CAGA,OAAO,MACL,SAGA;EACA,MAAM,EAAE,MAAM,OAAO;EACrB,kBAAuB,IAAI;EAY3B,OARc,MAAM,IAAI,IAAI,mBAAmB;GAI7C,OAAO,MAHc,eAAe,QAAQ,IAAI;EAIlD,CAGW;CAGb;CAeA,OAAO,OACL,SACA,SACA,oBACmF;EACnF,MAAM,aAAa,kBAAkB,OAAO;EAC5C,MAAM,aAAa,mBAAmB,kBAAkB;EAExD,MAAM,WAAiC;GACrC;GACA;GACA,SAAS,iBAAoB,OAAO;GACpC,UAAU,UAAU,YAAY;IAE9B,OAAO,WAAW,QAAQ,UAA6B,OAAO;GAChE;EACF;EAEA,IAAI,WAAW,YAAY,KAAA,GAEzB,SAAS,WAAW,UAAU,WAC5B,WAAW,QAAS,UAA6B,MAAM;EAI3D,OAAO,IAAI,MAAM,CAAC,QAAQ,CAAC;CAG7B;;CAGA,OAAO,iBACL,SACA,SACmF;EACnF,MAAM,qBAAqB,YAA+C;GACxE,MAAM,WAAW,MAAM,QAAQ;GAC/B,MAAM,YAAY,oBAAoB,QAAQ;GAE9C,IAAI,CAAC,WACH,MAAM,IAAI,2BAA2B;GAGvC,OAAO;IAAE;IAAU,SAAS;GAAU;EACxC;EAEA,MAAM,aAAa,kBAAkB,OAAO;EAG5C,OAAO,IAAI,MAAM,CACf;GACE;GACA;GACA,SAAS,aAAa,MAAM,mBAAmB,EAAA,CAAG;GAClD;EACF,CACF,CAAC;CACH;CAeA,OAAO,UACL,SACA,SACA,oBACmF;EACnF,MAAM,aAAa,kBAAkB,OAAO;EAC5C,MAAM,aAAa,mBAAmB,kBAAkB;EAExD,MAAM,WAAiC;GACrC;GACA;GACA,eAAe,kBAAkB,SAAS,OAAO;GACjD,UAAU,UAAU,YAAY;IAE9B,OAAO,WAAW,QAAQ,UAA6B,OAAO;GAChE;EACF;EAEA,IAAI,WAAW,YAAY,KAAA,GAEzB,SAAS,WAAW,UAAU,WAC5B,WAAW,QAAS,UAA6B,MAAM;EAI3D,OAAO,IAAI,MAAM,CAAC,QAAQ,CAAC;CAG7B;;CAGA,OAAO,IACL,SACA,SACmF;EACnF,MAAM,aAAa,kBAAkB,OAAO;EAG5C,OAAO,IAAI,MAAM,CACf;GACE;GACA;GACA,eAAe,kBAAkB,SAAS,OAAO;EACnD,CACF,CAAC;CACH;CAuBA,OAAO,cACL,SAIA,oBAC+C;EAC/C,MAAM,YAAY,mBAAmB,kBAAkB;EAEvD,OAAO,MAAM,yBACL;GACJ,MAAM,WAAW,QAAQ;GAEzB,IAAI,eAAe,QAAQ,GACzB,OAAO,wBAAwB,QAAQ;GAGzC,OAAO;EACT,GACA,UAAU,SACV,UAAU,OACZ;CACF;CAaA,OAAO,iBACL,SACA,oBACoE;EACpE,MAAM,aAAa,mBAAmB,kBAAkB;EAGxD,OAAO,MAAM,yBACL,yBAAyB,OAAO,IACrC,UAAU,YAAY;GAErB,OAAO,WAAW,QAAQ,UAAsB,OAAO;EACzD,GACA,WAAW,YAAY,KAAA,IACnB,KAAA,KACC,UAAU,WAAW,WAAW,QAAS,UAAsB,MAAM,CAC5E;CACF;;CAGA,OAAO,cACL,SAC+E;EAE/E,OAAO,MAAM,mBACX,YAAY;GACV,MAAM,SAAS,MAAM,QAAQ;GAE7B,IAAI,OAAO,QAAQ,MAAM,GACvB,MAAM,OAAO;EAEjB,GACA,YAAY,CAAC,CACf;CACF;;CAGA,OAAO,MACL,GAAG,QACkB;EACrB,MAAM,0BAAU,IAAI,IAAiC;EAErD,KAAK,MAAM,SAAS,QAClB,KAAK,MAAM,SAAS,gBAAgB,KAAK,GAAG;GAC1C,IAAI,iBAAiB,KAAK,GAAG;IAC3B,QAAQ,IAAI,MAAM,IAAI,KAAK;IAC3B;GACF;GAEA,MAAM,UAAU,MAAM;GACtB,MAAM,aAAa,4BAA4B,KAAK;GACpD,MAAM,WAAW,QAAQ,IAAI,UAAU;GAEvC,IAAI,UAAU;IACZ,IAAI,iBAAiB,QAAQ,GAC3B,MAAM,IAAI,MAAM,4DAA4D;IAG9E,IAAI,SAAS,YAAY,SACvB,MAAM,IAAI,yBAAyB,SAAS,SAAS,OAAO;IAG9D,MAAM,IAAI,sBAAsB,OAAO;GACzC;GAEA,QAAQ,IAAI,YAAY,KAAK;EAC/B;EAIF,OAAO,IAAI,MAAM,CAAC,GAAG,QAAQ,OAAO,CAAC,CAAC;CACxC;;CAGA,OAAO,SAA+B,OAAgC;EACpE,OAAO;CACT;CAoBA,OAAO,SAAS,MAAkB,GAAG,WAAmD;EACtF,MAAM,0BAAU,IAAI,IAAiC;EAErD,KAAK,MAAM,SAAS,gBAAgB,IAAI,GACtC,QAAQ,IAAI,iBAAiB,KAAK,IAAI,MAAM,KAAK,4BAA4B,KAAK,GAAG,KAAK;EAG5F,KAAK,MAAM,SAAS,WAClB,KAAK,MAAM,SAAS,gBAAgB,KAAK,GACvC,QAAQ,IAAI,iBAAiB,KAAK,IAAI,MAAM,KAAK,4BAA4B,KAAK,GAAG,KAAK;EAK9F,OAAO,IAAI,MAAM,CAAC,GAAG,QAAQ,OAAO,CAAC,CAAC;CACxC;AACF;AAIA,OAAO,eAAe,OAAO,SAAS;CACpC,OAAO,MAAM;CACb,UAAU;CACV,YAAY;CACZ,cAAc;AAChB,CAAC;AAED,MAAM,oBAEF,kBAEI;CAEJ,OAAO,QAAQ;AACjB;AAEF,MAAM,sBACJ,cAC6B;CAE7B,IAAI,OAAO,cAAc,YACvB,OAAO,EAAE,SAAS,UAAU;CAG9B,OAAO;AACT;AAGA,MAAM,kBAAkB,UAAkD;CACxE,IAAI,EAAE,iBAAiB,WAAW,EAAE,UAAU,QAC5C,OAAO;CAGT,OAAO,MAAM,gBAAgB;AAC/B"}