better-effect 0.5.0 → 0.6.1

package/dist/index.mjs

@@ -1,4 +1,6 @@
-import { a as ServiceTagCollisionError, i as LayerRegistrationError, n as LayerDisposeError, o as ServiceNotFoundError, r as LayerGeneratorYieldError, s as ServiceRuntimeNotConfiguredError, t as DuplicateServiceError } from "./errors-GR3K_nRu.mjs";
+import { a as LayerRegistrationError, c as ServiceAcquisitionError, i as LayerGeneratorYieldError, l as ServiceNotFoundError, n as DuplicateServiceError, o as ServiceTagCollisionError, r as LayerDisposeError, s as CircularDependencyError, u as ServiceRuntimeNotConfiguredError } from "./internal-identity-Cm4-KIUj.mjs";
+import { t as MapLayerBackend } from "./map-layer-backend-BodcEeNA.mjs";
+import { t as isPromiseLike } from "./runtime-CDcCF5cb.mjs";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { Result, TaggedError } from "better-result";
 //#region src/service/runtime.ts
@@ -136,101 +138,48 @@ var Layer = class Layer {
 		const defaultAcquire = () => {
 			return new service();
 		};
+		const normalizedAcquire = normalizeAcquire(acquire ?? defaultAcquire);
 		return new Layer([{
 			service,
-			acquire: acquire ?? defaultAcquire
+			acquire: normalizedAcquire
 		}]);
 	}
-	/**
-	* Create a Layer from an already-constructed Service instance.
-	*
-	* The instance is returned as-is whenever the Service is resolved.
-	*
-	* @example
-	* ```ts
-	* const DatabaseLive = Layer.succeed(Database, database)
-	* ```
-	*/
+	/** Create a Layer from an already-constructed Service instance. */
 	static succeed(service, instance) {
-		return Layer.make(service, () => instance);
+		const normalizedAcquire = normalizeAcquire(() => instance);
+		return new Layer([{
+			service,
+			acquire: normalizedAcquire
+		}]);
 	}
-	/**
-	* Define a provider with Runtime-root cleanup.
-	*
-	* The release callback intentionally keeps its compatibility-friendly
-	* one-argument shape and runs when the owning Runtime is disposed. Use
-	* `scopedGen` when acquisition needs contextual Services or cleanup needs
-	* `ScopeOutcome`.
-	*
-	* @example
-	* ```ts
-	* const DatabaseLive = Layer.scoped(
-	*   Database,
-	*   () => openDatabase(),
-	*   (database) => database.close()
-	* )
-	* ```
-	*/
+	/** Define a provider with Runtime-root cleanup. */
 	static scoped(service, acquire, release) {
 		return new Layer([{
 			service,
-			acquire,
-			release: (instance) => release(instance)
+			acquire: normalizeAcquire(acquire),
+			release: (instance, outcome) => {
+				return release(instance, outcome);
+			}
 		}]);
 	}
-	/**
-	* Define a provider whose acquisition can yield contextual Services.
-	*
-	* The release callback receives the acquired instance and the final
-	* `ScopeOutcome` selected by the owning Runtime.
-	*
-	* @example
-	* ```ts
-	* const RepositoryLive = Layer.scopedGen(
-	*   UserRepository,
-	*   async function* () {
-	*     const database = yield* Database
-	*     return new UserRepository(database)
-	*   },
-	*   (repository, outcome) => repository.close(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) => release(instance, outcome)
+			release: (instance, outcome) => {
+				return release(instance, outcome);
+			}
 		}]);
 	}
-	/**
-	* Define a provider whose acquisition can yield contextual Services.
-	*
-	* Unlike `scopedGen`, this variant has no release callback. Use it for
-	* providers whose lifetime is managed elsewhere or that need no cleanup.
-	*
-	* @example
-	* ```ts
-	* const RepositoryLive = Layer.gen(UserRepository, async function* () {
-	*   const database = yield* Database
-	*   return new UserRepository(database)
-	* })
-	* ```
-	*/
+	/** Define a provider whose acquisition can yield contextual Services. */
 	static gen(service, factory) {
-		return Layer.make(service, () => runLayerGenerator(service, factory));
+		return new Layer([{
+			service,
+			acquire: () => runLayerGenerator(service, factory)
+		}]);
 	}
