better-effect 0.8.0 → 0.9.2

package/dist/index.mjs

@@ -1,226 +1,9 @@
-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 { a as runRuntimeContext, c as RuntimeContextNotConfiguredError, i as makeRuntimeContext, n as currentRuntimeContext, o as setDefaultRuntimeContextStorage, r as getRuntimeContext, t as activeRuntimeContextStorage } from "./context-B4yO5LaH.mjs";
-import { nodeRuntimeContextStorage } from "./runtime/node.mjs";
-import { t as MapLayerBackend } from "./map-layer-backend-BodcEeNA.mjs";
+import { a as ServiceTagCollisionError, c as ServiceNotFoundError, i as LayerRegistrationError, l as ServiceRuntimeNotConfiguredError, n as LayerDisposeError, o as CircularDependencyError, r as LayerGeneratorYieldError, s as ServiceAcquisitionError, t as DuplicateServiceError } from "./errors-Dnjhzbt0.mjs";
+import { a as runRuntimeContext, c as RuntimeContextNotConfiguredError, i as makeRuntimeContext, n as currentRuntimeContext, r as getRuntimeContext, t as activeRuntimeContextStorage } from "./context-B4yO5LaH.mjs";
+import { a as ServiceRuntime, i as Service, n as linkAbortSignals, o as defaultRuntimeContextStorage, r as Layer, t as CurrentAbortSignal } from "./signal-Cl9tqGyX.mjs";
+import { t as MapLayerBackend } from "./map-layer-backend-gal-mcRv.mjs";
 import { t as isPromiseLike } from "./runtime-CDcCF5cb.mjs";
 import { Result, TaggedError } 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 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/scope/errors.ts
 /** Thrown when Scope context is accessed outside an active Scope execution. */
 var ScopeRuntimeNotConfiguredError = class extends Error {
@@ -473,6 +256,9 @@ const Scope = {
 };
 //#endregion
 //#region src/effect/combinators.ts
+const asResult = (value) => {
+	return value;
+};
 const mapResult = (result, fn) => {
 	return Result.map(result, fn);
 };
@@ -537,6 +323,83 @@ function andThenAsync(first, second) {
 	});
 	return andThenAsyncResult(first, next);
 }
+const tapResult = (result, fn) => Result.tap(result, fn);
+const tapErrorResult = (result, fn) => Result.tapError(result, fn);
+const tapBothResult = (result, handlers) => Result.tapBoth(result, handlers);
+const recoverResult = (result, fn) => Result.tryRecover(result, fn);
+const recoverAsyncResult = (result, fn) => Result.tryRecoverAsync(result, (error) => Promise.resolve(fn(error)));
+const flattenResult = (result) => Result.flatten(result);
+const matchResult = (result, handlers) => Result.match(result, handlers);
+const allResult = (results) => Result.all(results);
+function tap(first, second) {
+	if (first instanceof Function && second === void 0) {
+		const callback = first;
+		return (effect) => tap(effect, callback);
+	}
+	if (second === void 0) throw new TypeError("Effect.tap requires a callback");
+	const fn = second;
+	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => tapResult(asResult(result), fn));
+	return tapResult(asResult(first), fn);
+}
+function tapError(first, second) {
+	if (first instanceof Function && second === void 0) {
+		const callback = first;
+		return (effect) => tapError(effect, callback);
+	}
+	if (second === void 0) throw new TypeError("Effect.tapError requires a callback");
+	const fn = second;
+	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => tapErrorResult(asResult(result), fn));
+	return tapErrorResult(asResult(first), fn);
+}
+function tapBoth(first, second) {
+	if (second === void 0) return (effect) => tapBoth(effect, first);
+	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => tapBothResult(result, second));
+	return tapBothResult(asResult(first), second);
+}
+function recover(first, second) {
+	if (first instanceof Function && second === void 0) {
+		const callback = first;
+		return (effect) => recover(effect, callback);
+	}
+	if (second === void 0) throw new TypeError("Effect.recover requires a callback");
+	const fn = second;
+	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => recoverResult(asResult(result), fn));
+	return recoverResult(asResult(first), fn);
+}
+function recoverAsync(first, second) {
+	if (first instanceof Function && second === void 0) {
+		const callback = first;
+		return (effect) => recoverAsync(effect, callback);
+	}
+	if (second === void 0) throw new TypeError("Effect.recoverAsync requires a callback");
+	const fn = second;
+	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => recoverAsyncResult(asResult(result), fn));
+	return recoverAsyncResult(asResult(first), fn);
+}
+/** Remove one nested Result/Effect layer. */
+function flatten(effect) {
+	return flattenResult(asResult(effect));
+}
+function as(first, second) {
+	if (arguments.length < 2) return (effect) => as(effect, first);
+	return mapResult(asResult(first), () => second);
+}
+/** Replace a successful value with void. */
+function asVoid(effect) {
+	return mapResult(asResult(effect), () => void 0);
+}
+function match(first, second) {
+	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => match(asResult(result), second));
+	return matchResult(asResult(first), second);
+}
+/** Collect already-created Effects in input order. */
+function all(results) {
+	return allResult(results);
+}
+/** Combine two already-created Effects in input order. */
+function zip(left, right) {
+	return Result.all([left, right]);
+}
 //#endregion
 //#region src/effect/effect.ts
 const runResultGenerator = Result.gen;
