better-effect 0.10.0 → 0.12.0

package/dist/adapters/iti.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"iti.mjs","names":[],"sources":["../../src/adapters/iti.ts"],"sourcesContent":["import { createContainer } from 'iti'\n\nimport {\n  DuplicateServiceError,\n  ServiceTagCollisionError,\n  type LayerBackend,\n  type LayerRegistration\n} from '../layer'\n\nimport { ServiceNotFoundError, type AnyServiceToken } from '../service'\n\nimport { assertServiceCompatibility } from '../layer/internal-identity'\nimport { isPromiseLike } from '../utils/runtime'\n\ntype LayerAcquiredValue = Awaited<ReturnType<LayerRegistration['acquire']>>\n\n/**\n * ITI-backed Layer backend.\n *\n * Install `iti` as the optional peer dependency and pass an instance to\n * `Runtime.make` when using ITI's container implementation.\n */\nexport class ItiLayerBackend implements LayerBackend {\n  private container: any = createContainer()\n\n  private readonly keys = new Map<string, string>()\n\n  private readonly registered = new Map<string, AnyServiceToken>()\n\n  /**\n   * Track async gets so disposal cannot reset ITI while a provider is acquiring.\n   * ITI caches rejected acquisitions; replacing the container is the explicit\n   * retry boundary for that sticky failure behavior.\n   */\n  private readonly pending = new Set<Promise<unknown>>()\n\n  private keyFor(token: AnyServiceToken): string {\n    const tag = token.serviceTag\n    const existing = this.keys.get(tag)\n\n    if (existing) {\n      return existing\n    }\n\n    const key = `better-effect:${tag}`\n\n    this.keys.set(tag, key)\n\n    return key\n  }\n\n  /** Register a Layer provider under its deterministic Service-tag key. */\n  register(registration: LayerRegistration): void {\n    const token = registration.service\n    const tag = token.serviceTag\n    const existing = this.registered.get(tag)\n\n    if (existing === token) {\n      throw new DuplicateServiceError(token)\n    }\n\n    if (existing) {\n      throw new ServiceTagCollisionError(existing, token)\n    }\n\n    const key = this.keyFor(token)\n\n    this.container = this.container.add({\n      [key]: registration.acquire\n    })\n\n    this.registered.set(tag, token)\n  }\n\n  /** Resolve a registered Service through the ITI container. */\n  resolve<T extends AnyServiceToken>(token: T): InstanceType<T> | PromiseLike<InstanceType<T>> {\n    const registered = this.registered.get(token.serviceTag)\n\n    if (registered === undefined) {\n      throw new ServiceNotFoundError(token)\n    }\n\n    const key = this.keyFor(token)\n    const resolved = this.container.get(key)\n\n    const validate = (instance: LayerAcquiredValue): InstanceType<T> => {\n      assertServiceCompatibility(token, registered, instance)\n\n      // SAFETY: The registered tag and compatibility check establish the constructor-to-instance relationship after ITI erases it.\n      return instance as InstanceType<T>\n    }\n\n    if (isPromiseLike(resolved)) {\n      const pending = Promise.resolve(resolved).then(validate)\n\n      this.pending.add(pending)\n      void pending.then(\n        () => this.pending.delete(pending),\n        () => this.pending.delete(pending)\n      )\n\n      return pending\n    }\n\n    return validate(resolved)\n  }\n\n  /** Reset container-owned ITI state; Scope owns Layer provider releases. */\n  async disposeAll(): Promise<void> {\n    const container = this.container\n\n    try {\n      await Promise.allSettled(this.pending)\n      await container.disposeAll()\n    } finally {\n      this.container = createContainer()\n      this.registered.clear()\n      this.keys.clear()\n      this.pending.clear()\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;AAsBA,IAAa,kBAAb,MAAqD;CACnD,YAAyB,gBAAgB;CAEzC,uBAAwB,IAAI,IAAoB;CAEhD,6BAA8B,IAAI,IAA6B;;;;;;CAO/D,0BAA2B,IAAI,IAAsB;CAErD,OAAe,OAAgC;EAC7C,MAAM,MAAM,MAAM;EAClB,MAAM,WAAW,KAAK,KAAK,IAAI,GAAG;EAElC,IAAI,UACF,OAAO;EAGT,MAAM,MAAM,iBAAiB;EAE7B,KAAK,KAAK,IAAI,KAAK,GAAG;EAEtB,OAAO;CACT;;CAGA,SAAS,cAAuC;EAC9C,MAAM,QAAQ,aAAa;EAC3B,MAAM,MAAM,MAAM;EAClB,MAAM,WAAW,KAAK,WAAW,IAAI,GAAG;EAExC,IAAI,aAAa,OACf,MAAM,IAAI,sBAAsB,KAAK;EAGvC,IAAI,UACF,MAAM,IAAI,yBAAyB,UAAU,KAAK;EAGpD,MAAM,MAAM,KAAK,OAAO,KAAK;EAE7B,KAAK,YAAY,KAAK,UAAU,IAAI,GACjC,MAAM,aAAa,QACtB,CAAC;EAED,KAAK,WAAW,IAAI,KAAK,KAAK;CAChC;;CAGA,QAAmC,OAA0D;EAC3F,MAAM,aAAa,KAAK,WAAW,IAAI,MAAM,UAAU;EAEvD,IAAI,eAAe,KAAA,GACjB,MAAM,IAAI,qBAAqB,KAAK;EAGtC,MAAM,MAAM,KAAK,OAAO,KAAK;EAC7B,MAAM,WAAW,KAAK,UAAU,IAAI,GAAG;EAEvC,MAAM,YAAY,aAAkD;GAClE,2BAA2B,OAAO,YAAY,QAAQ;GAGtD,OAAO;EACT;EAEA,IAAI,cAAc,QAAQ,GAAG;GAC3B,MAAM,UAAU,QAAQ,QAAQ,QAAQ,CAAC,CAAC,KAAK,QAAQ;GAEvD,KAAK,QAAQ,IAAI,OAAO;GACxB,QAAa,WACL,KAAK,QAAQ,OAAO,OAAO,SAC3B,KAAK,QAAQ,OAAO,OAAO,CACnC;GAEA,OAAO;EACT;EAEA,OAAO,SAAS,QAAQ;CAC1B;;CAGA,MAAM,aAA4B;EAChC,MAAM,YAAY,KAAK;EAEvB,IAAI;GACF,MAAM,QAAQ,WAAW,KAAK,OAAO;GACrC,MAAM,UAAU,WAAW;EAC7B,UAAU;GACR,KAAK,YAAY,gBAAgB;GACjC,KAAK,WAAW,MAAM;GACtB,KAAK,KAAK,MAAM;GAChB,KAAK,QAAQ,MAAM;EACrB;CACF;AACF"}
+{"version":3,"file":"iti.mjs","names":[],"sources":["../../src/adapters/iti.ts"],"sourcesContent":["import { createContainer } from 'iti'\n\nimport {\n  DuplicateServiceError,\n  ServiceTagCollisionError,\n  type LayerBackend,\n  type LayerBackendDisposeOptions,\n  type LayerRegistration\n} from '../layer'\n\nimport { ServiceNotFoundError, type AnyServiceToken } from '../service'\nimport { captureServiceTag } from '../service/tag'\n\nimport { assertServiceCompatibility } from '../layer/internal-identity'\nimport { captureLayerRegistrationTag, normalizeLayerRegistration } from '../layer/registration'\nimport { isPromiseLike } from '../utils/runtime'\n\ntype LayerAcquiredValue = Awaited<ReturnType<LayerRegistration['acquire']>>\n\n/**\n * ITI-backed Layer backend.\n *\n * Install `iti` as the optional peer dependency and pass an instance to\n * `Runtime.make` when using ITI's container implementation.\n */\nexport class ItiLayerBackend implements LayerBackend {\n  private container: any = createContainer()\n\n  private readonly keys = new Map<string, string>()\n\n  private readonly registered = new Map<string, AnyServiceToken>()\n\n  /**\n   * Track async gets so disposal cannot reset ITI while a provider is acquiring.\n   * ITI caches rejected acquisitions; replacing the container is the explicit\n   * retry boundary for that sticky failure behavior.\n   */\n  private readonly pending = new Map<Promise<unknown>, AnyServiceToken>()\n\n  private keyFor(tag: string): string {\n    const existing = this.keys.get(tag)\n\n    if (existing) {\n      return existing\n    }\n\n    const key = `better-effect:${tag}`\n\n    this.keys.set(tag, key)\n\n    return key\n  }\n\n  /** Register a Layer provider under its deterministic Service-tag key. */\n  register(registration: LayerRegistration): void {\n    const normalized = normalizeLayerRegistration(registration)\n    const token = normalized.service\n    const tag = captureLayerRegistrationTag(normalized)\n    const existing = this.registered.get(tag)\n\n    if (existing === token) {\n      throw new DuplicateServiceError(token)\n    }\n\n    if (existing) {\n      throw new ServiceTagCollisionError(existing, token)\n    }\n\n    const key = this.keyFor(tag)\n\n    this.container = this.container.add({\n      [key]: normalized.acquire\n    })\n\n    this.registered.set(tag, token)\n  }\n\n  /** Resolve a registered Service through the ITI container. */\n  resolve<T extends AnyServiceToken>(token: T): InstanceType<T> | PromiseLike<InstanceType<T>> {\n    const tag = captureServiceTag(token)\n    const registered = this.registered.get(tag)\n\n    if (registered === undefined) {\n      throw new ServiceNotFoundError(token)\n    }\n\n    const key = this.keyFor(tag)\n    const resolved = this.container.get(key)\n\n    const validate = (instance: LayerAcquiredValue): InstanceType<T> => {\n      assertServiceCompatibility(token, registered, instance)\n\n      // SAFETY: The registered tag and compatibility check establish the constructor-to-instance relationship after ITI erases it.\n      return instance as InstanceType<T>\n    }\n\n    if (isPromiseLike(resolved)) {\n      const pending = Promise.resolve(resolved).then(validate)\n\n      this.pending.set(pending, registered)\n      void pending.then(\n        () => this.pending.delete(pending),\n        () => this.pending.delete(pending)\n      )\n\n      return pending\n    }\n\n    return validate(resolved)\n  }\n\n  /** Reset container-owned ITI state; Scope owns Layer provider releases. */\n  async disposeAll(options?: LayerBackendDisposeOptions): Promise<void> {\n    const container = this.container\n    const acquisitions = [...this.pending.keys()]\n\n    try {\n      if (acquisitions.length > 0) {\n        const observePending = options?.onPendingAcquisitions\n\n        if (observePending) {\n          await observePending(acquisitions)\n        }\n\n        await Promise.allSettled(acquisitions)\n      }\n      await container.disposeAll()\n    } finally {\n      this.container = createContainer()\n      this.registered.clear()\n      this.keys.clear()\n      this.pending.clear()\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;AAyBA,IAAa,kBAAb,MAAqD;CACnD,YAAyB,gBAAgB;CAEzC,uBAAwB,IAAI,IAAoB;CAEhD,6BAA8B,IAAI,IAA6B;;;;;;CAO/D,0BAA2B,IAAI,IAAuC;CAEtE,OAAe,KAAqB;EAClC,MAAM,WAAW,KAAK,KAAK,IAAI,GAAG;EAElC,IAAI,UACF,OAAO;EAGT,MAAM,MAAM,iBAAiB;EAE7B,KAAK,KAAK,IAAI,KAAK,GAAG;EAEtB,OAAO;CACT;;CAGA,SAAS,cAAuC;EAC9C,MAAM,aAAa,2BAA2B,YAAY;EAC1D,MAAM,QAAQ,WAAW;EACzB,MAAM,MAAM,4BAA4B,UAAU;EAClD,MAAM,WAAW,KAAK,WAAW,IAAI,GAAG;EAExC,IAAI,aAAa,OACf,MAAM,IAAI,sBAAsB,KAAK;EAGvC,IAAI,UACF,MAAM,IAAI,yBAAyB,UAAU,KAAK;EAGpD,MAAM,MAAM,KAAK,OAAO,GAAG;EAE3B,KAAK,YAAY,KAAK,UAAU,IAAI,GACjC,MAAM,WAAW,QACpB,CAAC;EAED,KAAK,WAAW,IAAI,KAAK,KAAK;CAChC;;CAGA,QAAmC,OAA0D;EAC3F,MAAM,MAAM,kBAAkB,KAAK;EACnC,MAAM,aAAa,KAAK,WAAW,IAAI,GAAG;EAE1C,IAAI,eAAe,KAAA,GACjB,MAAM,IAAI,qBAAqB,KAAK;EAGtC,MAAM,MAAM,KAAK,OAAO,GAAG;EAC3B,MAAM,WAAW,KAAK,UAAU,IAAI,GAAG;EAEvC,MAAM,YAAY,aAAkD;GAClE,2BAA2B,OAAO,YAAY,QAAQ;GAGtD,OAAO;EACT;EAEA,IAAI,cAAc,QAAQ,GAAG;GAC3B,MAAM,UAAU,QAAQ,QAAQ,QAAQ,CAAC,CAAC,KAAK,QAAQ;GAEvD,KAAK,QAAQ,IAAI,SAAS,UAAU;GACpC,QAAa,WACL,KAAK,QAAQ,OAAO,OAAO,SAC3B,KAAK,QAAQ,OAAO,OAAO,CACnC;GAEA,OAAO;EACT;EAEA,OAAO,SAAS,QAAQ;CAC1B;;CAGA,MAAM,WAAW,SAAqD;EACpE,MAAM,YAAY,KAAK;EACvB,MAAM,eAAe,CAAC,GAAG,KAAK,QAAQ,KAAK,CAAC;EAE5C,IAAI;GACF,IAAI,aAAa,SAAS,GAAG;IAC3B,MAAM,iBAAiB,SAAS;IAEhC,IAAI,gBACF,MAAM,eAAe,YAAY;IAGnC,MAAM,QAAQ,WAAW,YAAY;GACvC;GACA,MAAM,UAAU,WAAW;EAC7B,UAAU;GACR,KAAK,YAAY,gBAAgB;GACjC,KAAK,WAAW,MAAM;GACtB,KAAK,KAAK,MAAM;GAChB,KAAK,QAAQ,MAAM;EACrB;CACF;AACF"}

package/dist/effect-CK4YZaX0.mjs

@@ -0,0 +1,559 @@
+import { t as isPromiseLike } from "./runtime-CDcCF5cb.mjs";
+import { i as Scope, n as inheritProgramName, r as setProgramName } from "./program-metadata-DhQCCirO.mjs";
+import { Err, Result, matchError, matchErrorPartial } from "better-result";
+//#region src/effect/combinators.ts
+const asResult = (value) => {
+	return 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$1(first, second) {
+	if (first instanceof Function && second === void 0) {
+		const callback = first;
+		return (effect) => {
+			return map$1(effect, callback);
+		};
+	}
+	const fn = second;
+	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => {
+		return mapResult(result, fn);
+	});
+	return mapResult(first, fn);
+}
+function mapError$1(first, second) {
+	if (first instanceof Function && second === void 0) {
+		const callback = first;
+		return (effect) => {
+			return mapError$1(effect, callback);
+		};
+	}
+	const fn = second;
+	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => {
+		return mapErrorResult(result, fn);
+	});
+	return mapErrorResult(first, fn);
+}
+function andThen$1(first, second) {
+	if (first instanceof Function && second === void 0) {
+		const callback = first;
+		return (effect) => {
+			return andThen$1(effect, callback);
+		};
+	}
+	return andThenResult(first, second);
+}
+function andThenAsync(first, second) {
+	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) => {
+		return andThenAsyncResult(result, next);
+	});
+	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 tapAsyncResult = (result, fn) => Result.tapAsync(result, (value) => Promise.resolve(fn(value)));
+const tapErrorAsyncResult = (result, fn) => Result.tapErrorAsync(result, (error) => Promise.resolve(fn(error)));
+const tapBothAsyncResult = (result, handlers) => Result.tapBothAsync(result, {
+	ok: (value) => Promise.resolve(handlers.ok(value)),
+	err: (error) => Promise.resolve(handlers.err(error))
+});
+const asTaggedResult = (result) => {
+	return result;
+};
+const matchErrorResult = (result, handlers) => {
+	return Result.mapError(result, (error) => matchError(error, handlers));
+};
+const matchErrorPartialResult = (result, handlers) => {
+	return Result.mapError(result, (error) => matchErrorPartial(error, 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$1(first, second) {
+	if (first instanceof Function && second === void 0) {
+		const callback = first;
+		return (effect) => tap$1(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$1(first, second) {
+	if (first instanceof Function && second === void 0) {
+		const callback = first;
+		return (effect) => tapError$1(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 tapAsync(first, second) {
+	if (first instanceof Function && second === void 0) {
+		const callback = first;
+		return (effect) => tapAsync(effect, callback);
+	}
+	if (second === void 0) throw new TypeError("Effect.tapAsync requires a callback");
+	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => tapAsyncResult(asResult(result), second));
+	return tapAsyncResult(asResult(first), second);
+}
+function tapErrorAsync(first, second) {
+	if (first instanceof Function && second === void 0) {
+		const callback = first;
+		return (effect) => tapErrorAsync(effect, callback);
+	}
+	if (second === void 0) throw new TypeError("Effect.tapErrorAsync requires a callback");
+	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => tapErrorAsyncResult(asResult(result), second));
+	return tapErrorAsyncResult(asResult(first), second);
+}
+function tapBothAsync(first, second) {
+	if (second === void 0) return (effect) => tapBothAsync(effect, first);
+	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => tapBothAsyncResult(result, second));
+	return tapBothAsyncResult(asResult(first), second);
+}
+function matchError$1(first, second) {
+	if (second === void 0) throw new TypeError("Effect.matchError requires handlers");
+	const handlers = second;
+	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => matchErrorResult(asTaggedResult(asResult(result)), handlers));
+	return matchErrorResult(asTaggedResult(asResult(first)), handlers);
+}
+function matchErrorPartial$1(first, second) {
+	if (second === void 0) throw new TypeError("Effect.matchErrorPartial requires handlers");
+	const handlers = second;
+	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => matchErrorPartialResult(asTaggedResult(asResult(result)), handlers));
+	return matchErrorPartialResult(asTaggedResult(asResult(first)), handlers);
+}
+function recover$1(first, second) {
+	if (first instanceof Function && second === void 0) {
+		const callback = first;
+		return (effect) => recover$1(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/program-combinators.ts
+const asProgram = (program) => program;
+const isAsyncEffect = (effect) => isPromiseLike(effect);
+const mapRuntime = (effect, fn) => {
+	if (isAsyncEffect(effect)) return Promise.resolve(effect).then((result) => Result.map(result, fn));
+	return Result.map(effect, fn);
+};
+const mapErrorRuntime = (effect, fn) => {
+	if (isAsyncEffect(effect)) return Promise.resolve(effect).then((result) => Result.mapError(result, fn));
+	return Result.mapError(effect, fn);
+};
+const tapRuntime = (effect, fn) => {
+	if (isAsyncEffect(effect)) return Promise.resolve(effect).then((result) => Result.tap(result, fn));
+	return Result.tap(effect, fn);
+};
+const tapErrorRuntime = (effect, fn) => {
+	if (isAsyncEffect(effect)) return Promise.resolve(effect).then((result) => Result.tapError(result, fn));
+	return Result.tapError(effect, fn);
+};
+const invoke = (output) => output instanceof Function ? output() : output;
+const andThenRuntime = (effect, next) => {
+	const continueWith = (value) => Promise.resolve(invoke(next(value)));
+	if (isAsyncEffect(effect)) return Promise.resolve(effect).then((result) => Result.andThenAsync(result, continueWith));
+	return Result.andThenAsync(effect, continueWith);
+};
+const recoverRuntime = (effect, recover) => {
+	const continueWith = (error) => Promise.resolve(invoke(recover(error)));
+	if (isAsyncEffect(effect)) return Promise.resolve(effect).then((result) => Result.tryRecoverAsync(result, continueWith));
+	return Result.tryRecoverAsync(effect, continueWith);
+};
+const mapProgram = (program, fn) => {
+	const mapped = asProgram(() => mapRuntime(program(), fn));
+	return inheritProgramName(program, mapped);
+};
+const mapErrorProgram = (program, fn) => {
+	const mapped = asProgram(() => mapErrorRuntime(program(), fn));
+	return inheritProgramName(program, mapped);
+};
+const tapProgram = (program, fn) => {
+	const tapped = asProgram(() => tapRuntime(program(), fn));
+	return inheritProgramName(program, tapped);
+};
+const tapErrorProgram = (program, fn) => {
+	const tapped = asProgram(() => tapErrorRuntime(program(), fn));
+	return inheritProgramName(program, tapped);
+};
+function map(first, second) {
+	if (second === void 0) return (program) => {
+		return mapProgram(program, first);
+	};
+	return mapProgram(first, second);
+}
+function mapError(first, second) {
+	if (second === void 0) return (program) => {
+		return mapErrorProgram(program, first);
+	};
+	return mapErrorProgram(first, second);
+}
+function andThen(first, second) {
+	if (second === void 0) return (program) => {
+		const chained = () => andThenRuntime(program(), first);
+		return inheritProgramName(program, chained);
+	};
+	const source = first;
+	const chained = () => andThenRuntime(source(), second);
+	return inheritProgramName(source, chained);
+}
+function tap(first, second) {
+	if (second === void 0) return (program) => {
+		return tapProgram(program, first);
+	};
+	return tapProgram(first, second);
+}
+function tapError(first, second) {
+	if (second === void 0) return (program) => {
+		return tapErrorProgram(program, first);
+	};
+	return tapErrorProgram(first, second);
+}
+function recover(first, second) {
+	if (second === void 0) return (program) => {
+		const recovered = () => recoverRuntime(program(), first);
+		return inheritProgramName(program, recovered);
+	};
+	const source = first;
+	const recovered = () => recoverRuntime(source(), second);
+	return inheritProgramName(source, recovered);
+}
+//#endregion
+//#region src/effect/program-scheduler.ts
+/** Validate the shared bounded-concurrency option before a Program is run. */
+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");
+};
+const runWorker = async (length, task, stopOnResultError, state) => {
+	while (!state.stopScheduling) {
+		const index = state.nextIndex++;
+		if (index >= length) return;
+		try {
+			const result = await task(index);
+			state.results[index] = result;
+			if (result instanceof Err) state.stopScheduling ||= stopOnResultError;
+		} catch (cause) {
+			state.defects[index] = { cause };
+			state.stopScheduling = true;
+		}
+	}
+};
+/** Run claimed Programs with a shared FIFO worker pool and no cancellation. */
+const runProgramCollection = async (length, task, options) => {
+	const state = {
+		nextIndex: 0,
+		stopScheduling: false,
+		results: Array.from({ length }),
+		defects: Array.from({ length })
+	};
+	const workerCount = Math.min(options.concurrency ?? length, length);
+	const workers = Array.from({ length: workerCount }, () => runWorker(length, task, options.stopOnResultError, state));
+	await Promise.all(workers);
+	return state;
+};
+/** Select the first defect by input index, independent of settlement order. */
+const firstProgramDefect = (defects) => {
+	for (const defect of defects) if (defect !== void 0) return defect;
+};
+/** Select the first short-circuiting failure by input index. */
+const firstProgramFailure = (results, defects) => {
+	const length = Math.max(results.length, defects.length);
+	for (let index = 0; index < length; index++) {
+		const defect = defects[index];
+		if (defect !== void 0) return {
+			kind: "defect",
+			cause: defect.cause
+		};
+		const result = results[index];
+		if (result instanceof Err) return {
+			kind: "result",
+			result
+		};
+	}
+};
+//#endregion
+//#region src/effect/effect.ts
+const runResultGenerator = Result.gen;
+function gen(body) {
+	return runResultGenerator(body);
+}
+function fn(body) {
+	const program = () => runResultGenerator(body);
+	return program;
+}
+const validateProgramName = (name) => {
+	if (typeof name !== "string") throw new TypeError("Program name must be a string");
+};
+function programNamed(name, program) {
+	validateProgramName(name);
+	if (program === void 0) return (source) => setProgramName(source, name);
+	return setProgramName(program, name);
+}
+const runShortCircuitingCollection = async (length, task, concurrency) => {
+	const outcome = await runProgramCollection(length, task, {
+		concurrency,
+		stopOnResultError: true
+	});
+	const failure = firstProgramFailure(outcome.results, outcome.defects);
+	if (failure?.kind === "defect") throw failure.cause;
+	if (failure?.kind === "result") return failure.result;
+	return Result.all(outcome.results);
+};
+const runAllResultsCollection = async (length, task, concurrency) => {
+	const outcome = await runProgramCollection(length, task, {
+		concurrency,
+		stopOnResultError: false
+	});
+	const defect = firstProgramDefect(outcome.defects);
+	if (defect !== void 0) throw defect.cause;
+	return Result.ok(outcome.results);
+};
+/** Build a lazy Program collection with optional bounded concurrency. */
+function programAll(programs, options = {}) {
+	const concurrency = options.concurrency;
+	const name = options?.name;
+	validateProgramConcurrency(concurrency);
+	const program = () => runShortCircuitingCollection(programs.length, (index) => programs[index](), concurrency);
+	if (name !== void 0) {
+		validateProgramName(name);
+		setProgramName(program, name);
+	}
+	return program;
+}
+/** Build a lazy Program collection from an input array and Program factory. */
+function programForEach(items, makeProgram, options = {}) {
+	const concurrency = options.concurrency;
+	const name = options?.name;
+	validateProgramConcurrency(concurrency);
+	const program = () => runShortCircuitingCollection(items.length, (index) => makeProgram(items[index], index)(), concurrency);
+	if (name !== void 0) {
+		validateProgramName(name);
+		setProgramName(program, name);
+	}
+	return program;
+}
+/** Build a lazy Program collection that retains every child Result. */
+function programAllResults(programs, options = {}) {
+	const concurrency = options.concurrency;
+	const name = options?.name;
+	validateProgramConcurrency(concurrency);
+	const program = () => runAllResultsCollection(programs.length, (index) => programs[index](), concurrency);
+	if (name !== void 0) {
+		validateProgramName(name);
+		setProgramName(program, name);
+	}
+	return program;
+}
+/** Value-level namespace for lazy Program combinators. */
+const Program = {
+	named: programNamed,
+	all: programAll,
+	forEach: programForEach,
+	allResults: programAllResults,
+	map,
+	mapError,
+	andThen,
+	tap,
+	tapError,
+	recover
+};
+/**
+* Acquire a resource in the current Scope and register its release callback.
+*
+* Acquisition failures are represented in the Effect Result error channel;
+* release failures remain owned by Scope cleanup. The release callback
+* receives the final outcome chosen by the enclosing execution boundary.
+*
+* @example
+* ```ts
+* const connection = yield* Effect.acquireRelease(
+*   () => pool.connect(),
+*   (connection, outcome) => connection.close(outcome)
+* )
+* ```
+*/
+function acquireRelease(acquire, release) {
+	const scope = Scope.current();
+	return Result.await(Result.tryPromise(() => scope.acquire(acquire, release)));
+}
+var AcquireReleaseResultFailure = class {
+	result;
+	constructor(result) {
+		this.result = result;
+	}
+};
+/**
+* Acquire a Result-valued resource and register only successful acquisitions.
+*
+* Typed acquisition failures remain unchanged in the Effect error channel;
+* unexpected acquisition and registration failures are normalized by
+* `better-result`. Release failures remain Scope cleanup failures.
+*/
+function acquireReleaseResult(acquire, release) {
+	const scope = Scope.current();
+	const registered = Result.tryPromise(async () => {
+		try {
+			const resource = await scope.acquire(async () => {
+				const result = await acquire();
+				if (Result.isError(result)) throw new AcquireReleaseResultFailure(result);
+				return result.value;
+			}, release);
+			return Result.ok(resource);
+		} catch (cause) {
+			if (cause instanceof AcquireReleaseResultFailure) return cause.result;
+			throw cause;
+		}
+	});
+	return Result.await(registered.then((result) => result.andThen((acquired) => acquired)));
+}
+/**
+* Lazily acquire and register a disposable resource in the current Scope.
+*
+* Disposal is delegated to `Scope.add`, including protocol preference,
+* validation, race-safe registration, and cleanup error handling.
+*/
+function acquireDisposable(acquire) {
+	const scope = Scope.current();
+	return Result.await(Result.tryPromise(async () => scope.add(await acquire())));
+}
+/**
+* Register an already-acquired disposable resource in the current Scope.
+*
+* The resource is not acquired by this helper. Registration failures are
+* represented in the Effect Result error channel; disposal failures remain
+* owned by Scope cleanup.
+*
+* @example
+* ```ts
+* const file = yield* Effect.add(await openFile('notes.txt'))
+* ```
+*/
+function add(resource) {
+	const scope = Scope.current();
+	return Result.await(Result.tryPromise(() => scope.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,
+	/** Acquire a Result-valued resource and register successful acquisitions. */
+	acquireReleaseResult,
+	/** Acquire and register a disposable resource in the current Scope. */
+	acquireDisposable,
+	/** Register an already-acquired disposable in the current Scope. */
+	add,
+	/** Map a successful Effect result. */
+	map: map$1,
+	/** Map an Effect error. */
+	mapError: mapError$1,
+	/** Chain a synchronous Effect result. */
+	andThen: andThen$1,
+	/** Chain an asynchronous Effect result. */
+	andThenAsync,
+	/** Observe successful values without changing the Result. */
+	tap: tap$1,
+	/** Observe successful values asynchronously without changing the Result. */
+	tapAsync,
+	/** Observe error values without changing the Result. */
+	tapError: tapError$1,
+	/** Observe error values asynchronously without changing the Result. */
+	tapErrorAsync,
+	/** Observe the active Result branch without changing the Result. */
+	tapBoth,
+	/** Observe the active Result branch asynchronously without changing the Result. */
+	tapBothAsync,
+	/** Match every tagged error variant and map it to a new error value. */
+	matchError: matchError$1,
+	/** Match selected tagged errors and retain unhandled variants. */
+	matchErrorPartial: matchErrorPartial$1,
+	/** Recover an error with another Effect. */
+	recover: recover$1,
+	/** 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
+export { Program as n, Effect as t };
+
+//# sourceMappingURL=effect-CK4YZaX0.mjs.map