-	/**
-	* Compose Layers without replacing providers.
-	*
-	* Each Service tag may appear only once. Duplicate tags are rejected at
-	* runtime; use `override` when replacement is intentional.
-	*
-	* @example
-	* ```ts
-	* const AppLive = Layer.merge(DatabaseLive, RepositoryLive)
-	* ```
-	*/
+	/** Compose Layers without replacing providers. */
 	static merge(...layers) {
 		const providers = /* @__PURE__ */ new Map();
 		for (const layer of layers) for (const provider of layer.providers) {
@@ -244,19 +193,7 @@ var Layer = class Layer {
 		}
 		return new Layer([...providers.values()]);
 	}
-	/**
-	* Replace providers in a base Layer, using tag identity and compatible
-	* instance contracts.
-	*
-	* Overrides are applied from left to right; the last compatible provider for
-	* a tag wins. Incompatible same-tag replacements remain visible as a type
-	* diagnostic and cannot be passed as a complete Layer.
-	*
-	* @example
-	* ```ts
-	* const TestLive = Layer.override(AppLive, Layer.succeed(Database, fakeDb))
-	* ```
-	*/
+	/** 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);
@@ -264,6 +201,9 @@ var Layer = class Layer {
 		return new Layer([...providers.values()]);
 	}
 };
+const normalizeAcquire = (acquire) => () => {
+	return acquire();
+};
 //#endregion
 //#region src/scope/errors.ts
 /** Thrown when Scope context is accessed outside an active Scope execution. */
@@ -303,9 +243,9 @@ const SCOPE_SUCCESS$2 = { status: "success" };
 const getDisposeFinalizer = (resource) => {
 	const candidate = Object(resource);
 	const asyncDispose = candidate[Symbol.asyncDispose];
-	if (typeof asyncDispose === "function") return () => asyncDispose.call(resource);
+	if (asyncDispose instanceof Function) return () => asyncDispose.call(resource);
 	const dispose = candidate[Symbol.dispose];
-	if (typeof dispose === "function") return () => dispose.call(resource);
+	if (dispose instanceof Function) return () => dispose.call(resource);
 };
 /** Dispose a value immediately when it implements a disposal protocol. */
 const disposeResource = (resource) => {
@@ -504,40 +444,79 @@ const Scope = {
 };
 //#endregion
 //#region src/effect/combinators.ts
-const isPromiseLike = (value) => {
-	if (typeof value !== "object" && typeof value !== "function" || value === null) return false;
-	return "then" in value && typeof value.then === "function";
-};
-const mapResult = (result, fn) => Result.map(result, fn);
-const mapErrorResult = (result, fn) => Result.mapError(result, fn);
-const andThenResult = (result, next) => Result.andThen(result, next);
-const andThenAsyncResult = (result, next) => Result.andThenAsync(result, (value) => Promise.resolve(next(value)));
+const mapResult = (result, fn) => {
+	return Result.map(result, fn);
+};
+const mapErrorResult = (result, fn) => {
+	return Result.mapError(result, fn);
+};
+const andThenResult = (result, next) => {
+	const resultNext = next;
+	return Result.andThen(result, resultNext);
+};
+const andThenAsyncResult = (result, next) => {
+	const resultNext = (value) => {
+		return Promise.resolve(next(value));
+	};
+	return Result.andThenAsync(result, resultNext);
+};
 function map(first, second) {
-	if (typeof first === "function" && second === void 0) return (effect) => map(effect, first);
+	if (first instanceof Function && second === void 0) {
+		const callback = first;
+		return (effect) => {
+			return map(effect, callback);
+		};
+	}
 	const fn = second;
-	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => mapResult(result, fn));
+	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => {
+		return mapResult(result, fn);
+	});
 	return mapResult(first, fn);
 }
 function mapError(first, second) {
-	if (typeof first === "function" && second === void 0) return (effect) => mapError(effect, first);
+	if (first instanceof Function && second === void 0) {
+		const callback = first;
+		return (effect) => {
+			return mapError(effect, callback);
+		};
+	}
 	const fn = second;
-	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => mapErrorResult(result, fn));
+	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => {
+		return mapErrorResult(result, fn);
+	});
 	return mapErrorResult(first, fn);
 }
 function andThen(first, second) {
-	if (typeof first === "function" && second === void 0) return (effect) => andThen(effect, first);
+	if (first instanceof Function && second === void 0) {
+		const callback = first;
+		return (effect) => {
+			return andThen(effect, callback);
+		};
+	}
 	return andThenResult(first, second);
 }
 function andThenAsync(first, second) {
-	if (typeof first === "function" && second === void 0) return (effect) => andThenAsync(effect, first);
+	if (first instanceof Function && second === void 0) {
+		const callback = first;
+		return (effect) => {
+			return andThenAsync(effect, callback);
+		};
+	}
 	const next = second;
-	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => andThenAsyncResult(result, next));
+	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => {
+		return andThenAsyncResult(result, next);
+	});
 	return andThenAsyncResult(first, next);
 }
 //#endregion
 //#region src/effect/effect.ts
