better-effect 0.7.0 → 0.9.1

package/dist/signal-BgUtPQj5.mjs

@@ -0,0 +1,271 @@
+import { a as ServiceTagCollisionError, l as ServiceRuntimeNotConfiguredError, r as LayerGeneratorYieldError, t as DuplicateServiceError } from "./errors-Dnjhzbt0.mjs";
+import { a as runRuntimeContext, i as makeRuntimeContext, n as currentRuntimeContext, o as setDefaultRuntimeContextStorage, r as getRuntimeContext } from "./context-B4yO5LaH.mjs";
+import { nodeRuntimeContextStorage } from "./runtime/node.mjs";
+//#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 context = makeRuntimeContext(resolver, current?.scope, current?.resolver === resolver ? current.resolutionPath : [], current?.signal);
+		return runRuntimeContext(storage, context, program);
+	}
+	/** Return the resolver active in the current execution context. */
+	static current() {
+		let context;
+		try {
+			context = currentRuntimeContext();
+		} catch {
+			throw new ServiceRuntimeNotConfiguredError();
+		}
+		if (!context.resolver) throw new ServiceRuntimeNotConfiguredError();
+		return context.resolver;
+	}
+	/** Resolve a Service token using the active resolver. */
+	static async resolve(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) {
+		if (tag.length === 0) throw new TypeError("Service tags must not be empty");
+		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);
+			}
+		}
+		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]);
+	}
+	static make(service, acquire) {
+		const defaultAcquire = () => {
+			return new service();
+		};
+		const normalizedAcquire = normalizeAcquire(acquire ?? defaultAcquire);
+		return new Layer([{
+			service,
+			acquire: normalizedAcquire
+		}]);
+	}
+	/** Create a Layer from an already-constructed Service instance. */
+	static succeed(service, instance) {
+		const normalizedAcquire = normalizeAcquire(() => instance);
+		return new Layer([{
+			service,
+			acquire: normalizedAcquire
+		}]);
+	}
+	/** Define a provider with Runtime-root cleanup. */
+	static scoped(service, acquire, release) {
+		return new Layer([{
+			service,
+			acquire: normalizeAcquire(acquire),
+			release: (instance, outcome) => {
+				return release(instance, outcome);
+			}
+		}]);
+	}
+	/** Define a provider whose acquisition can yield contextual Services. */
+	static scopedGen(service, factory, release) {
+		return new Layer([{
+			service,
+			acquire: () => runLayerGenerator(service, factory),
+			release: (instance, outcome) => {
+				return release(instance, outcome);
+			}
+		}]);
+	}
+	/** Define a provider whose acquisition can yield contextual Services. */
+	static gen(service, factory) {
+		return new Layer([{
+			service,
+			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 existing = providers.get(service.serviceTag);
+			if (existing) {
+				if (existing.service !== service) throw new ServiceTagCollisionError(existing.service, service);
+				throw new DuplicateServiceError(service);
+			}
+			providers.set(service.serviceTag, provider);
+		}
+		return new Layer([...providers.values()]);
+	}
+	/** Mark a Layer composition root as complete without changing its runtime value. */
+	static complete(layer) {
+		return layer;
+	}
+	/** Replace providers in a base Layer, using tag identity and compatible contracts. */
+	static override(base, ...overrides) {
+		const providers = /* @__PURE__ */ new Map();
+		for (const provider of base.providers) providers.set(provider.service.serviceTag, provider);
+		for (const layer of overrides) for (const provider of layer.providers) providers.set(provider.service.serviceTag, provider);
+		return new Layer([...providers.values()]);
+	}
+};
+const normalizeAcquire = (acquire) => () => {
+	return acquire();
+};
+//#endregion
+//#region src/runtime/signal.ts
+const neverAbortedSignal = new AbortController().signal;
+/** Link caller, Runtime and shutdown signals without owning the caller's controller. */
+const linkAbortSignals = (...signals) => {
+	const active = signals.filter((signal) => signal !== void 0);
+	if (active.length === 0) return {
+		signal: neverAbortedSignal,
+		dispose: () => {}
+	};
+	if (active.length === 1) return {
+		signal: active[0],
+		dispose: () => {}
+	};
+	const controller = new AbortController();
+	const listeners = [];
+	let disposed = false;
+	const dispose = () => {
+		if (disposed) return;
+		disposed = true;
+		for (const [source, listener] of listeners) source.removeEventListener("abort", listener);
+		listeners.length = 0;
+	};
+	const abortFrom = (source) => {
+		if (controller.signal.aborted) return;
+		controller.abort(source.reason);
+		dispose();
+	};
+	for (const source of active) {
+		if (source.aborted) {
+			abortFrom(source);
+			break;
+		}
+		const listener = () => abortFrom(source);
+		listeners.push([source, listener]);
+		source.addEventListener("abort", listener, { once: true });
+	}
+	return {
+		signal: controller.signal,
+		dispose
+	};
+};
+/** Return the current cooperative-cancellation signal. */
+const currentAbortSignal = () => currentRuntimeContext().signal ?? neverAbortedSignal;
+/** Yieldable access to the signal of the current Runtime execution. */
+const CurrentAbortSignal = { *[Symbol.iterator]() {
+	return currentAbortSignal();
+} };
+//#endregion
+export { ServiceRuntime as a, Service as i, linkAbortSignals as n, defaultRuntimeContextStorage as o, Layer as r, CurrentAbortSignal as t };
+
+//# sourceMappingURL=signal-BgUtPQj5.mjs.map

package/dist/signal-BgUtPQj5.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal-BgUtPQj5.mjs","names":["Constructor"],"sources":["../src/runtime/default.ts","../src/service/runtime.ts","../src/service/service.ts","../src/layer/internal.ts","../src/layer/layer.ts","../src/runtime/signal.ts"],"sourcesContent":["import { nodeRuntimeContextStorage } from './node'\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'\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 context = makeRuntimeContext(\n      resolver,\n      current?.scope,\n      current?.resolver === resolver ? current.resolutionPath : [],\n      current?.signal\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 {\n      throw new ServiceRuntimeNotConfiguredError()\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    const resolver = ServiceRuntime.current()\n\n    return await resolver.resolve(token)\n  }\n}\n","import { ServiceRuntime } from './runtime'\n\nimport type { ServiceRequirement } from '../effect/types'\n\nimport type {\n  AnyService,\n  AnyServiceToken,\n  ServiceClass,\n  ServiceContract,\n  ServiceIdentity,\n  ServiceIdentityTypeId,\n  ServiceInstance,\n  ServiceRequirements,\n  ServiceTag,\n  ServiceToken,\n  ServiceTokenOf\n} from './types'\n\ntype ServiceTagLiteral<Tag extends string> = string extends Tag\n  ? never\n  : Tag extends ''\n    ? never\n    : Tag\n\ninterface ServiceFactory<Self> {\n  <const Tag extends string>(\n    tag: ServiceTagLiteral<Tag>\n  ): (abstract new () => ServiceIdentity<Tag>) & {\n    readonly name: string\n    readonly serviceTag: Tag\n  } & {\n    readonly of: Service.FactoryOf<Self, Tag>\n    readonly [Symbol.asyncIterator]: (\n      this: ServiceToken<Tag, Self & ServiceIdentity<Tag>>\n    ) => AsyncGenerator<ServiceRequirement<Self>, Self, unknown>\n  }\n}\n\n/**\n * Declare a class-backed Service with a stable string-literal identity.\n *\n * The returned class is simultaneously the implementation type, the runtime\n * dependency token, and the value yielded by `yield*` in an Effect generator.\n * The explicit self type preserves exact instance inference, while the second\n * call captures the tag as a literal for Layer composition and diagnostics.\n *\n * @example\n * ```ts\n * class Database extends Service<Database>()('Database') {\n *   query(): string {\n *     return 'ok'\n *   }\n * }\n *\n * const database = yield* Database\n * database.query()\n * ```\n *\n * @typeParam Self The instance type implemented by the declared Service.\n */\nexport function Service<Self>(): ServiceFactory<Self> {\n  return function <const Tag extends string>(tag: ServiceTagLiteral<Tag>) {\n    if (tag.length === 0) {\n      throw new TypeError('Service tags must not be empty')\n    }\n\n    abstract class BaseService implements ServiceIdentity<Tag> {\n      /** The stable logical identity used by Layers and resolver backends. */\n      static readonly serviceTag: Tag = tag\n      declare readonly [ServiceIdentityTypeId]: Tag\n\n      /**\n       * Type-check a structural implementation of this Service.\n       *\n       * This is an identity helper. It returns the supplied value unchanged\n       * and does not invoke a constructor or modify its prototype.\n       *\n       * @example\n       * ```ts\n       * class Database extends Service<Database>()('Database') {\n       *   query(sql: string): string {\n       *     return sql\n       *   }\n       * }\n       *\n       * const database = Database.of({\n       *   query: (sql) => `Result: ${sql}`\n       * })\n       *\n       * database.query('SELECT 1')\n       * // 'Result: SELECT 1'\n       * // database is the original object, not an instance of Database\n       * ```\n       */\n      static of(this: void, implementation: ServiceContract<Self & ServiceIdentity<Tag>>): Self {\n        // SAFETY: ServiceContract removes only the phantom marker; this boundary restores Self.\n        return implementation as Self\n      }\n\n      /** Resolve this Service from the resolver active in the current runtime. */\n      // oxlint-disable-next-line require-yield\n      static async *[Symbol.asyncIterator](\n        this: ServiceToken<Tag, Self & ServiceIdentity<Tag>>\n      ): AsyncGenerator<ServiceRequirement<Self>, Self, unknown> {\n        return await ServiceRuntime.resolve(this)\n      }\n    }\n\n    return BaseService\n  }\n}\n\n/** Type-level aliases for Service tokens and their instance contracts. */\nexport declare namespace Service {\n  /** The widened Service instance constraint. */\n  export type Any = AnyService\n\n  /** A class-backed Service token with a stable tag and instance contract. */\n  export type Token<Tag extends string = string, Instance extends AnyService = any> = ServiceToken<\n    Tag,\n    Instance\n  >\n\n  /** A constructible Service class with a stable tag and instance contract. */\n  export type Class<\n    Tag extends string = string,\n    Instance extends AnyService = AnyService\n  > = ServiceClass<Tag, Instance>\n\n  /** Extract the instance represented by a Service token. */\n  export type Instance<T extends AnyServiceToken> = ServiceInstance<T>\n\n  /** Extract the stable tag represented by a Service instance. */\n  export type Tag<S extends AnyService> = ServiceTag<S>\n\n  /** A branded Service instance identity with a stable tag. */\n  export type Identity<Tag extends string = string> = ServiceIdentity<Tag>\n\n  /** Remove the internal identity marker from a Service implementation contract. */\n  export type Contract<S extends AnyService> = ServiceContract<S>\n\n  /** Extract the Service token represented by a branded Service instance. */\n  export type TokenOf<S extends AnyService> = ServiceTokenOf<S>\n\n  /** Declaration bridge for the recursive structural `Service.of` signature. */\n  export type FactoryOf<Self, Tag extends string> = (\n    this: void,\n    implementation: ServiceContract<Self & ServiceIdentity<Tag>>\n  ) => Self\n\n  /** Extract Effect Service requirements from a Service instance. */\n  export type Requirements<S extends AnyService> = ServiceRequirements<S>\n}\n","import { LayerGeneratorYieldError } from './errors'\n\nimport type { ServiceRequirement } from '../effect/types'\nimport type { ServiceClass } from '../service'\n\nimport type { LayerGenerator } from './types'\n\nexport const runLayerGenerator = async <\n  S extends ServiceClass<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  const state = await iterator.next()\n\n  if (!state.done) {\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  // SAFETY: The public generator boundary accepts only the requested Service contract.\n  return state.value as InstanceType<S>\n}\n","import type { ServiceRequirement } from '../effect/types'\nimport type { AnyService, ServiceClass, ServiceContract, ServiceRequirements } from '../service'\nimport type { ScopeOutcome } from '../scope'\nimport type { Covariant, Invariant } from '../internal/variance'\nimport type { MaybePromise } from '../utils/types'\n\nimport { DuplicateServiceError, ServiceTagCollisionError } from './errors'\nimport { runLayerGenerator } from './internal'\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 { LayerGenerator, LayerGeneratorRequirements, LayerRegistration } 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\ninterface LayerProvider extends LayerRegistration {\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\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\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 provider registrations retained by this Layer. */\n  readonly providers: readonly LayerProvider[]\n\n  private constructor(providers: readonly LayerProvider[]) {\n    this.providers = Object.freeze([...providers])\n  }\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 ServiceClass<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 ServiceClass<any, any>>(\n    service: S,\n    acquire?: () => MaybePromise<ServiceContract<InstanceType<S>>>\n  ): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>> {\n    const defaultAcquire = (): InstanceType<S> => {\n      // SAFETY: The no-argument overload constrains `service` to a default constructible class.\n      const Constructor = service 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        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 ServiceClass<any, any>>(\n    service: S,\n    instance: ServiceContract<InstanceType<S>>\n  ): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>> {\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        acquire: normalizedAcquire\n      }\n    ]) as LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>>\n  }\n\n  /** Define a provider with Runtime-root cleanup. */\n  static scoped<S extends ServiceClass<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    // SAFETY: The public callbacks constrain acquisition and release to the requested Service.\n    return new Layer([\n      {\n        service,\n        acquire: normalizeAcquire<S>(acquire),\n        release: (instance, outcome) => {\n          // SAFETY: The backend invokes release with the instance acquired for this token.\n          return release(instance as InstanceType<S>, outcome)\n        }\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 ServiceClass<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    // SAFETY: The generator and release callback are checked against the requested Service.\n    return new Layer([\n      {\n        service,\n        acquire: () => runLayerGenerator(service, factory),\n        release: (instance, outcome) => {\n          // SAFETY: The backend invokes release with the instance acquired for this token.\n          return release(instance as InstanceType<S>, outcome)\n        }\n      }\n    ]) as LayerResult<ProviderEntry<InstanceType<S>, LayerGeneratorRequirements<S, Yield>>>\n  }\n\n  /** Define a provider whose acquisition can yield contextual Services. */\n  static gen<S extends ServiceClass<any, any>, Yield extends ServiceRequirement<unknown>>(\n    service: S,\n    factory: LayerGenerator<S, Yield>\n  ): LayerResult<ProviderEntry<InstanceType<S>, LayerGeneratorRequirements<S, Yield>>> {\n    // SAFETY: The generator result is normalized to the requested Service at the runtime boundary.\n    return new Layer([\n      {\n        service,\n        acquire: () => runLayerGenerator(service, factory)\n      }\n    ]) as LayerResult<ProviderEntry<InstanceType<S>, LayerGeneratorRequirements<S, Yield>>>\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 providers = new Map<string, LayerProvider>()\n\n    for (const layer of layers) {\n      for (const provider of layer.providers) {\n        const service = provider.service\n        const existing = providers.get(service.serviceTag)\n\n        if (existing) {\n          if (existing.service !== service) {\n            throw new ServiceTagCollisionError(existing.service, service)\n          }\n\n          throw new DuplicateServiceError(service)\n        }\n\n        providers.set(service.serviceTag, provider)\n      }\n    }\n\n    // SAFETY: The heterogeneous provider list is erased only at this internal storage boundary.\n    return new Layer([...providers.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, const Overrides extends readonly LayerInput[]>(\n    base: Base & ValidateLayerInput<Base>,\n    ...overrides: Overrides & ValidateOverrides<Base, Overrides>\n  ): OverrideLayerResult<Base, Overrides> {\n    const providers = new Map<string, LayerProvider>()\n\n    for (const provider of base.providers) {\n      providers.set(provider.service.serviceTag, provider)\n    }\n\n    for (const layer of overrides) {\n      for (const provider of layer.providers) {\n        providers.set(provider.service.serviceTag, provider)\n      }\n    }\n\n    // SAFETY: Runtime provider replacement preserves the computed override metadata.\n    return new Layer([...providers.values()]) as OverrideLayerResult<Base, Overrides>\n  }\n}\n\nconst normalizeAcquire =\n  <S extends ServiceClass<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\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","import { currentRuntimeContext } from './context'\n\nconst neverAbortedSignal = new AbortController().signal\n\ntype SignalListener = readonly [AbortSignal, () => void]\n\nexport type AbortSignalLink = {\n  readonly signal: AbortSignal\n  readonly dispose: () => void\n}\n\n/** Link caller, Runtime and shutdown signals without owning the caller's controller. */\nexport const linkAbortSignals = (\n  ...signals: readonly (AbortSignal | undefined)[]\n): AbortSignalLink => {\n  const active = signals.filter((signal): signal is AbortSignal => signal !== undefined)\n\n  if (active.length === 0) {\n    return { signal: neverAbortedSignal, dispose: () => {} }\n  }\n\n  if (active.length === 1) {\n    return { signal: active[0]!, dispose: () => {} }\n  }\n\n  const controller = new AbortController()\n  const listeners: SignalListener[] = []\n  let disposed = false\n\n  const dispose = (): void => {\n    if (disposed) {\n      return\n    }\n\n    disposed = true\n\n    for (const [source, listener] of listeners) {\n      source.removeEventListener('abort', listener)\n    }\n\n    listeners.length = 0\n  }\n\n  const abortFrom = (source: AbortSignal): void => {\n    if (controller.signal.aborted) {\n      return\n    }\n\n    controller.abort(source.reason)\n    dispose()\n  }\n\n  for (const source of active) {\n    if (source.aborted) {\n      abortFrom(source)\n      break\n    }\n\n    const listener = (): void => abortFrom(source)\n    listeners.push([source, listener])\n    source.addEventListener('abort', listener, { once: true })\n  }\n\n  return { signal: controller.signal, dispose }\n}\n\n/** Return the current cooperative-cancellation signal. */\nexport const currentAbortSignal = (): AbortSignal =>\n  currentRuntimeContext().signal ?? neverAbortedSignal\n\n/** Yieldable access to the signal of the current Runtime execution. */\nexport const CurrentAbortSignal = {\n  // oxlint-disable-next-line require-yield\n  *[Symbol.iterator](): Generator<never, AbortSignal, unknown> {\n    return currentAbortSignal()\n  }\n} as const\n"],"mappings":"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"}

package/dist/standard-services.d.mts

@@ -0,0 +1,116 @@
+import { I as ServiceIdentity, V as ServiceToken, b as Service, j as ServiceRequirement } from "./index-BFgG9zZC.mjs";
+import { S as LayerResult, w as ProviderEntry } from "./index-BSRPIYII.mjs";
+import { t as CurrentAbortSignal } from "./index-yOfq7LKL.mjs";
+//#region src/standard-services/index.d.ts
+declare const Clock_base: (abstract new () => ServiceIdentity<"Clock">) & {
+  readonly name: string;
+  readonly serviceTag: "Clock";
+} & {
+  readonly of: Service.FactoryOf<Clock, "Clock">;
+  readonly [Symbol.asyncIterator]: (this: ServiceToken<"Clock", Clock & ServiceIdentity<"Clock">>) => AsyncGenerator<ServiceRequirement<Clock>, Clock, unknown>;
+};
+/** Host-backed time and waiting service. */
+declare class Clock extends Clock_base {
+  now(): Date;
+  sleep(milliseconds: number): Promise<void>;
+}
+/** The default host Clock provider. */
+declare const ClockLive: LayerResult<ProviderEntry<Clock, never>>;
+/** Deterministic Clock implementation for tests. */
+declare class ClockTest implements Service.Contract<Clock> {
+  private currentTime;
+  private readonly waiters;
+  constructor(initial?: Date | number);
+  now(): Date;
+  setTime(value: Date | number): void;
+  advance(milliseconds: number): void;
+  sleep(milliseconds: number): Promise<void>;
+  static layer(initial?: Date | number): LayerResult<ProviderEntry<Clock, never>>;
+  private flushWaiters;
+}
+declare const ClockTestLayer: (initial?: Date | number) => LayerResult<ProviderEntry<Clock, never>>;
+declare const Random_base: (abstract new () => ServiceIdentity<"Random">) & {
+  readonly name: string;
+  readonly serviceTag: "Random";
+} & {
+  readonly of: Service.FactoryOf<Random, "Random">;
+  readonly [Symbol.asyncIterator]: (this: ServiceToken<"Random", Random & ServiceIdentity<"Random">>) => AsyncGenerator<ServiceRequirement<Random>, Random, unknown>;
+};
+/** Host-backed pseudo-random number service. */
+declare class Random extends Random_base {
+  next(): number;
+  nextInt(maxExclusive: number): number;
+}
+/** The default host Random provider. */
+declare const RandomLive: LayerResult<ProviderEntry<Random, never>>;
+/** Reproducible pseudo-random implementation with isolated mutable state. */
+declare class RandomSeeded implements Service.Contract<Random> {
+  private state;
+  constructor(seed: number);
+  next(): number;
+  nextInt(maxExclusive: number): number;
+  static layer(seed: number): LayerResult<ProviderEntry<Random, never>>;
+}
+declare const RandomSeededLayer: (seed: number) => LayerResult<ProviderEntry<Random, never>>;
+type LoggerLevel = 'debug' | 'info' | 'warn' | 'error';
+type LoggerEvent = {
+  level: LoggerLevel;
+  message: string;
+  data?: LoggerData;
+};
+type LoggerData = string | number | boolean | bigint | null | readonly LoggerData[] | {
+  readonly [key: string]: LoggerData;
+};
+declare const Logger_base: (abstract new () => ServiceIdentity<"Logger">) & {
+  readonly name: string;
+  readonly serviceTag: "Logger";
+} & {
+  readonly of: Service.FactoryOf<Logger, "Logger">;
+  readonly [Symbol.asyncIterator]: (this: ServiceToken<"Logger", Logger & ServiceIdentity<"Logger">>) => AsyncGenerator<ServiceRequirement<Logger>, Logger, unknown>;
+};
+/** Structured host logger bridge. */
+declare class Logger extends Logger_base {
+  log(event: LoggerEvent): void;
+  log(level: LoggerLevel, message: string, data?: LoggerData): void;
+  debug(message: string, data?: LoggerData): void;
+  info(message: string, data?: LoggerData): void;
+  warn(message: string, data?: LoggerData): void;
+  error(message: string, data?: LoggerData): void;
+}
+/** The default host Logger provider. */
+declare const LoggerLive: LayerResult<ProviderEntry<Logger, never>>;
+/** Ordered in-memory Logger implementation for tests. */
+declare class LoggerTest implements Service.Contract<Logger> {
+  readonly events: LoggerEvent[];
+  log(event: LoggerEvent): void;
+  log(level: LoggerLevel, message: string, data?: LoggerData): void;
+  debug(message: string, data?: LoggerData): void;
+  info(message: string, data?: LoggerData): void;
+  warn(message: string, data?: LoggerData): void;
+  error(message: string, data?: LoggerData): void;
+  clear(): void;
+  static make(): {
+    logger: LoggerTest;
+    layer: LayerResult<ProviderEntry<Logger, never>>;
+  };
+  static layer(logger?: LoggerTest): LayerResult<ProviderEntry<Logger, never>>;
+}
+declare const LoggerTestLayer: () => LayerResult<ProviderEntry<Logger, never>>;
+declare const CurrentRequest_base: (abstract new () => ServiceIdentity<"CurrentRequest">) & {
+  readonly name: string;
+  readonly serviceTag: "CurrentRequest";
+} & {
+  readonly of: Service.FactoryOf<CurrentRequest, "CurrentRequest">;
+  readonly [Symbol.asyncIterator]: (this: ServiceToken<"CurrentRequest", CurrentRequest & ServiceIdentity<"CurrentRequest">>) => AsyncGenerator<ServiceRequirement<CurrentRequest>, CurrentRequest, unknown>;
+};
+/** Execution-local request value carried by a normal Service provider. */
+declare class CurrentRequest extends CurrentRequest_base {
+  readonly value: unknown;
+  readonly request: unknown;
+  constructor(value: unknown);
+  static layer(value: unknown): LayerResult<ProviderEntry<CurrentRequest, never>>;
+}
+declare const CurrentRequestLayer: (value: unknown) => LayerResult<ProviderEntry<CurrentRequest, never>>;
+//#endregion
+export { Clock, ClockLive, ClockTest, ClockTestLayer, CurrentAbortSignal, CurrentRequest, CurrentRequestLayer, Logger, LoggerData, LoggerEvent, LoggerLevel, LoggerLive, LoggerTest, LoggerTestLayer, Random, RandomLive, RandomSeeded, RandomSeededLayer };
+//# sourceMappingURL=standard-services.d.mts.map

package/dist/standard-services.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard-services.d.mts","names":[],"sources":["../src/standard-services/index.ts"],"mappings":";;;;;;;;;;;;cAaa,cAAc;EACzB,OAAO;EAIP,MAAM,uBAAuB;;;cAOlB,WAAS,YAAA,cAAA;;cAQT,qBAAqB,QAAQ,SAAS;UACzC;mBAES;EAEL,YAAA,UAAS;EAQrB,OAAO;EAIP,QAAQ,OAAO;EAWf,QAAQ;EAMR,MAAM,uBAAuB;SAStB,MAAM,UAAS,gBAAiB,YAAA,cAAA;UAI/B;;cAYG,iBAAkB,UAAS,kBAAiB,YAAA,cAAA;;;;;;;;;cAG5C,eAAe;EAC1B;EAIA,QAAQ;;;cAUG,YAAU,YAAA,cAAA;;cAGV,wBAAwB,QAAQ,SAAS;UAC5C;EAEI,YAAA;EAQZ;EAKA,QAAQ;SAQD,MAAM,eAAY,YAAA,cAAA;;cAKd,oBAAqB,iBAAY,YAAA,cAAA;KAElC;KAEA;EACV,OAAO;EACP;EACA,OAAO;;KAGG,kEAMC;YACG,cAAc;;;;;;;;;;cAqBjB,eAAe;EAC1B,IAAI,OAAO;EACX,IAAI,OAAO,aAAa,iBAAiB,OAAO;EAahD,MAAM,iBAAiB,OAAO;EAI9B,KAAK,iBAAiB,OAAO;EAI7B,KAAK,iBAAiB,OAAO;EAI7B,MAAM,iBAAiB,OAAO;;;cAMnB,YAAU,YAAA,cAAA;;cAGV,sBAAsB,QAAQ,SAAS;WACzC,QAAQ;EAEjB,IAAI,OAAO;EACX,IAAI,OAAO,aAAa,iBAAiB,OAAO;EAOhD,MAAM,iBAAiB,OAAO;EAI9B,KAAK,iBAAiB,OAAO;EAI7B,KAAK,iBAAiB,OAAO;EAI7B,MAAM,iBAAiB,OAAO;EAI9B;SAIO;;;;SAKA,MAAM,SAAQ,aAA6B,YAAA,cAAA;;cAKvC,uBAAe,YAAA,cAAA;;;;;;;;;cAGf,uBAAuB;WAIb;WAHZ;EAGY,YAAA;SAMd,MAAM,iBAAc,YAAA,cAAA;;cAMhB,sBAAuB,mBAAc,YAAA,cAAA"}

package/dist/standard-services.mjs

@@ -0,0 +1,180 @@
+import { i as Service, r as Layer, t as CurrentAbortSignal } from "./signal-BgUtPQj5.mjs";
+//#region src/standard-services/index.ts
+const assertDelay = (milliseconds) => {
+	if (!Number.isFinite(milliseconds) || milliseconds < 0) throw new RangeError("Delay must be a finite non-negative number");
+};
+/** Host-backed time and waiting service. */
+var Clock = class extends Service()("Clock") {
+	now() {
+		return /* @__PURE__ */ new Date();
+	}
+	sleep(milliseconds) {
+		assertDelay(milliseconds);
+		return new Promise((resolve) => setTimeout(resolve, milliseconds));
+	}
+};
+/** The default host Clock provider. */
+const ClockLive = Layer.make(Clock);
+/** Deterministic Clock implementation for tests. */
+var ClockTest = class ClockTest {
+	currentTime;
+	waiters = [];
+	constructor(initial = 0) {
+		this.currentTime = initial instanceof Date ? initial.getTime() : initial;
+		if (!Number.isFinite(this.currentTime)) throw new RangeError("ClockTest time must be finite");
+	}
+	now() {
+		return new Date(this.currentTime);
+	}
+	setTime(value) {
+		const next = value instanceof Date ? value.getTime() : value;
+		if (!Number.isFinite(next)) throw new RangeError("ClockTest time must be finite");
+		this.currentTime = next;
+		this.flushWaiters();
+	}
+	advance(milliseconds) {
+		assertDelay(milliseconds);
+		this.currentTime += milliseconds;
+		this.flushWaiters();
+	}
+	sleep(milliseconds) {
+		assertDelay(milliseconds);
+		return new Promise((resolve) => {
+			this.waiters.push({
+				at: this.currentTime + milliseconds,
+				resolve
+			});
+			this.flushWaiters();
+		});
+	}
+	static layer(initial = 0) {
+		return Layer.succeed(Clock, new ClockTest(initial));
+	}
+	flushWaiters() {
+		for (let index = this.waiters.length - 1; index >= 0; index--) {
+			const waiter = this.waiters[index];
+			if (waiter.at <= this.currentTime) {
+				this.waiters.splice(index, 1);
+				waiter.resolve();
+			}
+		}
+	}
+};
+const ClockTestLayer = (initial = 0) => ClockTest.layer(initial);
+/** Host-backed pseudo-random number service. */
+var Random = class extends Service()("Random") {
+	next() {
+		return Math.random();
+	}
+	nextInt(maxExclusive) {
+		if (!Number.isInteger(maxExclusive) || maxExclusive <= 0) throw new RangeError("Random.nextInt maxExclusive must be a positive integer");
+		return Math.floor(this.next() * maxExclusive);
+	}
+};
+/** The default host Random provider. */
+const RandomLive = Layer.make(Random);
+/** Reproducible pseudo-random implementation with isolated mutable state. */
+var RandomSeeded = class RandomSeeded {
+	state;
+	constructor(seed) {
+		if (!Number.isFinite(seed)) throw new RangeError("RandomSeeded seed must be finite");
+		this.state = seed >>> 0;
+	}
+	next() {
+		this.state = 1664525 * this.state + 1013904223 >>> 0;
+		return this.state / 4294967296;
+	}
+	nextInt(maxExclusive) {
+		if (!Number.isInteger(maxExclusive) || maxExclusive <= 0) throw new RangeError("RandomSeeded.nextInt maxExclusive must be a positive integer");
+		return Math.floor(this.next() * maxExclusive);
+	}
+	static layer(seed) {
+		return Layer.succeed(Random, new RandomSeeded(seed));
+	}
+};
+const RandomSeededLayer = (seed) => RandomSeeded.layer(seed);
+const isLoggerLevel = (value) => value === "debug" || value === "info" || value === "warn" || value === "error";
+const toLoggerEvent = (input, message, data) => {
+	if (!isLoggerLevel(input)) return input;
+	const event = {
+		level: input,
+		message: message ?? ""
+	};
+	if (data !== void 0) event.data = data;
+	return event;
+};
+/** Structured host logger bridge. */
+var Logger = class extends Service()("Logger") {
+	log(first, message, data) {
+		const event = toLoggerEvent(first, message, data);
+		const write = console[event.level];
+		if (event.data === void 0) write.call(console, event.message);
+		else write.call(console, event.message, event.data);
+	}
+	debug(message, data) {
+		this.log("debug", message, data);
+	}
+	info(message, data) {
+		this.log("info", message, data);
+	}
+	warn(message, data) {
+		this.log("warn", message, data);
+	}
+	error(message, data) {
+		this.log("error", message, data);
+	}
+};
+/** The default host Logger provider. */
+const LoggerLive = Layer.make(Logger);
+/** Ordered in-memory Logger implementation for tests. */
+var LoggerTest = class LoggerTest {
+	events = [];
+	log(first, message, data) {
+		const event = toLoggerEvent(first, message, data);
+		this.events.push(event);
+	}
+	debug(message, data) {
+		this.log("debug", message, data);
+	}
+	info(message, data) {
+		this.log("info", message, data);
+	}
+	warn(message, data) {
+		this.log("warn", message, data);
+	}
+	error(message, data) {
+		this.log("error", message, data);
+	}
+	clear() {
+		this.events.length = 0;
+	}
+	static make() {
+		const logger = new LoggerTest();
+		return {
+			logger,
+			layer: Layer.succeed(Logger, logger)
+		};
+	}
+	static layer(logger = new LoggerTest()) {
+		return Layer.succeed(Logger, logger);
+	}
+};
+const LoggerTestLayer = () => LoggerTest.layer();
+/** Execution-local request value carried by a normal Service provider. */
+var CurrentRequest = class CurrentRequest extends Service()("CurrentRequest") {
+	value;
+	request;
+	constructor(value) {
+		super();
+		this.value = value;
+		this.request = value;
+	}
+	static layer(value) {
+		return Layer.succeed(CurrentRequest, new CurrentRequest(value));
+	}
+};
+const CurrentRequestLayer = (value) => CurrentRequest.layer(value);
+//#endregion
+export { Clock, ClockLive, ClockTest, ClockTestLayer, CurrentAbortSignal, CurrentRequest, CurrentRequestLayer, Logger, LoggerLive, LoggerTest, LoggerTestLayer, Random, RandomLive, RandomSeeded, RandomSeededLayer };
+
+//# sourceMappingURL=standard-services.mjs.map

package/dist/standard-services.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard-services.mjs","names":[],"sources":["../src/standard-services/index.ts"],"sourcesContent":["import { CurrentAbortSignal } from '../runtime'\nimport { Layer } from '../layer'\nimport { Service } from '../service'\n\nexport { CurrentAbortSignal }\n\nconst assertDelay = (milliseconds: number): void => {\n  if (!Number.isFinite(milliseconds) || milliseconds < 0) {\n    throw new RangeError('Delay must be a finite non-negative number')\n  }\n}\n\n/** Host-backed time and waiting service. */\nexport class Clock extends Service<Clock>()('Clock') {\n  now(): Date {\n    return new Date()\n  }\n\n  sleep(milliseconds: number): Promise<void> {\n    assertDelay(milliseconds)\n    return new Promise((resolve) => setTimeout(resolve, milliseconds))\n  }\n}\n\n/** The default host Clock provider. */\nexport const ClockLive = Layer.make(Clock)\n\ntype ClockWaiter = {\n  readonly at: number\n  readonly resolve: () => void\n}\n\n/** Deterministic Clock implementation for tests. */\nexport class ClockTest implements Service.Contract<Clock> {\n  private currentTime: number\n\n  private readonly waiters: ClockWaiter[] = []\n\n  constructor(initial: Date | number = 0) {\n    this.currentTime = initial instanceof Date ? initial.getTime() : initial\n\n    if (!Number.isFinite(this.currentTime)) {\n      throw new RangeError('ClockTest time must be finite')\n    }\n  }\n\n  now(): Date {\n    return new Date(this.currentTime)\n  }\n\n  setTime(value: Date | number): void {\n    const next = value instanceof Date ? value.getTime() : value\n\n    if (!Number.isFinite(next)) {\n      throw new RangeError('ClockTest time must be finite')\n    }\n\n    this.currentTime = next\n    this.flushWaiters()\n  }\n\n  advance(milliseconds: number): void {\n    assertDelay(milliseconds)\n    this.currentTime += milliseconds\n    this.flushWaiters()\n  }\n\n  sleep(milliseconds: number): Promise<void> {\n    assertDelay(milliseconds)\n\n    return new Promise((resolve) => {\n      this.waiters.push({ at: this.currentTime + milliseconds, resolve })\n      this.flushWaiters()\n    })\n  }\n\n  static layer(initial: Date | number = 0) {\n    return Layer.succeed(Clock, new ClockTest(initial))\n  }\n\n  private flushWaiters(): void {\n    for (let index = this.waiters.length - 1; index >= 0; index--) {\n      const waiter = this.waiters[index]!\n\n      if (waiter.at <= this.currentTime) {\n        this.waiters.splice(index, 1)\n        waiter.resolve()\n      }\n    }\n  }\n}\n\nexport const ClockTestLayer = (initial: Date | number = 0) => ClockTest.layer(initial)\n\n/** Host-backed pseudo-random number service. */\nexport class Random extends Service<Random>()('Random') {\n  next(): number {\n    return Math.random()\n  }\n\n  nextInt(maxExclusive: number): number {\n    if (!Number.isInteger(maxExclusive) || maxExclusive <= 0) {\n      throw new RangeError('Random.nextInt maxExclusive must be a positive integer')\n    }\n\n    return Math.floor(this.next() * maxExclusive)\n  }\n}\n\n/** The default host Random provider. */\nexport const RandomLive = Layer.make(Random)\n\n/** Reproducible pseudo-random implementation with isolated mutable state. */\nexport class RandomSeeded implements Service.Contract<Random> {\n  private state: number\n\n  constructor(seed: number) {\n    if (!Number.isFinite(seed)) {\n      throw new RangeError('RandomSeeded seed must be finite')\n    }\n\n    this.state = seed >>> 0\n  }\n\n  next(): number {\n    this.state = (1664525 * this.state + 1013904223) >>> 0\n    return this.state / 0x1_0000_0000\n  }\n\n  nextInt(maxExclusive: number): number {\n    if (!Number.isInteger(maxExclusive) || maxExclusive <= 0) {\n      throw new RangeError('RandomSeeded.nextInt maxExclusive must be a positive integer')\n    }\n\n    return Math.floor(this.next() * maxExclusive)\n  }\n\n  static layer(seed: number) {\n    return Layer.succeed(Random, new RandomSeeded(seed))\n  }\n}\n\nexport const RandomSeededLayer = (seed: number) => RandomSeeded.layer(seed)\n\nexport type LoggerLevel = 'debug' | 'info' | 'warn' | 'error'\n\nexport type LoggerEvent = {\n  level: LoggerLevel\n  message: string\n  data?: LoggerData\n}\n\nexport type LoggerData =\n  | string\n  | number\n  | boolean\n  | bigint\n  | null\n  | readonly LoggerData[]\n  | { readonly [key: string]: LoggerData }\ntype LoggerInput = LoggerEvent | LoggerLevel\n\nconst isLoggerLevel = (value: LoggerInput): value is LoggerLevel =>\n  value === 'debug' || value === 'info' || value === 'warn' || value === 'error'\n\nconst toLoggerEvent = (input: LoggerInput, message?: string, data?: LoggerData): LoggerEvent => {\n  if (!isLoggerLevel(input)) {\n    return input\n  }\n\n  const event: LoggerEvent = { level: input, message: message ?? '' }\n\n  if (data !== undefined) {\n    event.data = data\n  }\n\n  return event\n}\n\n/** Structured host logger bridge. */\nexport class Logger extends Service<Logger>()('Logger') {\n  log(event: LoggerEvent): void\n  log(level: LoggerLevel, message: string, data?: LoggerData): void\n  log(first: LoggerInput, message?: string, data?: LoggerData): void {\n    const event = toLoggerEvent(first, message, data)\n\n    const write = console[event.level]\n\n    if (event.data === undefined) {\n      write.call(console, event.message)\n    } else {\n      write.call(console, event.message, event.data)\n    }\n  }\n\n  debug(message: string, data?: LoggerData): void {\n    this.log('debug', message, data)\n  }\n\n  info(message: string, data?: LoggerData): void {\n    this.log('info', message, data)\n  }\n\n  warn(message: string, data?: LoggerData): void {\n    this.log('warn', message, data)\n  }\n\n  error(message: string, data?: LoggerData): void {\n    this.log('error', message, data)\n  }\n}\n\n/** The default host Logger provider. */\nexport const LoggerLive = Layer.make(Logger)\n\n/** Ordered in-memory Logger implementation for tests. */\nexport class LoggerTest implements Service.Contract<Logger> {\n  readonly events: LoggerEvent[] = []\n\n  log(event: LoggerEvent): void\n  log(level: LoggerLevel, message: string, data?: LoggerData): void\n  log(first: LoggerInput, message?: string, data?: LoggerData): void {\n    const event = toLoggerEvent(first, message, data)\n\n    this.events.push(event)\n  }\n\n  debug(message: string, data?: LoggerData): void {\n    this.log('debug', message, data)\n  }\n\n  info(message: string, data?: LoggerData): void {\n    this.log('info', message, data)\n  }\n\n  warn(message: string, data?: LoggerData): void {\n    this.log('warn', message, data)\n  }\n\n  error(message: string, data?: LoggerData): void {\n    this.log('error', message, data)\n  }\n\n  clear(): void {\n    this.events.length = 0\n  }\n\n  static make() {\n    const logger = new LoggerTest()\n    return { logger, layer: Layer.succeed(Logger, logger) }\n  }\n\n  static layer(logger: LoggerTest = new LoggerTest()) {\n    return Layer.succeed(Logger, logger)\n  }\n}\n\nexport const LoggerTestLayer = () => LoggerTest.layer()\n\n/** Execution-local request value carried by a normal Service provider. */\nexport class CurrentRequest extends Service<CurrentRequest>()('CurrentRequest') {\n  readonly request: unknown\n\n  // oxlint-disable-next-line anti-slop/no-unknown-parameters\n  constructor(readonly value: unknown) {\n    super()\n    this.request = value\n  }\n\n  // oxlint-disable-next-line anti-slop/no-unknown-parameters\n  static layer(value: unknown) {\n    return Layer.succeed(CurrentRequest, new CurrentRequest(value))\n  }\n}\n\n// oxlint-disable-next-line anti-slop/no-unknown-parameters\nexport const CurrentRequestLayer = (value: unknown) => CurrentRequest.layer(value)\n"],"mappings":"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"}

package/dist/testing.mjs

@@ -1,2 +1,2 @@
-import { t as MapLayerBackend } from "./map-layer-backend-BodcEeNA.mjs";
+import { t as MapLayerBackend } from "./map-layer-backend-gal-mcRv.mjs";
 export { MapLayerBackend as MemoryLayerBackend };