@@ -547,6 +410,40 @@ function fn(body) {
 	const program = () => runResultGenerator(body);
 	return program;
 }
+const validateProgramConcurrency = (concurrency) => {
+	if (concurrency !== void 0 && (!Number.isFinite(concurrency) || !Number.isInteger(concurrency) || concurrency <= 0)) throw new RangeError("Program.all concurrency must be a positive integer");
+};
+/** Build a lazy Program collection with optional bounded concurrency. */
+function programAll(programs, options = {}) {
+	validateProgramConcurrency(options.concurrency);
+	const concurrency = options.concurrency;
+	const program = async () => {
+		const results = Array.from({ length: programs.length });
+		const failures = Array.from({ length: programs.length }, () => false);
+		const causes = Array.from({ length: programs.length });
+		let nextIndex = 0;
+		const worker = async () => {
+			while (true) {
+				const index = nextIndex++;
+				if (index >= programs.length) return;
+				try {
+					results[index] = await programs[index]();
+				} catch (cause) {
+					failures[index] = true;
+					causes[index] = cause;
+				}
+			}
+		};
+		const workers = Math.min(concurrency ?? programs.length, programs.length);
+		await Promise.all(Array.from({ length: workers }, () => worker()));
+		const failureIndex = failures.findIndex(Boolean);
+		if (failureIndex >= 0) throw causes[failureIndex];
+		return Result.all(results);
+	};
+	return program;
+}
+/** Value-level namespace for lazy Program combinators. */
+const Program = { all: programAll };
 /**
 * Acquire a resource in the current Scope and register its release callback.
 *
@@ -582,12 +479,6 @@ function add(resource) {
 	const scope = Scope.current();
 	return Result.await(Result.tryPromise(() => scope.add(resource)));
 }
-/**
-* Effect namespace containing generator, resource, and Result combinators.
-*
-* Prefer these helpers when a program needs typed Service requirements or
-* Scope-aware acquisition and cleanup.
-*/
 const Effect = {
 	/** Compose a generator-based Effect program. */
 	gen,
@@ -604,7 +495,29 @@ const Effect = {
 	/** Chain a synchronous Effect result. */
 	andThen,
 	/** Chain an asynchronous Effect result. */
-	andThenAsync
+	andThenAsync,
+	/** Observe successful values without changing the Result. */
+	tap,
+	/** Observe error values without changing the Result. */
+	tapError,
+	/** Observe the active Result branch without changing the Result. */
+	tapBoth,
+	/** Recover an error with another Effect. */
+	recover,
+	/** Recover an error asynchronously with another Effect. */
+	recoverAsync,
+	/** Remove one nested Effect layer. */
+	flatten,
+	/** Replace a successful value. */
+	as,
+	/** Replace a successful value with void. */
+	asVoid,
+	/** Match either Result branch. */
+	match,
+	/** Collect Effects in input order. */
+	all,
+	/** Zip two Effects in input order. */
+	zip
 };
 //#endregion
 //#region src/function/pipe.ts
@@ -702,54 +615,6 @@ 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) {
@@ -1272,6 +1137,6 @@ var Runtime = class Runtime {
 	}
 };
 //#endregion
-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 };
+export { CircularDependencyError, CurrentAbortSignal, DuplicateServiceError, Effect, Layer, LayerDisposeError, LayerGeneratorYieldError, LayerRegistrationError, MapLayerBackend, Program, Resource, ResourceNotDisposableError, ResourceReleaseFailure, Runtime, RuntimeContextNotConfiguredError, Scope, ScopeCloseError, ScopeClosedError, ScopeRuntimeNotConfiguredError, Service, ServiceAcquisitionError, ServiceNotFoundError, ServiceRuntime, ServiceRuntimeNotConfiguredError, ServiceTagCollisionError, pipe };
 
 //# sourceMappingURL=index.mjs.map