better-effect 0.7.0 → 0.8.0

package/dist/index.mjs

@@ -702,24 +702,110 @@ const classifyRuntimeOutcome = (value) => {
 	return { status: "success" };
 };
 //#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
+//#region src/runtime/observer.ts
+const notifyRuntimeObservers = (observers, select, event) => {
+	for (const observer of observers) {
+		const callback = select(observer);
+		if (!callback) continue;
+		try {
+			Promise.resolve(callback(event)).catch(() => {});
+		} catch {}
+	}
+};
+//#endregion
 //#region src/layer/resolution.ts
 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, storage = defaultRuntimeContextStorage) => {
+const createResolutionResolver = (resolver, storage = defaultRuntimeContextStorage, observers = []) => {
 	const wrapped = { async resolve(token) {
 		const context = getRuntimeContext(storage);
-		const path = context?.resolver === wrapped ? context.resolutionPath : [];
+		const path = context?.resolutionPath ?? [];
 		const cycleStart = findCycleStart(path, token);
-		if (cycleStart >= 0) throw new CircularDependencyError([...path.slice(cycleStart), token]);
 		const resolutionPath = [...path, token];
+		const notifyResolve = (outcome) => {
+			notifyRuntimeObservers(observers, (observer) => observer.onServiceResolve, {
+				service: token,
+				resolutionPath,
+				outcome
+			});
+		};
+		if (cycleStart >= 0) {
+			const error = new CircularDependencyError([...path.slice(cycleStart), token]);
+			notifyResolve({
+				status: "failure",
+				cause: error
+			});
+			throw error;
+		}
 		const nextContext = makeRuntimeContext(wrapped, context?.scope, resolutionPath, context?.signal);
 		return await runRuntimeContext(storage, nextContext, async () => {
 			try {
-				return await resolver.resolve(token);
+				const instance = await resolver.resolve(token);
+				notifyResolve({ status: "success" });
+				return instance;
 			} catch (cause) {
-				if (shouldPreserve(cause)) throw cause;
-				throw new ServiceAcquisitionError(token, resolutionPath, cause);
+				if (shouldPreserve(cause)) {
+					notifyResolve({
+						status: "failure",
+						cause
+					});
+					throw cause;
+				}
+				const error = new ServiceAcquisitionError(token, resolutionPath, cause);
+				notifyResolve({
+					status: "failure",
+					cause: error
+				});
+				throw error;
 			}
 		});
 	} };
@@ -738,19 +824,83 @@ const normalizeDisposeCauses = (cause) => {
 	if (cause instanceof AggregateError) return [...cause.errors];
 	return [cause];
 };
+const isScopeOutcome = (input) => input !== void 0 && "status" in input;
+const validateDisposeOptions = (options) => {
+	const { gracePeriod } = options;
+	if (gracePeriod !== void 0 && (!Number.isFinite(gracePeriod) || gracePeriod < 0)) throw new RangeError("Runtime dispose gracePeriod must be a finite non-negative number");
+};
 const notifyShutdownFailure = async (observer, diagnostic) => {
 	if (!observer) return;
 	try {
 		await observer(diagnostic);
 	} catch {}
 };
-const bindProviderToScope = (provider, rootScope, contextStorage) => ({
+const bindProviderToScope = (provider, scope, contextStorage, resolver, observers) => ({
 	service: provider.service,
-	acquire: () => ScopeRuntime.run(rootScope, async () => {
-		if (!provider.release) return await provider.acquire();
-		return await rootScope.acquire(() => provider.acquire(), (resource, outcome) => provider.release(resource, outcome));
-	}, contextStorage)
+	acquire: () => {
+		const current = getRuntimeContext(contextStorage);
+		const context = makeRuntimeContext(resolver, scope, current?.resolutionPath ?? [], current?.signal);
+		return runRuntimeContext(contextStorage, context, () => ScopeRuntime.run(scope, async () => {
+			const resolutionPath = current?.resolutionPath ?? [provider.service];
+			try {
+				const instance = provider.release ? await scope.acquire(() => provider.acquire(), async (resource, outcome) => {
+					try {
+						await provider.release(resource, outcome);
+						notifyRuntimeObservers(observers, (observer) => observer.onResourceRelease, {
+							service: provider.service,
+							outcome
+						});
+					} catch (cause) {
+						notifyRuntimeObservers(observers, (observer) => observer.onResourceRelease, {
+							service: provider.service,
+							outcome,
+							error: cause
+						});
+						throw cause;
+					}
+				}) : await provider.acquire();
+				notifyRuntimeObservers(observers, (observer) => observer.onServiceAcquire, {
+					service: provider.service,
+					resolutionPath,
+					outcome: SCOPE_SUCCESS
+				});
+				return instance;
+			} catch (cause) {
+				notifyRuntimeObservers(observers, (observer) => observer.onServiceAcquire, {
+					service: provider.service,
+					resolutionPath,
+					outcome: {
+						status: "failure",
+						cause
+					}
+				});
+				throw cause;
+			}
+		}, contextStorage));
+	}
 });
+/** Resolve request-local providers first, then fall back to the Runtime root. */
+var ExecutionLayerBackend = class {
+	local;
+	root;
+	localTags = /* @__PURE__ */ new Set();
+	constructor(local, root) {
+		this.local = local;
+		this.root = root;
+	}
+	register(registration) {
+		this.localTags.add(registration.service.serviceTag);
+		this.local.register(registration);
+	}
+	async resolve(token) {
+		if (this.localTags.has(token.serviceTag)) return await this.local.resolve(token);
+		return await this.root.resolve(token);
+	}
+	async disposeAll() {
+		await this.local.disposeAll();
+		this.localTags.clear();
+	}
+};
 var RuntimeHandleImpl = class {
 	backend;
 	resolver;
@@ -758,34 +908,79 @@ var RuntimeHandleImpl = class {
 	onCleanupFailure;
 	contextStorage;
 	signal;
+	observers;
+	services;
 	disposePromise;
+	warmupPromise;
 	executions = /* @__PURE__ */ new Set();
+	shutdownController = new AbortController();
 	state = "active";
-	constructor(backend, resolver, rootScope, onCleanupFailure, contextStorage, signal) {
+	constructor(backend, resolver, rootScope, onCleanupFailure, contextStorage, signal, observers, services) {
 		this.backend = backend;
 		this.resolver = resolver;
 		this.rootScope = rootScope;
 		this.onCleanupFailure = onCleanupFailure;
 		this.contextStorage = contextStorage;
 		this.signal = signal;
+		this.observers = observers;
+		this.services = services;
 	}
-	run(program) {
+	run(program, options) {
+		this.assertActive();
+		const executionScope = this.rootScope.fork();
+		const signalLink = linkAbortSignals(this.signal, options?.signal, this.shutdownController.signal);
+		return this.startExecution(signalLink, () => this.runExecution(executionScope, program, this.resolver, signalLink.signal));
+	}
+	runWith(layer, program, options) {
 		this.assertActive();
 		const executionScope = this.rootScope.fork();
+		const localBackend = new MapLayerBackend();
+		const backend = new ExecutionLayerBackend(localBackend, this.backend);
+		const resolver = createResolutionResolver(backend, this.contextStorage, this.observers);
+		const signalLink = linkAbortSignals(this.signal, options?.signal, this.shutdownController.signal);
+		return this.startExecution(signalLink, async () => {
+			try {
+				return await this.runExecution(executionScope, async () => {
+					for (const provider of layer.providers) backend.register(bindProviderToScope(provider, executionScope, this.contextStorage, resolver, this.observers));
+					return await program();
+				}, resolver, signalLink.signal);
+			} finally {
+				await localBackend.disposeAll();
+			}
+		});
+	}
+	warmup() {
+		this.assertActive();
+		if (this.warmupPromise) return this.warmupPromise;
+		const warmup = runRuntimeContext(this.contextStorage, makeRuntimeContext(this.resolver, this.rootScope, [], this.signal), async () => {
+			for (const service of this.services) await this.resolver.resolve(service);
+		});
+		this.warmupPromise = warmup;
+		warmup.then(() => {
+			if (this.warmupPromise === warmup) this.warmupPromise = void 0;
+		}, () => {
+			if (this.warmupPromise === warmup) this.warmupPromise = void 0;
+		});
+		return warmup;
+	}
+	startExecution(signalLink, run) {
 		let resolveExecution;
 		let rejectExecution;
 		const execution = new Promise((resolve, reject) => {
 			resolveExecution = resolve;
 			rejectExecution = reject;
 		});
-		this.executions.add(execution);
+		const activeExecution = { promise: execution };
+		this.executions.add(activeExecution);
 		execution.then(() => {
-			this.executions.delete(execution);
+			this.executions.delete(activeExecution);
+			signalLink.dispose();
 		}, () => {
-			this.executions.delete(execution);
+			this.executions.delete(activeExecution);
+			signalLink.dispose();
 		});
 		try {
-			this.runExecution(executionScope, program).then((value) => {
+			run().then((value) => {
 				resolveExecution(value);
 			}, (cause) => {
 				rejectExecution(cause);
@@ -795,29 +990,54 @@ var RuntimeHandleImpl = class {
 		}
 		return execution;
 	}
-	runExecution(executionScope, program) {
+	runExecution(executionScope, program, resolver = this.resolver, signal = this.shutdownController.signal) {
 		const options = this.onCleanupFailure ? {
 			classify: classifyRuntimeOutcome,
 			onCleanupFailure: this.onCleanupFailure
 		} : { classify: classifyRuntimeOutcome };
+		notifyRuntimeObservers(this.observers, (observer) => observer.onExecutionStart, { scope: executionScope });
 		return runScoped(executionScope, program, {
 			...options,
 			contextStorage: this.contextStorage,
-			context: makeRuntimeContext(this.resolver, executionScope, [], this.signal)
+			context: makeRuntimeContext(resolver, executionScope, [], signal)
+		}).then((value) => {
+			notifyRuntimeObservers(this.observers, (observer) => observer.onExecutionEnd, {
+				scope: executionScope,
+				outcome: classifyRuntimeOutcome(value)
+			});
+			return value;
+		}, (cause) => {
+			notifyRuntimeObservers(this.observers, (observer) => observer.onExecutionEnd, {
+				scope: executionScope,
+				outcome: {
+					status: "failure",
+					cause
+				}
+			});
+			throw cause;
 		});
 	}
-	dispose(outcome = SCOPE_SUCCESS) {
+	dispose(input) {
 		if (this.disposePromise) return this.disposePromise;
+		const outcome = isScopeOutcome(input) || input === void 0 ? input ?? SCOPE_SUCCESS : SCOPE_SUCCESS;
+		const options = isScopeOutcome(input) || input === void 0 ? {} : input;
+		validateDisposeOptions(options);
 		this.state = "disposing";
 		const executions = [...this.executions];
-		this.disposePromise = this.performDispose(executions, outcome);
+		this.disposePromise = this.performDispose(executions, outcome, options);
 		return this.disposePromise;
 	}
-	async performDispose(executions, outcome) {
+	async performDispose(executions, outcome, options) {
 		const failures = [];
-		await Promise.allSettled(executions);
+		await Promise.allSettled(this.warmupPromise ? [this.warmupPromise] : []);
+		await this.waitForExecutions(executions, options);
 		try {
-			await runRuntimeContext(this.contextStorage, makeRuntimeContext(this.resolver, this.rootScope, [], this.signal), () => this.rootScope.close(outcome));
+			const signalLink = linkAbortSignals(this.signal, this.shutdownController.signal);
+			try {
+				await runRuntimeContext(this.contextStorage, makeRuntimeContext(this.resolver, this.rootScope, [], signalLink.signal), () => this.rootScope.close(outcome));
+			} finally {
+				signalLink.dispose();
+			}
 		} catch (cause) {
 			failures.push(cause);
 		}
@@ -836,6 +1056,21 @@ var RuntimeHandleImpl = class {
 			throw error;
 		}
 	}
+	async waitForExecutions(executions, options) {
+		const settled = Promise.allSettled(executions.map((execution) => execution.promise));
+		if (options.abortAfterGracePeriod !== true || executions.length === 0) {
+			await settled;
+			return;
+		}
+		const gracePeriod = options.gracePeriod ?? 0;
+		let timer;
+		const timedOut = await Promise.race([settled.then(() => false), new Promise((resolve) => {
+			timer = setTimeout(() => resolve(true), gracePeriod);
+		})]);
+		if (timer !== void 0) clearTimeout(timer);
+		if (timedOut && !this.shutdownController.signal.aborted) this.shutdownController.abort(/* @__PURE__ */ new Error("Runtime shutdown grace period exceeded"));
+		await settled;
+	}
 	assertActive() {
 		if (this.state !== "active") throw new RuntimeHandleDisposedError();
 	}
@@ -844,13 +1079,14 @@ var RuntimeHandleImpl = class {
 const createRuntimeHandle = async (layer, backend, options = {}) => {
 	const rootScope = Scope.make();
 	const contextStorage = options.contextStorage ?? defaultRuntimeContextStorage;
-	const resolver = createResolutionResolver(backend, contextStorage);
+	const observers = options.observers ?? [];
+	const resolver = createResolutionResolver(backend, contextStorage, observers);
 	ScopeRuntime.bind(rootScope, contextStorage);
 	let current;
 	try {
 		for (const provider of layer.providers) {
 			current = provider;
-			await backend.register(bindProviderToScope(provider, rootScope, contextStorage));
+			await backend.register(bindProviderToScope(provider, rootScope, contextStorage, resolver, observers));
 		}
 	} catch (registrationCause) {
 		const outcome = {
@@ -878,7 +1114,7 @@ const createRuntimeHandle = async (layer, backend, options = {}) => {
 		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, resolver, rootScope, options.onCleanupFailure, contextStorage, options.signal);
+	return new RuntimeHandleImpl(backend, resolver, rootScope, options.onCleanupFailure, contextStorage, options.signal, observers, layer.providers.map((provider) => provider.service));
 };
 //#endregion
 //#region src/runtime/runtime.ts
@@ -917,7 +1153,9 @@ var Runtime = class Runtime {
 	static async make(layer, backendOrOptions, legacyOptions) {
 		const { backend, options } = resolveRuntimeConfig(backendOrOptions, legacyOptions);
 		const handle = await createRuntimeHandle(layer, backend, options);
-		return new Runtime(handle);
+		const runtime = new Runtime(handle);
+		if (options.warmup) await runtime.warmup();
+		return runtime;
 	}
 	static async run(layer, backendOrProgramOrOptions, programOrOptions, legacyOptions) {
 		let program;
@@ -997,16 +1235,33 @@ var Runtime = class Runtime {
 		if (executionFailed) throw executionFailure;
 		return value;
 	}
+	/** Resolve every Layer provider and dispose the Runtime if warmup fails. */
+	async warmup() {
+		try {
+			await this.handle.warmup();
+		} catch (cause) {
+			try {
+				await this.handle.dispose({
+					status: "failure",
+					cause
+				});
+			} catch {}
+			throw cause;
+		}
+	}
 	/** Run one execution in this Runtime's child Scope. */
-	run(program) {
-		return this.handle.run(program);
+	run(program, options) {
+		return this.handle.run(program, options);
+	}
+	/** Run one execution with a Layer owned by that execution's child Scope. */
+	runWith(layer, program, options) {
+		return this.handle.runWith(layer, program, options);
 	}
 	runUnchecked(program) {
 		return this.handle.run(program);
 	}
-	/** Stop new executions and release the Runtime's Layer resources. */
-	dispose() {
-		return this.handle.dispose();
+	dispose(optionsOrOutcome) {
+		return this.handle.dispose(optionsOrOutcome);
 	}
 	/** Release Runtime-owned resources through JavaScript's async disposal protocol. */
 	async [Symbol.asyncDispose]() {
@@ -1017,6 +1272,6 @@ var Runtime = class Runtime {
 	}
 };
 //#endregion
-export { CircularDependencyError, DuplicateServiceError, Effect, Layer, LayerDisposeError, LayerGeneratorYieldError, LayerRegistrationError, MapLayerBackend, Resource, ResourceNotDisposableError, ResourceReleaseFailure, Runtime, RuntimeContextNotConfiguredError, Scope, ScopeCloseError, ScopeClosedError, ScopeRuntimeNotConfiguredError, Service, ServiceAcquisitionError, ServiceNotFoundError, ServiceRuntime, ServiceRuntimeNotConfiguredError, ServiceTagCollisionError, pipe };
+export { CircularDependencyError, CurrentAbortSignal, DuplicateServiceError, Effect, Layer, LayerDisposeError, LayerGeneratorYieldError, LayerRegistrationError, MapLayerBackend, Resource, ResourceNotDisposableError, ResourceReleaseFailure, Runtime, RuntimeContextNotConfiguredError, Scope, ScopeCloseError, ScopeClosedError, ScopeRuntimeNotConfiguredError, Service, ServiceAcquisitionError, ServiceNotFoundError, ServiceRuntime, ServiceRuntimeNotConfiguredError, ServiceTagCollisionError, pipe };
 
 //# sourceMappingURL=index.mjs.map