better-effect 0.10.0 → 0.12.0

package/dist/testing.mjs

@@ -1,2 +1,1159 @@
-import { t as MapLayerBackend } from "./map-layer-backend-gal-mcRv.mjs";
-export { MapLayerBackend as MemoryLayerBackend };
+import { i as LayerDisposeError, r as DuplicateServiceError, s as ServiceTagCollisionError, u as ServiceNotFoundError } from "./registration-drnZk0SY.mjs";
+import { g as RuntimeContextOverlapError, h as RuntimeContextNotConfiguredError } from "./context-BUEf1qjL.mjs";
+import { t as isPromiseLike } from "./runtime-CDcCF5cb.mjs";
+import { o as ScopeCloseError, s as ScopeClosedError } from "./signal-D2UTcaaG.mjs";
+import { n as Service, r as ServiceRuntime, t as Layer } from "./layer-D56fRdLt.mjs";
+import { i as Scope, o as ScopeRuntime } from "./program-metadata-DhQCCirO.mjs";
+import { i as MapLayerBackend, n as RuntimeObserver, r as classifyRuntimeOutcome, t as Runtime } from "./runtime-CBMrX8Wl.mjs";
+import { d as Random, h as IdGenerator, l as LoggerTest, p as RandomSeeded, r as ClockTest, s as Logger, t as Clock, v as IdGeneratorTest } from "./standard-services-GBZ32tll.mjs";
+//#region src/testing/contracts.ts
+/** Thrown by a conformance scenario when an adapter violates its contract. */
+var ConformanceError = class extends Error {
+	scenario;
+	constructor(scenario, detail, cause) {
+		super(`${scenario}: ${detail}`, { cause });
+		this.scenario = scenario;
+		this.name = "ConformanceError";
+	}
+};
+var ContractService = class extends Service()("@better-effect/testing/ContractService") {};
+var MissingContractService = class extends Service()("@better-effect/testing/MissingContractService") {};
+var CompatibleRegisteredService = class extends Service()("@better-effect/testing/CompatibleService") {
+	read() {
+		return "registered";
+	}
+	write() {
+		return "registered-only";
+	}
+};
+var CompatibleRequestedService = class extends Service()("@better-effect/testing/CompatibleService") {
+	read() {
+		return "requested";
+	}
+};
+var IncompatibleRegisteredService = class extends Service()("@better-effect/testing/IncompatibleService") {
+	read() {
+		return "registered";
+	}
+};
+var IncompatibleRequestedService = class extends Service()("@better-effect/testing/IncompatibleService") {
+	write() {
+		return "requested";
+	}
+};
+const layerScenario = (name, run) => ({
+	name,
+	async run() {
+		try {
+			await run();
+		} catch (cause) {
+			if (cause instanceof ConformanceError) throw cause;
+			throw new ConformanceError(name, `unexpected failure (${describeCause(cause)})`, cause);
+		}
+	}
+});
+const fail = (scenario, detail) => {
+	throw new ConformanceError(scenario, detail);
+};
+const assert = (condition, scenario, detail) => {
+	if (!condition) fail(scenario, detail);
+};
+const describeCause = (cause) => cause instanceof Error ? `${cause.name}: ${cause.message}` : String(cause);
+const rejected = async (value, scenario, expectation) => {
+	const outcome = await Promise.resolve(value).then(() => ({ rejected: false }), (cause) => ({
+		rejected: true,
+		cause
+	}));
+	if (outcome.rejected) return outcome.cause;
+	fail(scenario, `expected ${expectation} to reject`);
+};
+const withBackend = async (options, run) => {
+	const backend = await options.makeBackend();
+	try {
+		return await run(backend);
+	} finally {
+		try {
+			await backend.disposeAll();
+		} finally {
+			await options.cleanup?.(backend);
+		}
+	}
+};
+const expectMissingService = (cause, service, scenario) => {
+	assert(cause instanceof ServiceNotFoundError, scenario, `expected ServiceNotFoundError for tag "${service.serviceTag}", received ${describeCause(cause)}`);
+	if (cause instanceof ServiceNotFoundError) assert(cause.service.serviceTag === service.serviceTag, scenario, `expected missing tag "${service.serviceTag}", received "${cause.service.serviceTag}"`);
+};
+const expectDuplicate = (cause, service, scenario) => {
+	assert(cause instanceof DuplicateServiceError, scenario, `expected DuplicateServiceError for tag "${service.serviceTag}", received ${describeCause(cause)}`);
+	if (cause instanceof DuplicateServiceError) assert(cause.service.serviceTag === service.serviceTag, scenario, `expected duplicate tag "${service.serviceTag}", received "${cause.service.serviceTag}"`);
+};
+const expectCollision = (cause, service, scenario) => {
+	assert(cause instanceof ServiceTagCollisionError, scenario, `expected ServiceTagCollisionError for tag "${service.serviceTag}", received ${describeCause(cause)}`);
+	if (cause instanceof ServiceTagCollisionError) assert(cause.incoming.serviceTag === service.serviceTag, scenario, `expected collision tag "${service.serviceTag}", received "${cause.incoming.serviceTag}"`);
+};
+/**
+* Return runner-neutral scenarios for a LayerBackend implementation.
+*
+* Every scenario creates a fresh backend and invokes `cleanup` in `finally`,
+* so consumers can register `scenario.run` directly with their test runner.
+*/
+const layerBackendContract = (options) => [
+	layerScenario("LayerBackend registers providers lazily", async () => {
+		await withBackend(options, async (backend) => {
+			let acquisitions = 0;
+			await backend.register({
+				service: ContractService,
+				acquire: () => {
+					acquisitions++;
+					return new ContractService();
+				}
+			});
+			assert(acquisitions === 0, "LayerBackend registers providers lazily", `expected no acquisitions during registration for tag "${ContractService.serviceTag}", received ${acquisitions}`);
+		});
+	}),
+	layerScenario("LayerBackend resolves the registered Service token", async () => {
+		await withBackend(options, async (backend) => {
+			const instance = new ContractService();
+			await backend.register({
+				service: ContractService,
+				acquire: () => instance
+			});
+			const resolved = await backend.resolve(ContractService);
+			assert(resolved === instance && resolved instanceof ContractService, "LayerBackend resolves the registered Service token", `expected token "${ContractService.serviceTag}" to resolve its registered instance`);
+		});
+	}),
+	layerScenario("LayerBackend caches successful acquisitions", async () => {
+		await withBackend(options, async (backend) => {
+			let acquisitions = 0;
+			await backend.register({
+				service: ContractService,
+				acquire: () => {
+					acquisitions++;
+					return new ContractService();
+				}
+			});
+			const first = await backend.resolve(ContractService);
+			const second = await backend.resolve(ContractService);
+			assert(first === second && acquisitions === 1, "LayerBackend caches successful acquisitions", `expected one cached acquisition for tag "${ContractService.serviceTag}", received ${acquisitions}`);
+		});
+	}),
+	layerScenario("LayerBackend deduplicates concurrent acquisitions", async () => {
+		await withBackend(options, async (backend) => {
+			let acquisitions = 0;
+			let releaseAcquisition;
+			let markStarted;
+			const acquired = new Promise((resolve) => {
+				markStarted = resolve;
+			});
+			const release = new Promise((resolve) => {
+				releaseAcquisition = resolve;
+			});
+			const instance = new ContractService();
+			await backend.register({
+				service: ContractService,
+				acquire: async () => {
+					acquisitions++;
+					markStarted();
+					await release;
+					return instance;
+				}
+			});
+			const first = Promise.resolve(backend.resolve(ContractService));
+			const second = Promise.resolve(backend.resolve(ContractService));
+			try {
+				await acquired;
+				assert(acquisitions === 1, "LayerBackend deduplicates concurrent acquisitions", `expected one in-flight acquisition for tag "${ContractService.serviceTag}", received ${acquisitions}`);
+				releaseAcquisition();
+				const [firstInstance, secondInstance] = await Promise.all([first, second]);
+				assert(firstInstance === instance && secondInstance === instance, "LayerBackend deduplicates concurrent acquisitions", `expected concurrent resolves for tag "${ContractService.serviceTag}" to share one instance`);
+			} finally {
+				releaseAcquisition();
+				await Promise.allSettled([first, second]);
+			}
+		});
+	}),
+	layerScenario("LayerBackend reports a missing Service tag", async () => {
+		await withBackend(options, async (backend) => {
+			const cause = await rejected(Promise.resolve().then(() => backend.resolve(MissingContractService)), "LayerBackend reports a missing Service tag", `resolution for tag "${MissingContractService.serviceTag}"`);
+			expectMissingService(cause, MissingContractService, "LayerBackend reports a missing Service tag");
+		});
+	}),
+	layerScenario("LayerBackend rejects exact duplicate registrations", async () => {
+		await withBackend(options, async (backend) => {
+			const registration = {
+				service: ContractService,
+				acquire: () => new ContractService()
+			};
+			await backend.register(registration);
+			const cause = await rejected(Promise.resolve().then(() => backend.register(registration)), "LayerBackend rejects exact duplicate registrations", `a duplicate registration for tag "${ContractService.serviceTag}"`);
+			expectDuplicate(cause, ContractService, "LayerBackend rejects exact duplicate registrations");
+		});
+	}),
+	layerScenario("LayerBackend rejects incompatible same-tag collisions", async () => {
+		await withBackend(options, async (backend) => {
+			await backend.register({
+				service: IncompatibleRegisteredService,
+				acquire: () => new IncompatibleRegisteredService()
+			});
+			const registrationCause = await rejected(Promise.resolve().then(() => backend.register({
+				service: IncompatibleRequestedService,
+				acquire: () => new IncompatibleRequestedService()
+			})), "LayerBackend rejects incompatible same-tag collisions", `a colliding registration for tag "${IncompatibleRequestedService.serviceTag}"`);
+			expectCollision(registrationCause, IncompatibleRequestedService, "LayerBackend rejects incompatible same-tag collisions");
+			const resolutionCause = await rejected(Promise.resolve().then(() => backend.resolve(IncompatibleRequestedService)), "LayerBackend rejects incompatible same-tag collisions", `an incompatible lookup for tag "${IncompatibleRequestedService.serviceTag}"`);
+			expectCollision(resolutionCause, IncompatibleRequestedService, "LayerBackend rejects incompatible same-tag collisions");
+		});
+	}),
+	layerScenario("LayerBackend preserves compatible same-tag registrations", async () => {
+		await withBackend(options, async (backend) => {
+			const registered = new CompatibleRegisteredService();
+			await backend.register({
+				service: CompatibleRegisteredService,
+				acquire: () => registered
+			});
+			const resolved = await backend.resolve(CompatibleRequestedService);
+			assert(resolved === registered && resolved.read() === "registered", "LayerBackend preserves compatible same-tag registrations", `expected compatible tag "${CompatibleRequestedService.serviceTag}" to resolve the registered contract`);
+		});
+	}),
+	layerScenario("LayerBackend applies declared acquisition-failure behavior", async () => {
+		await withBackend(options, async (backend) => {
+			const failure = /* @__PURE__ */ new Error("contract acquisition failure");
+			let acquisitions = 0;
+			await backend.register({
+				service: ContractService,
+				acquire: async () => {
+					acquisitions++;
+					throw failure;
+				}
+			});
+			const firstCause = await rejected(Promise.resolve().then(() => backend.resolve(ContractService)), "LayerBackend applies declared acquisition-failure behavior", `the first acquisition for tag "${ContractService.serviceTag}"`);
+			const secondCause = await rejected(Promise.resolve().then(() => backend.resolve(ContractService)), "LayerBackend applies declared acquisition-failure behavior", `the second acquisition for tag "${ContractService.serviceTag}"`);
+			const expectedAcquisitions = options.acquisitionFailure === "retry" ? 2 : 1;
+			assert(firstCause === failure && secondCause === failure && acquisitions === expectedAcquisitions, "LayerBackend applies declared acquisition-failure behavior", `expected ${options.acquisitionFailure} behavior with ${expectedAcquisitions} acquisition attempts for tag "${ContractService.serviceTag}", received ${acquisitions}`);
+		});
+	}),
+	layerScenario("LayerBackend disposal waits for in-flight acquisition", async () => {
+		await withBackend(options, async (backend) => {
+			let releaseAcquisition;
+			let releaseCallbackGate;
+			let markStarted;
+			let disposing;
+			let callbackCompleted;
+			let observedPendingAcquisitions;
+			let callbackInvoked = false;
+			let acquisitionCompleted = false;
+			let callbackCompletionReactionObserved = false;
+			let disposalSettled = false;
+			const acquired = new Promise((resolve) => {
+				markStarted = resolve;
+			});
+			const release = new Promise((resolve) => {
+				releaseAcquisition = resolve;
+			});
+			const callbackGate = new Promise((resolve) => {
+				releaseCallbackGate = resolve;
+			});
+			await backend.register({
+				service: ContractService,
+				acquire: async () => {
+					markStarted();
+					await release;
+					acquisitionCompleted = true;
+					return new ContractService();
+				}
+			});
+			const resolving = Promise.resolve(backend.resolve(ContractService));
+			try {
+				await acquired;
+				const disposalResult = backend.disposeAll({ onPendingAcquisitions: (acquisitions) => {
+					assert(acquisitions.length > 0, "LayerBackend disposal waits for in-flight acquisition", `disposeAll did not report a pending acquisition for tag "${ContractService.serviceTag}"`);
+					callbackInvoked = true;
+					observedPendingAcquisitions = Promise.allSettled(acquisitions).then(() => {
+						assert(acquisitionCompleted, "LayerBackend disposal waits for in-flight acquisition", `disposeAll reported an acquisition that settled before tag "${ContractService.serviceTag}" completed`);
+					});
+					callbackCompleted = callbackGate.then(() => void 0);
+					return callbackCompleted;
+				} });
+				assert(disposalResult !== void 0 && isPromiseLike(disposalResult), "LayerBackend disposal waits for in-flight acquisition", `disposeAll did not await the pending-acquisition callback for tag "${ContractService.serviceTag}"`);
+				disposing = Promise.resolve(disposalResult);
+				const disposalReaction = disposing.then(() => {
+					disposalSettled = true;
+				}, () => {
+					disposalSettled = true;
+				});
+				assert(callbackInvoked, "LayerBackend disposal waits for in-flight acquisition", `disposeAll did not synchronously invoke the pending-acquisition callback for tag "${ContractService.serviceTag}"`);
+				const callbackCompletionBarrier = (callbackCompleted ?? fail("LayerBackend disposal waits for in-flight acquisition", `the pending-acquisition callback for tag "${ContractService.serviceTag}" did not return a completion Promise`)).then(() => {
+					callbackCompletionReactionObserved = true;
+				});
+				releaseCallbackGate();
+				await callbackCompletionBarrier;
+				assert(callbackCompletionReactionObserved, "LayerBackend disposal waits for in-flight acquisition", `the pending-acquisition callback for tag "${ContractService.serviceTag}" did not complete`);
+				assert(!acquisitionCompleted, "LayerBackend disposal waits for in-flight acquisition", `the pending acquisition for tag "${ContractService.serviceTag}" completed before disposal released it`);
+				assert(!disposalSettled, "LayerBackend disposal waits for in-flight acquisition", `disposeAll settled after its pending-acquisition callback completed but before tag "${ContractService.serviceTag}" completed`);
+				releaseAcquisition();
+				if (observedPendingAcquisitions === void 0) fail("LayerBackend disposal waits for in-flight acquisition", `disposeAll did not observe a pending acquisition for tag "${ContractService.serviceTag}"`);
+				await Promise.all([
+					resolving,
+					observedPendingAcquisitions,
+					disposing,
+					disposalReaction
+				]);
+			} finally {
+				releaseCallbackGate();
+				releaseAcquisition();
+				const pending = [resolving];
+				if (observedPendingAcquisitions !== void 0) pending.push(observedPendingAcquisitions);
+				if (disposing !== void 0) pending.push(disposing);
+				await Promise.allSettled(pending);
+			}
+		});
+	}),
+	layerScenario("LayerBackend disposal clears registrations and supports reuse", async () => {
+		await withBackend(options, async (backend) => {
+			const first = new ContractService();
+			await backend.register({
+				service: ContractService,
+				acquire: () => first
+			});
+			assert(await backend.resolve(ContractService) === first, "LayerBackend disposal clears registrations and supports reuse", `expected the first registration for tag "${ContractService.serviceTag}" to resolve before disposal`);
+			await backend.disposeAll();
+			const missingCause = await rejected(Promise.resolve().then(() => backend.resolve(ContractService)), "LayerBackend disposal clears registrations and supports reuse", `resolution after disposing tag "${ContractService.serviceTag}"`);
+			expectMissingService(missingCause, ContractService, "LayerBackend disposal clears registrations and supports reuse");
+			const second = new ContractService();
+			await backend.register({
+				service: ContractService,
+				acquire: () => second
+			});
+			assert(await backend.resolve(ContractService) === second, "LayerBackend disposal clears registrations and supports reuse", `expected a fresh instance for reused tag "${ContractService.serviceTag}" after disposal`);
+		});
+	}),
+	layerScenario("LayerBackend repeated disposal is safe", async () => {
+		await withBackend(options, async (backend) => {
+			await backend.disposeAll();
+			await backend.disposeAll();
+		});
+	}),
+	layerScenario("LayerBackend does not execute Layer release callbacks", async () => {
+		await withBackend(options, async (backend) => {
+			let releases = 0;
+			const registration = Layer.scoped(ContractService, () => new ContractService(), () => {
+				releases++;
+			}).providers[0] ?? fail("LayerBackend does not execute Layer release callbacks", `Layer did not retain the provider for tag "${ContractService.serviceTag}"`);
+			await backend.register(registration);
+			await backend.resolve(ContractService);
+			await backend.disposeAll();
+			assert(releases === 0, "LayerBackend does not execute Layer release callbacks", `backend disposal executed ${releases} Layer release callback(s) for tag "${ContractService.serviceTag}"`);
+		});
+	})
+];
+const makeResolver = () => {
+	const services = /* @__PURE__ */ new Map();
+	return { resolve(token) {
+		const service = services.get(token);
+		if (service === void 0) throw new Error(`No test Service is registered for "${token.serviceTag}"`);
+		return service;
+	} };
+};
+const makeContext = (scope, resolver) => ({
+	scope,
+	resolver,
+	resolutionPath: []
+});
+const withStorage = async (options, run) => {
+	const storage = options.makeStorage();
+	try {
+		return await run(storage);
+	} finally {
+		await options.cleanup?.(storage);
+	}
+};
+const expectMissingContext = (cause, options, scenario) => {
+	const isMissing = options.isMissingContextError ?? ((cause) => cause instanceof RuntimeContextNotConfiguredError);
+	assert(isMissing(cause), scenario, `expected the declared missing-context error for ${options.concurrency} storage, received ${describeCause(cause)}`);
+};
+const expectOverlap = (cause, options, scenario) => {
+	const isOverlap = options.isOverlapError ?? ((cause) => cause instanceof RuntimeContextOverlapError);
+	assert(isOverlap(cause), scenario, `expected the declared overlap error for sequential storage, received ${describeCause(cause)}`);
+};
+const closeScopes = async (...scopes) => {
+	const failures = [];
+	for (const scope of scopes) try {
+		await scope.close();
+	} catch (cause) {
+		failures.push(cause);
+	}
+	if (failures.length === 1) throw failures[0];
+	if (failures.length > 1) throw new AggregateError(failures, "Contract Scope cleanup failed");
+};
+/**
+* Return runner-neutral scenarios for a RuntimeContextStorage implementation.
+*
+* Every scenario creates a fresh storage and invokes `cleanup` in `finally`,
+* so consumers can register `scenario.run` directly with their test runner.
+*/
+const runtimeContextStorageContract = (options) => {
+	const scenarios = [
+		layerScenario("RuntimeContextStorage exposes context synchronously and after await", async () => {
+			await withStorage(options, async (storage) => {
+				const scope = Scope.make();
+				const context = makeContext(scope, makeResolver());
+				try {
+					await storage.run(context, async () => {
+						assert(storage.current() === context, "RuntimeContextStorage exposes context synchronously and after await", "current() did not return the context synchronously inside run()");
+						await Promise.resolve();
+						assert(storage.current() === context, "RuntimeContextStorage exposes context synchronously and after await", "current() did not retain the context after Promise suspension");
+					});
+				} finally {
+					await scope.close();
+				}
+			});
+		}),
+		layerScenario("RuntimeContextStorage restores parent context after nested execution", async () => {
+			await withStorage(options, async (storage) => {
+				const rootScope = Scope.make();
+				const childScope = rootScope.fork();
+				const resolver = makeResolver();
+				const root = makeContext(rootScope, resolver);
+				try {
+					await storage.run(root, async () => {
+						await ServiceRuntime.run(resolver, async () => {
+							const serviceContext = storage.current();
+							assert(serviceContext !== root && serviceContext.resolver === resolver, "RuntimeContextStorage restores parent context after nested execution", "ServiceRuntime.run did not preserve the parent resolver lineage");
+							await Scope.provide(childScope, async () => {
+								const scopeContext = storage.current();
+								assert(scopeContext.scope === childScope && scopeContext.resolver === resolver, "RuntimeContextStorage restores parent context after nested execution", "Scope.provide did not preserve the parent Service lineage");
+								await Promise.resolve();
+								assert(storage.current() === scopeContext, "RuntimeContextStorage restores parent context after nested execution", "derived Scope context changed after Promise suspension");
+							});
+							assert(storage.current() === serviceContext, "RuntimeContextStorage restores parent context after nested execution", "parent Service context was not restored after Scope.provide");
+						}, storage);
+						assert(storage.current() === root, "RuntimeContextStorage restores parent context after nested execution", "root context was not restored after ServiceRuntime.run");
+					});
+				} finally {
+					await closeScopes(childScope, rootScope);
+				}
+			});
+		}),
+		layerScenario("RuntimeContextStorage restores context after synchronous throw", async () => {
+			await withStorage(options, async (storage) => {
+				const scope = Scope.make();
+				const context = makeContext(scope, makeResolver());
+				const failure = /* @__PURE__ */ new Error("contract synchronous failure");
+				try {
+					const cause = await rejected(Promise.resolve().then(() => storage.run(context, () => {
+						throw failure;
+					})), "RuntimeContextStorage restores context after synchronous throw", "the synchronous callback failure");
+					assert(cause === failure, "RuntimeContextStorage restores context after synchronous throw", `expected the original synchronous failure, received ${describeCause(cause)}`);
+					expectMissingContext(await rejected(Promise.resolve().then(() => storage.current()), "RuntimeContextStorage restores context after synchronous throw", "current() outside run()"), options, "RuntimeContextStorage restores context after synchronous throw");
+				} finally {
+					await scope.close();
+				}
+			});
+		}),
+		layerScenario("RuntimeContextStorage restores context after Promise rejection", async () => {
+			await withStorage(options, async (storage) => {
+				const scope = Scope.make();
+				const context = makeContext(scope, makeResolver());
+				const failure = /* @__PURE__ */ new Error("contract async failure");
+				try {
+					const cause = await rejected(storage.run(context, async () => {
+						await Promise.resolve();
+						throw failure;
+					}), "RuntimeContextStorage restores context after Promise rejection", "the asynchronous callback failure");
+					assert(cause === failure, "RuntimeContextStorage restores context after Promise rejection", `expected the original asynchronous failure, received ${describeCause(cause)}`);
+					expectMissingContext(await rejected(Promise.resolve().then(() => storage.current()), "RuntimeContextStorage restores context after Promise rejection", "current() outside run()"), options, "RuntimeContextStorage restores context after Promise rejection");
+				} finally {
+					await scope.close();
+				}
+			});
+		}),
+		layerScenario("RuntimeContextStorage preserves custom internal failures", async () => {
+			await withStorage(options, async (storage) => {
+				const failure = /* @__PURE__ */ new Error("contract storage failure");
+				const faultyStorage = {
+					run: (context, program) => storage.run(context, program),
+					current: () => {
+						throw failure;
+					}
+				};
+				const cause = await rejected(Promise.resolve().then(() => ServiceRuntime.run(makeResolver(), () => void 0, faultyStorage)), "RuntimeContextStorage preserves custom internal failures", "a custom storage failure");
+				assert(cause === failure, "RuntimeContextStorage preserves custom internal failures", `expected the original custom failure, received ${describeCause(cause)}`);
+			});
+		}),
+		layerScenario("Scope closes when RuntimeContextStorage.run throws synchronously", async () => {
+			await withStorage(options, async (storage) => {
+				const parent = Scope.make();
+				const child = parent.fork();
+				const storageFailure = /* @__PURE__ */ new Error("contract close storage failure");
+				const closeFailure = /* @__PURE__ */ new Error("contract close finalizer failure");
+				const outcome = {
+					status: "failure",
+					cause: closeFailure
+				};
+				const events = [];
+				const faultyStorage = {
+					run: () => {
+						throw storageFailure;
+					},
+					current: () => storage.current()
+				};
+				child.addFinalizer((childOutcome) => {
+					events.push(`child:${childOutcome.status}`);
+				});
+				parent.addFinalizer((parentOutcome) => {
+					events.push(`first:${parentOutcome.status}`);
+					throw closeFailure;
+				});
+				parent.addFinalizer((parentOutcome) => {
+					events.push(`second:${parentOutcome.status}`);
+				});
+				ScopeRuntime.bind(parent, faultyStorage);
+				const firstClose = parent.close(outcome);
+				const secondClose = parent.close();
+				assert(secondClose === firstClose, "Scope closes when RuntimeContextStorage.run throws synchronously", "later close did not share the original close Promise");
+				const cause = await rejected(firstClose, "Scope closes when RuntimeContextStorage.run throws synchronously", "the storage-safe close");
+				assert(cause instanceof ScopeCloseError && cause.causes.length === 2 && cause.causes[0] === storageFailure && cause.causes[1] === closeFailure, "Scope closes when RuntimeContextStorage.run throws synchronously", `expected storage then finalizer cleanup failures, received ${describeCause(cause)}`);
+				assert(events.join(",") === "child:failure,second:failure,first:failure", "Scope closes when RuntimeContextStorage.run throws synchronously", `expected child-first LIFO finalizers with the original outcome, received ${events.join(",")}`);
+				const closedCause = await rejected(Promise.resolve().then(() => parent.addFinalizer(() => void 0)), "Scope closes when RuntimeContextStorage.run throws synchronously", "registration after close");
+				assert(closedCause instanceof ScopeClosedError, "Scope closes when RuntimeContextStorage.run throws synchronously", `Scope remained open after storage failure (${describeCause(closedCause)})`);
+			});
+		})
+	];
+	if (options.concurrency === "concurrent") scenarios.push(layerScenario("RuntimeContextStorage isolates concurrent roots", async () => {
+		await withStorage(options, async (storage) => {
+			const firstScope = Scope.make();
+			const secondScope = Scope.make();
+			const first = makeContext(firstScope, makeResolver());
+			const second = makeContext(secondScope, makeResolver());
+			let releaseFirst;
+			let releaseSecond;
+			let firstStarted;
+			let secondStarted;
+			const firstMayFinish = new Promise((resolve) => {
+				releaseFirst = resolve;
+			});
+			const secondMayFinish = new Promise((resolve) => {
+				releaseSecond = resolve;
+			});
+			const firstStartedPromise = new Promise((resolve) => {
+				firstStarted = resolve;
+			});
+			const secondStartedPromise = new Promise((resolve) => {
+				secondStarted = resolve;
+			});
+			const runs = [];
+			try {
+				const firstRun = Promise.resolve(storage.run(first, async () => {
+					firstStarted();
+					await firstMayFinish;
+					return storage.current();
+				}));
+				runs.push(firstRun);
+				const secondRun = Promise.resolve(storage.run(second, async () => {
+					secondStarted();
+					await secondMayFinish;
+					return storage.current();
+				}));
+				runs.push(secondRun);
+				await Promise.all([firstStartedPromise, secondStartedPromise]);
+				releaseFirst();
+				releaseSecond();
+				const [firstCurrent, secondCurrent] = await Promise.all([firstRun, secondRun]);
+				assert(firstCurrent === first && secondCurrent === second, "RuntimeContextStorage isolates concurrent roots", "overlapping roots observed another context frame");
+			} finally {
+				releaseFirst();
+				releaseSecond();
+				await Promise.allSettled(runs);
+				await closeScopes(firstScope, secondScope);
+			}
+		});
+	}), layerScenario("RuntimeContextStorage isolates concurrent derived siblings", async () => {
+		await withStorage(options, async (storage) => {
+			const rootScope = Scope.make();
+			const firstScope = rootScope.fork();
+			const secondScope = rootScope.fork();
+			const root = makeContext(rootScope, makeResolver());
+			let releaseFirst;
+			let releaseSecond;
+			let firstStarted;
+			let secondStarted;
+			const firstMayFinish = new Promise((resolve) => {
+				releaseFirst = resolve;
+			});
+			const secondMayFinish = new Promise((resolve) => {
+				releaseSecond = resolve;
+			});
+			const firstStartedPromise = new Promise((resolve) => {
+				firstStarted = resolve;
+			});
+			const secondStartedPromise = new Promise((resolve) => {
+				secondStarted = resolve;
+			});
+			const runs = [];
+			try {
+				await storage.run(root, async () => {
+					try {
+						const firstRun = Promise.resolve(Scope.provide(firstScope, async () => {
+							firstStarted();
+							await firstMayFinish;
+							return storage.current();
+						}));
+						runs.push(firstRun);
+						const secondRun = Promise.resolve(Scope.provide(secondScope, async () => {
+							secondStarted();
+							await secondMayFinish;
+							return storage.current();
+						}));
+						runs.push(secondRun);
+						await Promise.all([firstStartedPromise, secondStartedPromise]);
+						releaseFirst();
+						releaseSecond();
+						const [firstContext, secondContext] = await Promise.all([firstRun, secondRun]);
+						assert(firstContext.scope === firstScope && secondContext.scope === secondScope, "RuntimeContextStorage isolates concurrent derived siblings", "overlapping derived siblings observed another Scope context");
+						assert(storage.current() === root, "RuntimeContextStorage isolates concurrent derived siblings", "root context was not restored after concurrent derived siblings settled");
+					} finally {
+						releaseFirst();
+						releaseSecond();
+						await Promise.allSettled(runs);
+					}
+				});
+			} finally {
+				releaseFirst();
+				releaseSecond();
+				await Promise.allSettled(runs);
+				await closeScopes(firstScope, secondScope, rootScope);
+			}
+		});
+	}));
+	else scenarios.push(layerScenario("RuntimeContextStorage rejects overlap and remains reusable", async () => {
+		await withStorage(options, async (storage) => {
+			const firstScope = Scope.make();
+			const secondScope = Scope.make();
+			const first = makeContext(firstScope, makeResolver());
+			const second = makeContext(secondScope, makeResolver());
+			let releaseFirst;
+			let firstStarted;
+			const firstMayFinish = new Promise((resolve) => {
+				releaseFirst = resolve;
+			});
+			const firstStartedPromise = new Promise((resolve) => {
+				firstStarted = resolve;
+			});
+			const runs = [];
+			try {
+				const firstRun = Promise.resolve(storage.run(first, async () => {
+					firstStarted();
+					await firstMayFinish;
+					return storage.current();
+				}));
+				runs.push(firstRun);
+				await firstStartedPromise;
+				const overlapCause = await rejected(Promise.resolve().then(() => storage.run(second, () => storage.current())), "RuntimeContextStorage rejects overlap and remains reusable", "an overlapping root run");
+				expectOverlap(overlapCause, options, "RuntimeContextStorage rejects overlap and remains reusable");
+				releaseFirst();
+				assert(await firstRun === first, "RuntimeContextStorage rejects overlap and remains reusable", "the first context did not remain intact after rejected overlap");
+				assert(storage.run(second, () => storage.current()) === second, "RuntimeContextStorage rejects overlap and remains reusable", "storage was not reusable after rejected overlap");
+			} finally {
+				releaseFirst();
+				await Promise.allSettled(runs);
+				await closeScopes(firstScope, secondScope);
+			}
+		});
+	}), layerScenario("RuntimeContextStorage rejects overlapping derived siblings and remains reusable", async () => {
+		await withStorage(options, async (storage) => {
+			const rootScope = Scope.make();
+			const firstScope = rootScope.fork();
+			const secondScope = rootScope.fork();
+			const root = makeContext(rootScope, makeResolver());
+			let releaseFirst;
+			let firstStarted;
+			const firstMayFinish = new Promise((resolve) => {
+				releaseFirst = resolve;
+			});
+			const firstStartedPromise = new Promise((resolve) => {
+				firstStarted = resolve;
+			});
+			const runs = [];
+			try {
+				await storage.run(root, async () => {
+					try {
+						const firstRun = Promise.resolve(Scope.provide(firstScope, async () => {
+							firstStarted();
+							await firstMayFinish;
+							return storage.current();
+						}));
+						runs.push(firstRun);
+						await firstStartedPromise;
+						let secondRan = false;
+						const overlapCause = await rejected(Promise.resolve().then(() => Scope.provide(secondScope, () => {
+							secondRan = true;
+							return storage.current();
+						})), "RuntimeContextStorage rejects overlapping derived siblings and remains reusable", "an overlapping derived sibling run");
+						expectOverlap(overlapCause, options, "RuntimeContextStorage rejects overlapping derived siblings and remains reusable");
+						assert(!secondRan, "RuntimeContextStorage rejects overlapping derived siblings and remains reusable", "the rejected derived sibling callback ran");
+						releaseFirst();
+						const firstContext = await firstRun;
+						assert(firstContext.scope === firstScope, "RuntimeContextStorage rejects overlapping derived siblings and remains reusable", "the first derived sibling context changed after rejected overlap");
+						assert(storage.current() === root, "RuntimeContextStorage rejects overlapping derived siblings and remains reusable", "root context was not restored after the first derived sibling settled");
+					} finally {
+						releaseFirst();
+						await Promise.allSettled(runs);
+					}
+				});
+				const reusable = makeContext(secondScope, makeResolver());
+				assert(storage.run(reusable, () => storage.current()) === reusable, "RuntimeContextStorage rejects overlapping derived siblings and remains reusable", "storage was not reusable after rejected derived sibling overlap");
+			} finally {
+				releaseFirst();
+				await Promise.allSettled(runs);
+				await closeScopes(firstScope, secondScope, rootScope);
+			}
+		});
+	}));
+	const makeCompanionStorage = options.makeCompanionStorage;
+	if (makeCompanionStorage) scenarios.push(layerScenario("RuntimeContextStorage interoperates without leaking frames", async () => {
+		await withStorage(options, async (storage) => {
+			const companion = makeCompanionStorage();
+			const outerScope = Scope.make();
+			const innerScope = Scope.make();
+			const outer = makeContext(outerScope, makeResolver());
+			const inner = makeContext(innerScope, makeResolver());
+			try {
+				await storage.run(outer, async () => {
+					await companion.run(inner, async () => {
+						assert(companion.current() === inner, "RuntimeContextStorage interoperates without leaking frames", "companion storage did not expose its own context");
+						await Promise.resolve();
+						assert(companion.current() === inner, "RuntimeContextStorage interoperates without leaking frames", "companion storage lost its context after Promise suspension");
+					});
+					assert(storage.current() === outer, "RuntimeContextStorage interoperates without leaking frames", "companion storage leaked its frame into the primary storage");
+					expectMissingContext(await rejected(Promise.resolve().then(() => companion.current()), "RuntimeContextStorage interoperates without leaking frames", "companion current() after its run() settled"), options, "RuntimeContextStorage interoperates without leaking frames");
+				});
+				expectMissingContext(await rejected(Promise.resolve().then(() => storage.current()), "RuntimeContextStorage interoperates without leaking frames", "primary current() after its run() settled"), options, "RuntimeContextStorage interoperates without leaking frames");
+			} finally {
+				try {
+					await closeScopes(outerScope, innerScope);
+				} finally {
+					await options.cleanup?.(companion);
+				}
+			}
+		});
+	}));
+	return scenarios;
+};
+//#endregion
+//#region src/testing/recorded-runtime-observer.ts
+const immutableView = (events) => Object.freeze([...events]);
+/** Records Runtime lifecycle events for assertions in tests. */
+var RecordedRuntimeObserver = class RecordedRuntimeObserver {
+	serviceResolutionEvents = [];
+	serviceAcquisitionEvents = [];
+	executionStartEvents = [];
+	executionEndEvents = [];
+	resourceReleaseEvents = [];
+	timelineEvents = [];
+	static make() {
+		return new RecordedRuntimeObserver();
+	}
+	onServiceResolve = (event) => {
+		this.record(this.serviceResolutionEvents, event);
+	};
+	onServiceAcquire = (event) => {
+		this.record(this.serviceAcquisitionEvents, event);
+	};
+	onExecutionStart = (event) => {
+		this.record(this.executionStartEvents, event);
+	};
+	onExecutionEnd = (event) => {
+		this.record(this.executionEndEvents, event);
+	};
+	onResourceRelease = (event) => {
+		this.record(this.resourceReleaseEvents, event);
+	};
+	get serviceResolutions() {
+		return immutableView(this.serviceResolutionEvents);
+	}
+	get serviceAcquisitions() {
+		return immutableView(this.serviceAcquisitionEvents);
+	}
+	get executionStarts() {
+		return immutableView(this.executionStartEvents);
+	}
+	get executionEnds() {
+		return immutableView(this.executionEndEvents);
+	}
+	get resourceReleases() {
+		return immutableView(this.resourceReleaseEvents);
+	}
+	get timeline() {
+		return immutableView(this.timelineEvents);
+	}
+	clear() {
+		this.serviceResolutionEvents.length = 0;
+		this.serviceAcquisitionEvents.length = 0;
+		this.executionStartEvents.length = 0;
+		this.executionEndEvents.length = 0;
+		this.resourceReleaseEvents.length = 0;
+		this.timelineEvents.length = 0;
+	}
+	snapshot() {
+		return Object.freeze({
+			serviceResolutions: this.serviceResolutions,
+			serviceAcquisitions: this.serviceAcquisitions,
+			executionStarts: this.executionStarts,
+			executionEnds: this.executionEnds,
+			resourceReleases: this.resourceReleases,
+			timeline: this.timeline
+		});
+	}
+	record(events, event) {
+		events.push(event);
+		this.timelineEvents.push(event);
+	}
+};
+//#endregion
+//#region src/testing/runtime-graph-observer.ts
+const compareStrings = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+const compareEdges = (left, right) => compareStrings(left.from, right.from) || compareStrings(left.to, right.to);
+const freezeNode = (node) => Object.freeze({ ...node });
+const freezeEdge = (edge) => Object.freeze({ ...edge });
+const serviceTags = (path, targetTag) => {
+	const tags = path.map((service) => service.serviceTag);
+	if (tags[tags.length - 1] !== targetTag) tags.push(targetTag);
+	return tags;
+};
+const mermaidLabelPunctuation = /* @__PURE__ */ new Set([
+	"&",
+	"\"",
+	"'",
+	"\\",
+	"[",
+	"]",
+	"(",
+	")",
+	"{",
+	"}",
+	"|",
+	"#",
+	";",
+	":",
+	"<",
+	">",
+	"=",
+	"`",
+	"*",
+	"_",
+	"~",
+	"!",
+	"^",
+	"$"
+]);
+const isMermaidLabelControl = (character, codePoint) => codePoint <= 31 || codePoint >= 127 && codePoint <= 159 || codePoint >= 55296 && codePoint <= 57343 || /\s/u.test(character) && character !== " " || /\p{Cf}/u.test(character);
+/**
+* Escape Mermaid syntax while keeping the decoded label readable.
+*
+* Mermaid's documented `#number;` form is a syntax-level escape. Encoding the
+* entity introducers themselves prevents label text from creating a second
+* entity, while encoding Markdown and HTML punctuation keeps it out of the
+* renderer's interpretation paths.
+*/
+const escapeMermaidLabel = (label) => {
+	let escaped = "";
+	for (const character of label) {
+		const codePoint = character.codePointAt(0);
+		if (codePoint === void 0) continue;
+		if (isMermaidLabelControl(character, codePoint) || mermaidLabelPunctuation.has(character)) escaped += `#${codePoint};`;
+		else escaped += character;
+	}
+	return escaped;
+};
+/** Encode a string as a Mermaid-safe, injective and registration-order-independent ID. */
+const mermaidId = (prefix, value) => {
+	const codeUnits = [];
+	for (let index = 0; index < value.length; index += 1) codeUnits.push(value.charCodeAt(index).toString(16).padStart(4, "0"));
+	return `${prefix}${codeUnits.join("_") || "empty"}`;
+};
+/**
+* Observe the public Runtime resolution and acquisition events as a diagnostic graph.
+*
+* The graph is deliberately an observation of paths emitted by Runtime. It does
+* not inspect Layer provenance, retain Service instances, or plan dependencies.
+*/
+var RuntimeGraphObserver = class RuntimeGraphObserver {
+	includeFailures;
+	rootLabel;
+	nodes = /* @__PURE__ */ new Map();
+	edges = /* @__PURE__ */ new Map();
+	rootEdges = /* @__PURE__ */ new Map();
+	constructor(includeFailures, rootLabel) {
+		this.includeFailures = includeFailures;
+		this.rootLabel = rootLabel;
+	}
+	/** Create an empty Runtime graph observer. */
+	static make(options = {}) {
+		if (typeof options !== "object" || options === null) throw new TypeError("RuntimeGraphObserver options must be an object");
+		if (options.includeFailures !== void 0 && typeof options.includeFailures !== "boolean") throw new TypeError("RuntimeGraphObserver includeFailures must be a boolean");
+		if (options.rootLabel !== void 0 && typeof options.rootLabel !== "string") throw new TypeError("RuntimeGraphObserver rootLabel must be a string");
+		return new RuntimeGraphObserver(options.includeFailures ?? true, options.rootLabel);
+	}
+	onServiceResolve = (event) => {
+		const targetTag = event.service.serviceTag;
+		const path = serviceTags(event.resolutionPath, targetTag);
+		const node = this.ensureNode(targetTag);
+		this.ensurePath(path);
+		node.resolutions += 1;
+		if (event.outcome.status === "failure" && this.includeFailures) node.failures += 1;
+		const parentTag = path[path.length - 2];
+		if (parentTag === void 0) {
+			if (this.rootLabel !== void 0) this.rootEdges.set(targetTag, (this.rootEdges.get(targetTag) ?? 0) + 1);
+			return;
+		}
+		const targets = this.edges.get(parentTag) ?? /* @__PURE__ */ new Map();
+		const edge = targets.get(targetTag) ?? (() => {
+			const created = {
+				from: parentTag,
+				to: targetTag,
+				resolutions: 0
+			};
+			targets.set(targetTag, created);
+			return created;
+		})();
+		edge.resolutions += 1;
+		this.edges.set(parentTag, targets);
+	};
+	onServiceAcquire = (event) => {
+		const targetTag = event.service.serviceTag;
+		const path = serviceTags(event.resolutionPath, targetTag);
+		const node = this.ensureNode(targetTag);
+		this.ensurePath(path);
+		node.acquisitions += 1;
+		if (event.outcome.status === "failure" && this.includeFailures) node.failures += 1;
+	};
+	/** Return a fresh, deeply detached and sorted graph snapshot. */
+	toJSON() {
+		const nodes = Object.freeze([...this.nodes.entries()].sort(([left], [right]) => compareStrings(left, right)).map(([tag, counters]) => freezeNode({
+			tag,
+			resolutions: counters.resolutions,
+			acquisitions: counters.acquisitions,
+			failures: counters.failures
+		})));
+		const edges = Object.freeze([...this.edges.values()].flatMap((targets) => [...targets.values()]).map((edge) => freezeEdge({ ...edge })).sort(compareEdges));
+		return Object.freeze({
+			nodes,
+			edges
+		});
+	}
+	/** Render the current graph as deterministic Mermaid flowchart source. */
+	toMermaid() {
+		const snapshot = this.toJSON();
+		const serviceIds = new Map(snapshot.nodes.map((node) => [node.tag, mermaidId("service_", node.tag)]));
+		const lines = ["flowchart TD"];
+		const rootTargets = [...this.rootEdges.entries()].sort(([left], [right]) => compareStrings(left, right));
+		const root = this.rootLabel !== void 0 && rootTargets.length > 0 ? {
+			id: mermaidId("root_", this.rootLabel),
+			label: this.rootLabel
+		} : void 0;
+		if (root !== void 0) lines.push(`  ${root.id}["${escapeMermaidLabel(root.label)}"]`);
+		for (const node of snapshot.nodes) {
+			const id = serviceIds.get(node.tag);
+			if (id !== void 0) lines.push(`  ${id}["${escapeMermaidLabel(node.tag)}"]`);
+		}
+		if (root !== void 0) for (const [targetTag, resolutions] of rootTargets) {
+			const targetId = serviceIds.get(targetTag);
+			if (targetId !== void 0) lines.push(`  ${root.id} -->|${resolutions}| ${targetId}`);
+		}
+		for (const edge of snapshot.edges) {
+			const fromId = serviceIds.get(edge.from);
+			const toId = serviceIds.get(edge.to);
+			if (fromId !== void 0 && toId !== void 0) lines.push(`  ${fromId} -->|${edge.resolutions}| ${toId}`);
+		}
+		return lines.join("\n");
+	}
+	/** Discard all observed graph data while keeping this observer reusable. */
+	clear() {
+		this.nodes.clear();
+		this.edges.clear();
+		this.rootEdges.clear();
+	}
+	ensureNode(tag) {
+		const existing = this.nodes.get(tag);
+		if (existing !== void 0) return existing;
+		const node = {
+			resolutions: 0,
+			acquisitions: 0,
+			failures: 0
+		};
+		this.nodes.set(tag, node);
+		return node;
+	}
+	ensurePath(path) {
+		for (const tag of path) this.ensureNode(tag);
+	}
+};
+//#endregion
+//#region src/testing/test-runtime.ts
+/**
+* Thrown when the TestRuntime recorder contains an execution start or end
+* event without its matching event at final disposal.
+*/
+var TestRuntimeObserverError = class extends Error {
+	unmatchedStarts;
+	unmatchedEnds;
+	constructor(unmatchedStarts, unmatchedEnds) {
+		const startLabel = `${unmatchedStarts.length} start${unmatchedStarts.length === 1 ? "" : "s"}`;
+		const endLabel = `${unmatchedEnds.length} end${unmatchedEnds.length === 1 ? "" : "s"}`;
+		super(`TestRuntime found unmatched execution events: ${startLabel} without an end, ${endLabel} without a start`);
+		this.name = "TestRuntimeObserverError";
+		this.unmatchedStarts = Object.freeze([...unmatchedStarts]);
+		this.unmatchedEnds = Object.freeze([...unmatchedEnds]);
+	}
+};
+/**
+* A disposable test boundary backed by the real Layer and Runtime
+* implementations.
+*/
+var TestRuntime = class TestRuntime {
+	runtime;
+	observer;
+	clock;
+	logger;
+	random;
+	idGenerator;
+	disposalPromise;
+	constructor(runtime, observer, clock, logger, random, idGenerator) {
+		this.runtime = runtime;
+		this.observer = observer;
+		this.clock = clock;
+		this.logger = logger;
+		this.random = random;
+		this.idGenerator = idGenerator;
+	}
+	static async make(layer, options) {
+		const resolvedOptions = options === void 0 ? {} : options;
+		return TestRuntime.makeInternal(layer, resolvedOptions);
+	}
+	static async makeInternal(layer, options) {
+		const observer = RecordedRuntimeObserver.make();
+		const composedLayer = composeTestLayer(layer, options);
+		const runtimeOptions = {
+			...options,
+			backend: options.backend ?? new MapLayerBackend(),
+			observers: [observer, ...options.observers ?? []]
+		};
+		const typedLayer = composedLayer;
+		const runtime = await Runtime.make(typedLayer, runtimeOptions);
+		return new TestRuntime(runtime, observer, options.clock, options.logger, options.random, options.idGenerator);
+	}
+	/** Run a fully typechecked program in the underlying Runtime. */
+	run(program, options) {
+		return this.runtime.run(program, options);
+	}
+	/** Run a fully typechecked program with an execution-local Layer. */
+	runWith(layer, program, options) {
+		return this.runtime.runWith(layer, program, options);
+	}
+	/** Dispose the underlying Runtime and perform the final recorder consistency check. */
+	dispose(options) {
+		return this.disposeWithInput(options);
+	}
+	/** Release this TestRuntime through JavaScript's async disposal protocol. */
+	[Symbol.asyncDispose]() {
+		return this.dispose();
+	}
+	disposeWithOutcome(outcome) {
+		return this.disposeWithInput(outcome);
+	}
+	disposeWithInput(input) {
+		if (this.disposalPromise !== void 0) return this.disposalPromise;
+		const disposal = input === void 0 ? this.runtime.dispose() : isScopeOutcome(input) ? this.runtime.dispose(input) : this.runtime.dispose(input);
+		this.disposalPromise = disposal.then(() => this.assertObserverConsistency(), (cause) => {
+			const observerFailure = this.observerConsistencyFailure();
+			if (observerFailure === void 0) throw cause;
+			const causes = cause instanceof LayerDisposeError ? cause.causes : [cause];
+			throw new LayerDisposeError([...causes, observerFailure]);
+		});
+		return this.disposalPromise;
+	}
+	assertObserverConsistency() {
+		const failure = this.observerConsistencyFailure();
+		if (failure !== void 0) throw failure;
+	}
+	observerConsistencyFailure() {
+		const unmatched = findUnmatchedExecutionEvents(this.observer.executionStarts, this.observer.executionEnds);
+		if (unmatched.starts.length === 0 && unmatched.ends.length === 0) return;
+		return new TestRuntimeObserverError(unmatched.starts, unmatched.ends);
+	}
+	static async use(layer, optionsOrUse, maybeUse) {
+		let use;
+		let resolvedOptions;
+		if (typeof optionsOrUse === "function") {
+			use = optionsOrUse;
+			resolvedOptions = {};
+		} else {
+			use = maybeUse;
+			resolvedOptions = optionsOrUse;
+		}
+		if (use === void 0) throw new TypeError("TestRuntime.use requires a callback");
+		const test = await TestRuntime.makeInternal(layer, resolvedOptions);
+		let value;
+		let executionFailed = false;
+		let executionFailure;
+		let outcome;
+		try {
+			value = await use(test);
+			outcome = classifyRuntimeOutcome(value);
+		} catch (cause) {
+			executionFailed = true;
+			executionFailure = cause;
+			outcome = {
+				status: "failure",
+				cause
+			};
+		}
+		try {
+			await test.disposeWithOutcome(outcome);
+		} catch (cleanupFailure) {
+			if (!executionFailed && outcome.status === "success") throw cleanupFailure;
+		}
+		if (executionFailed) throw executionFailure;
+		return value;
+	}
+};
+const isScopeOutcome = (input) => "status" in input;
+const composeTestLayer = (layer, options) => {
+	const overrides = [...options.overrides ?? []];
+	if (options.clock !== void 0) overrides.push(Layer.succeed(Clock, options.clock));
+	if (options.logger !== void 0) overrides.push(Layer.succeed(Logger, options.logger));
+	if (options.random !== void 0) overrides.push(Layer.succeed(Random, options.random));
+	if (options.idGenerator !== void 0) overrides.push(Layer.succeed(IdGenerator, options.idGenerator));
+	const typedLayer = layer;
+	const typedOverrides = overrides;
+	return Layer.override(typedLayer, ...typedOverrides);
+};
+const findUnmatchedExecutionEvents = (starts, ends) => {
+	const endCounts = countExecutionScopes(ends);
+	const unmatchedStarts = [];
+	for (const event of starts) {
+		const count = endCounts.get(event.scope) ?? 0;
+		if (count === 0) unmatchedStarts.push(event);
+		else endCounts.set(event.scope, count - 1);
+	}
+	const startCounts = countExecutionScopes(starts);
+	const unmatchedEnds = [];
+	for (const event of ends) {
+		const count = startCounts.get(event.scope) ?? 0;
+		if (count === 0) unmatchedEnds.push(event);
+		else startCounts.set(event.scope, count - 1);
+	}
+	return {
+		starts: unmatchedStarts,
+		ends: unmatchedEnds
+	};
+};
+const countExecutionScopes = (events) => {
+	const counts = /* @__PURE__ */ new Map();
+	for (const event of events) counts.set(event.scope, (counts.get(event.scope) ?? 0) + 1);
+	return counts;
+};
+//#endregion
+export { ClockTest, ConformanceError, IdGeneratorTest, LoggerTest, MapLayerBackend as MemoryLayerBackend, RandomSeeded, RecordedRuntimeObserver, RuntimeGraphObserver, RuntimeObserver, TestRuntime, TestRuntimeObserverError, layerBackendContract, runtimeContextStorageContract };
+
+//# sourceMappingURL=testing.mjs.map