+const runResultGenerator = Result.gen;
 function gen(body) {
-	return Result.gen(body);
+	return runResultGenerator(body);
+}
+function fn(body) {
+	const program = () => runResultGenerator(body);
+	return program;
 }
 /**
 * Acquire a resource in the current Scope and register its release callback.
@@ -583,6 +562,8 @@ function add(resource) {
 const Effect = {
 	/** Compose a generator-based Effect program. */
 	gen,
+	/** Build a lazy Program from a generator. */
+	fn,
 	/** Acquire and register a resource in the current Scope. */
 	acquireRelease,
 	/** Register an already-acquired disposable in the current Scope. */
@@ -680,7 +661,10 @@ const Resource = {
 acquireUseRelease };
 //#endregion
 //#region src/runtime/outcome.ts
-const isResultLike = (value) => typeof value === "object" && value !== null && "status" in value && (value.status === "ok" || value.status === "error");
+const isResultLike = (value) => {
+	const candidate = Object(value);
+	return Object.prototype.toString.call(value) !== "[object Function]" && "status" in candidate && (candidate.status === "ok" || candidate.status === "error");
+};
 const classifyRuntimeOutcome = (value) => {
 	if (isResultLike(value) && Result.isError(value)) return {
 		status: "failure",
@@ -689,6 +673,33 @@ const classifyRuntimeOutcome = (value) => {
 	return { status: "success" };
 };
 //#endregion
+//#region src/layer/resolution.ts
+const resolutionStorage = new AsyncLocalStorage();
+const findCycleStart = (path, token) => path.findIndex((current) => current.serviceTag === token.serviceTag);
+const shouldPreserve = (cause) => cause instanceof CircularDependencyError || cause instanceof ServiceAcquisitionError || cause instanceof ServiceNotFoundError || cause instanceof ServiceTagCollisionError;
+/** Wrap a backend with Runtime-local resolution paths and acquisition errors. */
+const createResolutionResolver = (resolver) => {
+	const wrapped = { async resolve(token) {
+		const context = resolutionStorage.getStore();
+		const path = context?.resolver === wrapped ? context.path : [];
+		const cycleStart = findCycleStart(path, token);
+		if (cycleStart >= 0) throw new CircularDependencyError([...path.slice(cycleStart), token]);
+		const resolutionPath = [...path, token];
+		return await resolutionStorage.run({
+			resolver: wrapped,
+			path: resolutionPath
+		}, async () => {
+			try {
+				return await resolver.resolve(token);
+			} catch (cause) {
+				if (shouldPreserve(cause)) throw cause;
+				throw new ServiceAcquisitionError(token, resolutionPath, cause);
+			}
+		});
+	} };
+	return wrapped;
+};
+//#endregion
 //#region src/layer/runtime.ts
 const SCOPE_SUCCESS = Object.freeze({ status: "success" });
 var RuntimeHandleDisposedError = class extends Error {
@@ -716,13 +727,15 @@ const bindProviderToScope = (provider, rootScope) => ({
 });
 var RuntimeHandleImpl = class {
 	backend;
+	resolver;
 	rootScope;
 	onCleanupFailure;
 	disposePromise;
 	executions = /* @__PURE__ */ new Set();
 	state = "active";
-	constructor(backend, rootScope, onCleanupFailure) {
+	constructor(backend, resolver, rootScope, onCleanupFailure) {
 		this.backend = backend;
+		this.resolver = resolver;
 		this.rootScope = rootScope;
 		this.onCleanupFailure = onCleanupFailure;
 	}
@@ -757,7 +770,7 @@ var RuntimeHandleImpl = class {
 			classify: classifyRuntimeOutcome,
 			onCleanupFailure: this.onCleanupFailure
 		} : { classify: classifyRuntimeOutcome };
-		return runScoped(executionScope, () => ServiceRuntime.run(this.backend, program), options);
+		return runScoped(executionScope, () => ServiceRuntime.run(this.resolver, program), options);
 	}
 	dispose(outcome = SCOPE_SUCCESS) {
 		if (this.disposePromise) return this.disposePromise;
@@ -770,7 +783,7 @@ var RuntimeHandleImpl = class {
 		const failures = [];
 		await Promise.allSettled(executions);
 		try {
-			await ServiceRuntime.run(this.backend, () => this.rootScope.close(outcome));
+			await ServiceRuntime.run(this.resolver, () => this.rootScope.close(outcome));
 		} catch (cause) {
 			failures.push(cause);
 		}
@@ -796,6 +809,7 @@ var RuntimeHandleImpl = class {
 /** Build a Runtime handle for a complete Layer and register its providers. */
 const createRuntimeHandle = async (layer, backend, options = {}) => {
 	const rootScope = Scope.make();
+	const resolver = createResolutionResolver(backend);
 	let current;
 	try {
 		for (const provider of layer.providers) {
@@ -809,7 +823,7 @@ const createRuntimeHandle = async (layer, backend, options = {}) => {
 		};
 		const cleanupCauses = [];
 		try {
-			await ServiceRuntime.run(backend, () => rootScope.close(outcome));
+			await ServiceRuntime.run(resolver, () => rootScope.close(outcome));
 		} catch (cause) {
 			cleanupCauses.push(cause);
 		}
@@ -825,15 +839,25 @@ const createRuntimeHandle = async (layer, backend, options = {}) => {
 				error: shutdownError
 			});
 		}
-		let cleanupCause;
-		if (cleanupCauses.length === 1) cleanupCause = cleanupCauses[0];
-		else if (cleanupCauses.length > 1) cleanupCause = new LayerDisposeError(cleanupCauses.flatMap(normalizeDisposeCauses));
+		const cleanupCause = cleanupCauses.length === 1 ? cleanupCauses[0] : cleanupCauses.length > 1 ? new LayerDisposeError(cleanupCauses.flatMap(normalizeDisposeCauses)) : void 0;
 		throw new LayerRegistrationError(current?.service, registrationCause, cleanupCause);
 	}
-	return new RuntimeHandleImpl(backend, rootScope, options.onCleanupFailure);
+	return new RuntimeHandleImpl(backend, resolver, rootScope, options.onCleanupFailure);
 };
 //#endregion
 //#region src/runtime/runtime.ts
+const isLayerBackend = (value) => value !== void 0 && "register" in value && "resolve" in value && "disposeAll" in value;
+const resolveRuntimeConfig = (backendOrOptions, legacyOptions) => {
+	if (isLayerBackend(backendOrOptions)) return {
+		backend: backendOrOptions,
+		options: legacyOptions ?? {}
+	};
+	const options = backendOrOptions ?? {};
+	return {
+		backend: options.backend ?? new MapLayerBackend(),
+		options
+	};
+};
 /**
 * Long-lived execution environment backed by a complete Layer.
 *
@@ -842,40 +866,38 @@ const createRuntimeHandle = async (layer, backend, options = {}) => {
 *
 * @example
 * ```ts
-* const runtime = await Runtime.make(AppLive, new MemoryLayerBackend())
+* const runtime = await Runtime.make(AppLive)
 * const result = await runtime.run(loadUser('u1'))
 * await runtime.dispose()
 * ```
 *
-* @typeParam Provided The Service constructors supplied by the Layer.
+* @typeParam Provided The branded Service instances supplied by the Layer.
 */
 var Runtime = class Runtime {
 	handle;
 	constructor(handle) {
 		this.handle = handle;
 	}
-	/**
-	* Create a long-lived Runtime that owns its Layer resources.
-	*
-	* @example
-	* ```ts
-	* const runtime = await Runtime.make(AppLive, backend)
-	* const result = await runtime.run(program)
-	* await runtime.dispose()
-	* ```
-	*/
-	static async make(layer, backend, options = {}) {
+	static async make(layer, backendOrOptions, legacyOptions) {
+		const { backend, options } = resolveRuntimeConfig(backendOrOptions, legacyOptions);
 		const handle = await createRuntimeHandle(layer, backend, options);
 		return new Runtime(handle);
 	}
-	/**
-	* Run one program and dispose its Layer resources before resolving.
-	*
-	* This is convenient for request-style or command-style execution where a
-	* Runtime should not outlive the operation.
-	*/
-	static async run(layer, backend, program, options = {}) {
-		const runtime = await Runtime.make(layer, backend, options);
+	static async run(layer, backendOrProgramOrOptions, programOrOptions, legacyOptions) {
+		let program;
+		let backendOrOptions;
+		let options;
+		if (typeof backendOrProgramOrOptions === "function") {
+			program = backendOrProgramOrOptions;
+			backendOrOptions = programOrOptions;
+			options = void 0;
+		} else {
+			backendOrOptions = backendOrProgramOrOptions;
+			program = programOrOptions;
+			options = legacyOptions;
+		}
+		const config = resolveRuntimeConfig(backendOrOptions, options);
+		const runtime = await Runtime.make(layer, config.backend, config.options);
 		let value;
 		let executionFailed = false;
 		let executionFailure;
@@ -926,6 +948,6 @@ var Runtime = class Runtime {
 	}
 };
 //#endregion
-export { DuplicateServiceError, Effect, Layer, LayerDisposeError, LayerGeneratorYieldError, LayerRegistrationError, Resource, ResourceNotDisposableError, ResourceReleaseFailure, Runtime, Scope, ScopeCloseError, ScopeClosedError, ScopeRuntimeNotConfiguredError, Service, ServiceNotFoundError, ServiceRuntime, ServiceRuntimeNotConfiguredError, ServiceTagCollisionError, pipe };
+export { CircularDependencyError, DuplicateServiceError, Effect, Layer, LayerDisposeError, LayerGeneratorYieldError, LayerRegistrationError, MapLayerBackend, Resource, ResourceNotDisposableError, ResourceReleaseFailure, Runtime, Scope, ScopeCloseError, ScopeClosedError, ScopeRuntimeNotConfiguredError, Service, ServiceAcquisitionError, ServiceNotFoundError, ServiceRuntime, ServiceRuntimeNotConfiguredError, ServiceTagCollisionError, pipe };
 
 //# sourceMappingURL=index.mjs.map