@shirudo/ddd-kit 3.0.0-rc.4 → 3.0.0-rc.6

package/dist/testing.js

@@ -1,5 +1,4 @@
-import { r as deepEqual } from "./chunks/deep-equal-except.js";
-import { t as isDispatchTrackingOutbox, u as isMintedEvent } from "./chunks/ports.js";
+import { E as deepEqual, t as isDispatchTrackingOutbox, u as isRecordedDomainEvent } from "./chunks/ports.js";
 
 //#region src/testing/contract-assertions.ts
 /**
@@ -80,12 +79,13 @@ function gatedContractTest(gate, test) {
 }
 /**
 * Identities of an in-memory pending batch, with the shared precondition
-* that every event is recorded (minted). The `requirement` names the
-* suite-specific rule the harness violated when an event is unminted.
+* that every event carries the recorded brand. The `requirement` names
+* the suite-specific rule the harness violated when an event is not
+* recorded.
 */
-function mintedPendingEventIds(events, requirement) {
+function recordedPendingEventIds(events, requirement) {
 	return events.map((event) => {
-		assert(typeof event === "object" && event !== null && isMintedEvent(event), requirement);
+		assert(typeof event === "object" && event !== null && isRecordedDomainEvent(event), requirement);
 		return event.eventId;
 	});
 }
@@ -276,7 +276,8 @@ function createCommandOutboxContractTests(harness) {
 					}
 				};
 				assert(!deepEqual(conflict.messages, original.messages), "harness contract: createCommand must return distinct content per seed, or the manufactured conflict is an exact retry");
-				assert(await captureRejection(env.addCommitted([conflict])) !== void 0, "a reused origin event id with different messages must reject");
+				const rejection = await captureRejection(env.addCommitted([conflict]));
+				assert(rejection !== void 0, "a reused origin event id with different messages must reject");
 				const stored = await env.readAll();
 				assertEqual(stored.length, 1, "a conflicting retry must not append another receipt");
 				assert(deepEqual(stored[0], original), "a conflicting retry must not replace the original receipt");
@@ -313,8 +314,10 @@ function createCommandOutboxContractTests(harness) {
 					}
 				}];
 				for (const { fact, candidate } of conflicts) {
-					assert(await captureRejection(env.addCommitted([candidate])) !== void 0, `a reused origin event id with a different source.${fact} must reject`);
-					assert(deepEqual(await env.readAll(), [original]), `a source.${fact} conflict must leave the original receipt unchanged`);
+					const rejection = await captureRejection(env.addCommitted([candidate]));
+					assert(rejection !== void 0, `a reused origin event id with a different source.${fact} must reject`);
+					const stored = await env.readAll();
+					assert(deepEqual(stored, [original]), `a source.${fact} conflict must leave the original receipt unchanged`);
 				}
 			})
 		},
@@ -347,8 +350,10 @@ function createCommandOutboxContractTests(harness) {
 							}
 						}
 					};
-					assert(await captureRejection(env.addCommitted([conflict])) !== void 0, `a reused origin event id with a different position.${fact} must reject`);
-					assert(deepEqual(await env.readAll(), [original]), `a position.${fact} conflict must leave the original receipt unchanged`);
+					const rejection = await captureRejection(env.addCommitted([conflict]));
+					assert(rejection !== void 0, `a reused origin event id with a different position.${fact} must reject`);
+					const stored = await env.readAll();
+					assert(deepEqual(stored, [original]), `a position.${fact} conflict must leave the original receipt unchanged`);
 				}
 			})
 		},
@@ -366,7 +371,8 @@ function createCommandOutboxContractTests(harness) {
 					}
 				};
 				assert(!deepEqual(conflictingOriginal.messages, original.messages), "harness contract: createCommand must return distinct content per seed, or the manufactured conflict is an exact retry");
-				assert(await captureRejection(env.addCommitted([newCommit, conflictingOriginal])) !== void 0, "a batch containing a conflicting origin must reject");
+				const rejection = await captureRejection(env.addCommitted([newCommit, conflictingOriginal]));
+				assert(rejection !== void 0, "a batch containing a conflicting origin must reject");
 				const stored = await env.readAll();
 				assertEqual(stored.length, 1, "a rejected batch must not leave its earlier new receipt behind");
 				assert(deepEqual(stored[0], original), "a rejected batch must preserve the pre-existing receipt");
@@ -412,7 +418,8 @@ function createCommandOutboxContractTests(harness) {
 					}
 				}];
 				await env.addCommitted(multiEventCommit);
-				assert(deepEqual(await env.readAll(), multiEventCommit), "a multi-event commit must retain its shared version, sequence, and size for every receipt");
+				const stored = await env.readAll();
+				assert(deepEqual(stored, multiEventCommit), "a multi-event commit must retain its shared version, sequence, and size for every receipt");
 			})
 		},
 		{
@@ -558,7 +565,8 @@ function createDeadlineStoreContractTests(harness) {
 					await env.store.cancel("s", "drop");
 					await env.store.cancel("s", "never-scheduled");
 				});
-				assert(deepEqual((await env.store.due(at(T1), 10)).map((d) => d.key), ["keep"]), "cancel must remove the addressed deadline and nothing else");
+				const due = await env.store.due(at(T1), 10);
+				assert(deepEqual(due.map((d) => d.key), ["keep"]), "cancel must remove the addressed deadline and nothing else");
 			})
 		},
 		{
@@ -691,7 +699,8 @@ function createDeadlineStoreContractTests(harness) {
 				const [poison] = await env.store.due(at(T1), 1);
 				assert(poison !== void 0, "expected the earliest due deadline");
 				await env.store.markFailed(poison.deliveryId, /* @__PURE__ */ new Error("boom"));
-				assertEqual((await env.store.due(at(T1), 10)).find((d) => d.deliveryId === poison.deliveryId)?.attempts, 1, "attempts must be surfaced on the record after markFailed");
+				const afterOne = await env.store.due(at(T1), 10);
+				assertEqual(afterOne.find((d) => d.deliveryId === poison.deliveryId)?.attempts, 1, "attempts must be surfaced on the record after markFailed");
 				for (let i = 1; i < ceiling; i++) await env.store.markFailed(poison.deliveryId, /* @__PURE__ */ new Error("boom"));
 				assert((await env.store.due(at(T1), 10)).some((d) => d.key === "healthy"), "deadlines carry no cross-address ordering; a dead-lettered neighbor must not block delivery");
 			})
@@ -794,9 +803,10 @@ function createEsRepositoryContractTests(harness) {
 	const readAll = { limit: 100 };
 	const createAggregateWithId = harness.createAggregateWithId;
 	const snapshotState = harness.snapshotState;
+	const captureSnapshot = harness.captureSnapshot;
 	const load = (repository, id) => loadAggregateOrFail(repository, id, "the stream was not appended or replayed correctly");
 	const streamFor = (id) => harness.streamKeyFor(id);
-	const recordedIds = (events) => mintedPendingEventIds(events, "pending events must be recorded before flush");
+	const recordedIds = (events) => recordedPendingEventIds(events, "pending events must be recorded before flush");
 	const ids = (events) => events.map((event) => {
 		assert(typeof event.eventId === "string" && event.eventId.length > 0, "committed events must carry their persisted eventId");
 		return event.eventId;
@@ -891,7 +901,8 @@ function createEsRepositoryContractTests(harness) {
 					repository.add(aggregate);
 					throw new Error("rollback probe");
 				}));
-				assert(!(await environment.committedStreamEvents(streamFor(aggregate.id), readAll)).exists, "rollback must leave the stream absent");
+				const stream = await environment.committedStreamEvents(streamFor(aggregate.id), readAll);
+				assert(!stream.exists, "rollback must leave the stream absent");
 				assertEqual((await environment.committedOutboxEvents()).length, 0, "rollback must leave the outbox empty");
 				assert(deepEqual(aggregate.pendingEvents, pending), "rollback must retain the exact pending batch");
 			})
@@ -920,10 +931,12 @@ function createEsRepositoryContractTests(harness) {
 				const aggregate = harness.createAggregate();
 				const pending = [...aggregate.pendingEvents];
 				environment.failNextOutboxWrite(/* @__PURE__ */ new Error("outbox failure probe"));
-				assert(await captureRejection(environment.run(async ({ repository }) => {
+				const rejection = await captureRejection(environment.run(async ({ repository }) => {
 					repository.add(aggregate);
-				})) !== void 0, "the outbox failure must reject");
-				assert(!(await environment.committedStreamEvents(streamFor(aggregate.id), readAll)).exists, "stream append must roll back with the outbox");
+				}));
+				assert(rejection !== void 0, "the outbox failure must reject");
+				const stream = await environment.committedStreamEvents(streamFor(aggregate.id), readAll);
+				assert(!stream.exists, "stream append must roll back with the outbox");
 				assertEqual((await environment.committedOutboxEvents()).length, 0, "failed outbox write must commit no envelope");
 				assert(deepEqual(aggregate.pendingEvents, pending), "failed commit must acknowledge none of the event batch");
 			})
@@ -982,9 +995,433 @@ function createEsRepositoryContractTests(harness) {
 			assert(deepEqual(ids(after.events), ids(before.events)), "duplicate add must not modify the existing stream");
 		})
 	}));
+	tests.push(gatedContractTest({
+		capability: "captureSnapshot",
+		satisfiedBy: Boolean(captureSnapshot)
+	}, {
+		name: "snapshot catch-up ends at the stream head and folds only the tail",
+		run: inEnvironment(async (environment) => {
+			assert(captureSnapshot !== void 0, "capability gate");
+			const seeded = await seed(environment);
+			await environment.run(async ({ repository }) => {
+				const loaded = await load(repository, seeded.id);
+				harness.mutate(loaded);
+				repository.update(loaded);
+			});
+			const snapshotted = await environment.run(({ repository }) => load(repository, seeded.id));
+			await captureSnapshot.call(harness, snapshotted, environment);
+			const atHead = await environment.run(({ repository }) => load(repository, seeded.id));
+			assert(atHead.version === snapshotted.version, `a snapshot at the head must load at the head ${snapshotted.version}, not beyond it; got ${atHead.version}`);
+			const winner = await environment.run(async ({ repository }) => {
+				const loaded = await load(repository, seeded.id);
+				harness.mutate(loaded);
+				harness.mutate(loaded);
+				repository.update(loaded);
+				return loaded;
+			});
+			const caughtUp = await environment.run(({ repository }) => load(repository, seeded.id));
+			assert(caughtUp.version === winner.version, `snapshot catch-up must end at the stream head ${winner.version}; got ${caughtUp.version}`);
+			if (snapshotState) assert(deepEqual(snapshotState.call(harness, caughtUp), snapshotState.call(harness, winner)), "snapshot catch-up must fold only the tail after the snapshot");
+		})
+	}));
 	return tests;
 }
 
+//#endregion
+//#region src/testing/event-bus-contract.ts
+/** Resolves after enough turns for a parallel batch to have started. */
+function turn() {
+	return new Promise((resolve) => setTimeout(resolve, 0));
+}
+/**
+* The event-bus contract test suite: the proof that an implementation
+* delivers the guarantees the `EventBus` port documents. Ordering,
+* parallelism within one event, and error collection after the batch are
+* a **port contract, not a kit guarantee**; this suite is how an
+* implementation demonstrates them.
+*
+* The suite covers the port and nothing else. Construction options of the
+* kit's own adapter, such as a publish-depth bound or an observer bundle,
+* are not port behavior and are not pinned here.
+*
+* Framework-agnostic: bind with
+* `(test.skipped ? it.skip : it)(test.name, test.run)`.
+*/
+function createEventBusContractTests(harness) {
+	const inEnv = bindContractEnvironment(() => harness.createEnvironment());
+	const first = () => harness.createFirstEvent();
+	const second = () => harness.createSecondEvent();
+	const types = () => {
+		const firstType = first().type;
+		const secondType = second().type;
+		assert(firstType !== secondType, "the harness must supply two event factories with different types");
+		return {
+			firstType,
+			secondType
+		};
+	};
+	return [
+		{
+			name: "dispatches the events of one batch in input order",
+			run: inEnv(async ({ bus }) => {
+				const { firstType, secondType } = types();
+				const seen = [];
+				bus.subscribe(firstType, async (event) => {
+					await new Promise((resolve) => setTimeout(resolve, 20));
+					seen.push(event.type);
+				});
+				bus.subscribe(secondType, async (event) => {
+					seen.push(event.type);
+				});
+				await bus.publish([
+					first(),
+					second(),
+					first()
+				]);
+				assertEqual(seen.join(","), [
+					firstType,
+					secondType,
+					firstType
+				].join(","), "a batch dispatches its events in input order");
+			})
+		},
+		{
+			name: "starts the handlers of an event only after the previous event finished",
+			run: inEnv(async ({ bus }) => {
+				const { firstType, secondType } = types();
+				const trace = [];
+				bus.subscribe(firstType, async () => {
+					trace.push("first:start");
+					await turn();
+					trace.push("first:end");
+				});
+				bus.subscribe(secondType, async () => {
+					trace.push("second:start");
+				});
+				await bus.publish([first(), second()]);
+				assertEqual(trace.join(","), "first:start,first:end,second:start", "an event dispatches only after the previous one finished");
+			})
+		},
+		{
+			name: "runs the handlers of one event in parallel",
+			run: inEnv(async ({ bus }) => {
+				const { firstType } = types();
+				const trace = [];
+				bus.subscribe(firstType, async () => {
+					trace.push("a:start");
+					await turn();
+					trace.push("a:end");
+				});
+				bus.subscribe(firstType, async () => {
+					trace.push("b:start");
+					await turn();
+					trace.push("b:end");
+				});
+				await bus.publish([first()]);
+				assertEqual(trace.join(","), "a:start,b:start,a:end,b:end", "the handlers of one event run in parallel");
+			})
+		},
+		{
+			name: "runs every handler of an event when a peer fails",
+			run: inEnv(async ({ bus }) => {
+				const { firstType } = types();
+				const seen = [];
+				bus.subscribe(firstType, async () => {
+					throw new Error("first handler failed");
+				});
+				bus.subscribe(firstType, async () => {
+					seen.push("peer");
+				});
+				await captureRejection(bus.publish([first()]));
+				assertEqual(seen.join(","), "peer", "a peer of a failing handler still runs");
+			})
+		},
+		{
+			name: "reaches the caller with a single failure directly",
+			run: inEnv(async ({ bus }) => {
+				const { firstType } = types();
+				const failure = /* @__PURE__ */ new Error("the only handler failed");
+				bus.subscribe(firstType, async () => {
+					throw failure;
+				});
+				const thrown = await captureRejection(bus.publish([first()]));
+				assertEqual(thrown, failure, "a single failure reaches the caller unchanged");
+			})
+		},
+		{
+			name: "collects two or more failures into an AggregateError",
+			run: inEnv(async ({ bus }) => {
+				const { firstType } = types();
+				const one = /* @__PURE__ */ new Error("handler one failed");
+				const two = /* @__PURE__ */ new Error("handler two failed");
+				bus.subscribe(firstType, async () => {
+					throw one;
+				});
+				bus.subscribe(firstType, async () => {
+					throw two;
+				});
+				const thrown = await captureRejection(bus.publish([first()]));
+				assert(thrown instanceof AggregateError, "two failures must reach the caller as an AggregateError");
+				assertEqual(thrown.errors.length, 2, "the AggregateError carries every failure");
+				assert(thrown.errors.includes(one) && thrown.errors.includes(two), "the AggregateError carries both failures");
+			})
+		},
+		{
+			name: "publishes the remaining events of a batch after a failure",
+			run: inEnv(async ({ bus }) => {
+				const { firstType, secondType } = types();
+				const seen = [];
+				bus.subscribe(firstType, async () => {
+					throw new Error("first handler failed");
+				});
+				bus.subscribe(secondType, async (event) => {
+					seen.push(event.type);
+				});
+				await captureRejection(bus.publish([first(), second()]));
+				assertEqual(seen.join(","), secondType, "a failure does not stop the remaining events of the batch");
+			})
+		},
+		{
+			name: "treats a handler that throws synchronously as a rejection",
+			run: inEnv(async ({ bus }) => {
+				const { firstType } = types();
+				const seen = [];
+				bus.subscribe(firstType, () => {
+					throw new Error("thrown synchronously");
+				});
+				bus.subscribe(firstType, async () => {
+					seen.push("peer");
+				});
+				const thrown = await captureRejection(bus.publish([first()]));
+				assert(thrown instanceof Error, "the throw must reach the caller");
+				assertEqual(seen.join(","), "peer", "a synchronous throw does not skip the peers");
+			})
+		},
+		{
+			name: "hands every subscriber the same event object",
+			run: inEnv(async ({ bus }) => {
+				const { firstType } = types();
+				const received = [];
+				bus.subscribe(firstType, (event) => {
+					received.push(event);
+				});
+				bus.subscribeAll((event) => {
+					received.push(event);
+				});
+				const published = first();
+				await bus.publish([published]);
+				assertEqual(received.length, 2, "both subscriptions must receive the event");
+				for (const one of received) assert(one === published, "every subscriber receives the published event itself, so its metadata cannot differ between them");
+			})
+		},
+		{
+			name: "delivers every type of a subscribed set to one handler",
+			run: inEnv(async ({ bus }) => {
+				const { firstType, secondType } = types();
+				const seen = [];
+				bus.subscribeMany([firstType, secondType], (event) => {
+					seen.push(event.type);
+				});
+				await bus.publish([first(), second()]);
+				assertEqual(seen.join(","), [firstType, secondType].join(","), "a set subscription receives every type in the set");
+			})
+		},
+		{
+			name: "releases every subscription of a set with one call",
+			run: inEnv(async ({ bus }) => {
+				const { firstType, secondType } = types();
+				const seen = [];
+				bus.subscribeMany([firstType, secondType], (event) => {
+					seen.push(event.type);
+				})();
+				await bus.publish([first(), second()]);
+				assertEqual(seen.length, 0, "one release must remove every subscription the set made");
+			})
+		},
+		{
+			name: "subscribes a repeated type of a set once",
+			run: inEnv(async ({ bus }) => {
+				const { firstType } = types();
+				let calls = 0;
+				bus.subscribeMany([firstType, firstType], () => {
+					calls++;
+				});
+				await bus.publish([first()]);
+				assertEqual(calls, 1, "the argument is a set, so a repeated type subscribes once");
+			})
+		},
+		{
+			name: "delivers every event type to a catch-all subscription",
+			run: inEnv(async ({ bus }) => {
+				const { firstType, secondType } = types();
+				const seen = [];
+				bus.subscribeAll(async (event) => {
+					seen.push(event.type);
+				});
+				await bus.publish([first(), second()]);
+				assertEqual(seen.join(","), [firstType, secondType].join(","), "a catch-all subscription receives every event type");
+			})
+		},
+		{
+			name: "runs a catch-all handler in the same batch as the typed handlers",
+			run: inEnv(async ({ bus }) => {
+				const { firstType } = types();
+				const seen = [];
+				bus.subscribe(firstType, async () => {
+					throw new Error("typed handler failed");
+				});
+				bus.subscribeAll(async () => {
+					seen.push("catch-all");
+				});
+				await captureRejection(bus.publish([first()]));
+				assertEqual(seen.join(","), "catch-all", "a catch-all handler runs in the same batch as the typed ones");
+			})
+		},
+		{
+			name: "removes exactly one subscription when the same handler subscribed twice",
+			run: inEnv(async ({ bus }) => {
+				const { firstType } = types();
+				let calls = 0;
+				const handler = async () => {
+					calls++;
+				};
+				const release = bus.subscribe(firstType, handler);
+				bus.subscribe(firstType, handler);
+				release();
+				await bus.publish([first()]);
+				assertEqual(calls, 1, "unsubscribe removes exactly one of two identical subscriptions");
+			})
+		},
+		{
+			name: "ignores a second call of the unsubscribe function",
+			run: inEnv(async ({ bus }) => {
+				const { firstType } = types();
+				let calls = 0;
+				const release = bus.subscribe(firstType, async () => {
+					calls++;
+				});
+				bus.subscribe(firstType, async () => {
+					calls++;
+				});
+				release();
+				release();
+				await bus.publish([first()]);
+				assertEqual(calls, 1, "a second unsubscribe removes no further subscription");
+			})
+		},
+		{
+			name: "resolves once() with the next event of its type and stops after it",
+			run: inEnv(async ({ bus }) => {
+				const { firstType } = types();
+				let deliveries = 0;
+				bus.subscribeAll(async () => {
+					deliveries++;
+				});
+				const waiting = bus.once(firstType);
+				const announced = first();
+				await bus.publish([announced]);
+				const received = await waiting;
+				await bus.publish([first()]);
+				assertEqual(received.eventId, announced.eventId, "once() resolves with the first event of that type");
+				assertEqual(deliveries, 2, "the second publication must still reach the bus");
+			})
+		},
+		{
+			name: "rejects once() when its timeout expires",
+			run: inEnv(async ({ bus }) => {
+				const { firstType } = types();
+				const thrown = await captureRejection(bus.once(firstType, { timeoutMs: 5 }));
+				assert(thrown !== void 0, "once() must reject after its timeout");
+			})
+		},
+		{
+			name: "rejects once() with the reason of an aborted signal",
+			run: inEnv(async ({ bus }) => {
+				const { firstType } = types();
+				const controller = new AbortController();
+				const reason = /* @__PURE__ */ new Error("the caller stopped waiting");
+				const waiting = captureRejection(bus.once(firstType, { signal: controller.signal }));
+				controller.abort(reason);
+				assertEqual(await waiting, reason, "once() rejects with the reason of the signal");
+			})
+		},
+		{
+			name: "rejects a publication whose signal is already aborted",
+			run: inEnv(async ({ bus }) => {
+				const { firstType } = types();
+				const controller = new AbortController();
+				controller.abort(/* @__PURE__ */ new Error("stopped before publish"));
+				let called = false;
+				bus.subscribe(firstType, async () => {
+					called = true;
+				});
+				const thrown = await captureRejection(bus.publish([first()], { signal: controller.signal }));
+				assert(thrown !== void 0, "an aborted publication must reject");
+				assertEqual(called, false, "an aborted publication dispatches no handler");
+			})
+		},
+		{
+			name: "refuses every operation after close",
+			run: inEnv(async ({ bus }) => {
+				const { firstType } = types();
+				bus.close();
+				let subscribeThrew = false;
+				try {
+					bus.subscribe(firstType, () => {});
+				} catch {
+					subscribeThrew = true;
+				}
+				let subscribeAllThrew = false;
+				try {
+					bus.subscribeAll(() => {});
+				} catch {
+					subscribeAllThrew = true;
+				}
+				assert(subscribeThrew, "subscribe must refuse a closed bus");
+				assert(subscribeAllThrew, "subscribeAll must refuse a closed bus");
+				assert(await captureRejection(bus.publish([first()])) !== void 0, "publish must refuse a closed bus");
+				assert(await captureRejection(bus.once(firstType)) !== void 0, "once must refuse a closed bus");
+			})
+		},
+		{
+			name: "settles a pending once() when the bus closes",
+			run: inEnv(async ({ bus }) => {
+				const { firstType } = types();
+				const waiting = captureRejection(bus.once(firstType));
+				bus.close();
+				assert(await waiting !== void 0, "closing must settle a pending once()");
+			})
+		},
+		{
+			name: "does nothing when close is called again",
+			run: inEnv(async ({ bus }) => {
+				bus.close();
+				let threw = false;
+				try {
+					bus.close();
+				} catch {
+					threw = true;
+				}
+				assert(threw === false, "a second close must do nothing");
+			})
+		},
+		{
+			name: "bounds the wait, not the handler, when the timeout expires",
+			run: inEnv(async ({ bus }) => {
+				const { firstType } = types();
+				let running = true;
+				bus.subscribe(firstType, async () => {
+					await new Promise((resolve) => setTimeout(resolve, 200));
+					running = false;
+				});
+				const thrown = await captureRejection(bus.publish([first()], { timeoutMs: 10 }));
+				assert(thrown !== void 0, "the publication must reject");
+				assertEqual(running, true, "the timeout bounds the wait, so the handler keeps running");
+			})
+		}
+	];
+}
+
 //#endregion
 //#region src/testing/event-store-contract.ts
 /**
@@ -1126,7 +1563,10 @@ function createEventStoreContractTests(harness) {
 						toVersion: Number.MAX_SAFE_INTEGER + 1
 					}
 				];
-				for (const options of invalidOptions) assert(await captureRejection(store.readStream(firstKey, options)) instanceof RangeError, "invalid read bounds must reject with RangeError before querying the stream");
+				for (const options of invalidOptions) {
+					const rejection = await captureRejection(store.readStream(firstKey, options));
+					assert(rejection instanceof RangeError, "invalid read bounds must reject with RangeError before querying the stream");
+				}
 			})
 		},
 		{
@@ -1227,7 +1667,8 @@ function createEventStoreContractTests(harness) {
 				const [firstKey] = harness.createCollidingStreamKeys();
 				const seeded = [harness.createEvent(firstKey, 30), harness.createEvent(firstKey, 31)];
 				await store.append(firstKey, seeded, { expectedVersion: 0 });
-				assertChainContainsKitError(await captureRejection(store.append({ ...firstKey }, [harness.createEvent(firstKey, 32), harness.createEvent(firstKey, 33)], { expectedVersion: 1 })), ["CONCURRENCY_CONFLICT"], "a stale append must map the adapter conflict to ConcurrencyConflictError");
+				const rejection = await captureRejection(store.append({ ...firstKey }, [harness.createEvent(firstKey, 32), harness.createEvent(firstKey, 33)], { expectedVersion: 1 }));
+				assertChainContainsKitError(rejection, ["CONCURRENCY_CONFLICT"], "a stale append must map the adapter conflict to ConcurrencyConflictError");
 				const stored = await store.readStream(firstKey, fixtureRead);
 				assert(stored.exists && stored.lastVersion === 2 && stored.events.length === 2 && stored.events[0]?.eventId === seeded[0]?.eventId && stored.events[1]?.eventId === seeded[1]?.eventId, "a rejected multi-event append must leave the stream untouched");
 			})
@@ -1238,7 +1679,8 @@ function createEventStoreContractTests(harness) {
 				const [firstKey] = harness.createCollidingStreamKeys();
 				const seeded = harness.createEvent(firstKey, 50);
 				await store.append(firstKey, [seeded], { expectedVersion: 0 });
-				assertChainContainsKitError(await captureRejection(store.append({ ...firstKey }, [harness.createEvent(firstKey, 51), harness.createEvent(firstKey, 52)], { expectedVersion: 0 })), ["CONCURRENCY_CONFLICT", "DUPLICATE_AGGREGATE"], "a duplicate create must map to ConcurrencyConflictError or the sanctioned DuplicateAggregateError");
+				const rejection = await captureRejection(store.append({ ...firstKey }, [harness.createEvent(firstKey, 51), harness.createEvent(firstKey, 52)], { expectedVersion: 0 }));
+				assertChainContainsKitError(rejection, ["CONCURRENCY_CONFLICT", "DUPLICATE_AGGREGATE"], "a duplicate create must map to ConcurrencyConflictError or the sanctioned DuplicateAggregateError");
 				const stored = await store.readStream(firstKey, fixtureRead);
 				assert(stored.exists && stored.lastVersion === 1 && stored.events.length === 1 && stored.events[0]?.eventId === seeded.eventId, "a rejected duplicate-create batch must leave the existing stream untouched");
 			})
@@ -1247,7 +1689,8 @@ function createEventStoreContractTests(harness) {
 			name: "OCC: an expectedVersion ahead of an unknown stream conflicts without creating it",
 			run: inEnv(async ({ store }) => {
 				const [firstKey] = harness.createCollidingStreamKeys();
-				assertChainContainsKitError(await captureRejection(store.append(firstKey, [harness.createEvent(firstKey, 60)], { expectedVersion: 3 })), ["CONCURRENCY_CONFLICT"], "an expectedVersion ahead of the stream must map to ConcurrencyConflictError");
+				const rejection = await captureRejection(store.append(firstKey, [harness.createEvent(firstKey, 60)], { expectedVersion: 3 }));
+				assertChainContainsKitError(rejection, ["CONCURRENCY_CONFLICT"], "an expectedVersion ahead of the stream must map to ConcurrencyConflictError");
 				const first = harness.createEvent(firstKey, 61);
 				await store.append({ ...firstKey }, [first], { expectedVersion: 0 });
 				const stored = await store.readStream(firstKey, fixtureRead);
@@ -1318,7 +1761,8 @@ function createIdempotencyStoreContractTests(harness) {
 					return claim;
 				});
 				await env.store.confirm(first);
-				assertChainContainsKitError(await captureRejection(env.run((ctx) => env.store.claim(ctx, "key-1", "fp-OTHER"))), ["IDEMPOTENCY_KEY_REUSE"], "a different fingerprint must throw IdempotencyKeyReuseError, never replay another command's outcome");
+				const rejection = await captureRejection(env.run((ctx) => env.store.claim(ctx, "key-1", "fp-OTHER")));
+				assertChainContainsKitError(rejection, ["IDEMPOTENCY_KEY_REUSE"], "a different fingerprint must throw IdempotencyKeyReuseError, never replay another command's outcome");
 			})
 		},
 		{
@@ -1357,10 +1801,11 @@ function createIdempotencyStoreContractTests(harness) {
 		{
 			name: "complete without a pending claim throws the wiring error",
 			run: inEnv(async (env) => {
-				assertChainContainsKitError(await captureRejection(env.run((ctx) => env.store.complete(ctx, {
+				const rejection = await captureRejection(env.run((ctx) => env.store.complete(ctx, {
 					key: "key-1",
 					token: "missing"
-				}, "x"))), ["IDEMPOTENCY_COMPLETED_WITHOUT_CLAIM"], "complete() without claim() must throw IdempotencyCompletionWithoutClaimError");
+				}, "x")));
+				assertChainContainsKitError(rejection, ["IDEMPOTENCY_COMPLETED_WITHOUT_CLAIM"], "complete() without claim() must throw IdempotencyCompletionWithoutClaimError");
 			})
 		}
 	];
@@ -1401,7 +1846,8 @@ function createIdempotencyStoreContractTests(harness) {
 			const renewed = await env.store.renew(claim);
 			assert(renewed !== void 0 && new Date(renewed.expiresAt).getTime() > originalExpiry, "renew must extend the lease beyond its previous expiry");
 			await advanceTimeTo(env, new Date(originalExpiry + 1));
-			assertChainContainsKitError(await captureRejection(env.run((ctx) => env.store.claim(ctx, "key-renew", "fp"))), ["IDEMPOTENCY_IN_FLIGHT"], "the renewed owner must still hold the key after the original expiry");
+			const rejection = await captureRejection(env.run((ctx) => env.store.claim(ctx, "key-renew", "fp")));
+			assertChainContainsKitError(rejection, ["IDEMPOTENCY_IN_FLIGHT"], "the renewed owner must still hold the key after the original expiry");
 		})
 	}), gatedContractTest({
 		capability: "family: non-transactional",
@@ -1412,8 +1858,10 @@ function createIdempotencyStoreContractTests(harness) {
 			const first = claimedHandle(await env.run((ctx) => env.store.claim(ctx, "key-1", "fp-1")), "a fresh key must be claimed");
 			assert(first.lease !== void 0, "a non-transactional claim must carry lease timing");
 			await expireLease(env, first);
-			assert(claimedHandle(await env.run((ctx) => env.store.claim(ctx, "key-1", "fp-1")), "an expired pending claim must be reclaimed").token !== first.token, "each ownership generation must have a different token");
-			assertChainContainsKitError(await captureRejection(env.run((ctx) => env.store.complete(ctx, first, "stale"))), ["IDEMPOTENCY_CLAIM_LOST"], "a stale owner must fail before it can complete after takeover");
+			const successor = claimedHandle(await env.run((ctx) => env.store.claim(ctx, "key-1", "fp-1")), "an expired pending claim must be reclaimed");
+			assert(successor.token !== first.token, "each ownership generation must have a different token");
+			const rejection = await captureRejection(env.run((ctx) => env.store.complete(ctx, first, "stale")));
+			assertChainContainsKitError(rejection, ["IDEMPOTENCY_CLAIM_LOST"], "a stale owner must fail before it can complete after takeover");
 		})
 	}), gatedContractTest({
 		capability: "family: non-transactional",
@@ -1455,7 +1903,8 @@ function createIdempotencyStoreContractTests(harness) {
 			const rolledBack = await env.run((ctx) => env.store.claim(ctx, "rolled-back", "fp"));
 			assert(rolledBack.status === "reconciliation-required", "the staged outcome must expose its reconciliation receipt");
 			await env.store.reconcile(rolledBack.reconciliation, "not-committed");
-			assertEqual((await env.run((ctx) => env.store.claim(ctx, "rolled-back", "fp"))).status, "claimed", "not-committed evidence must release the staged outcome");
+			const fresh = await env.run((ctx) => env.store.claim(ctx, "rolled-back", "fp"));
+			assertEqual(fresh.status, "claimed", "not-committed evidence must release the staged outcome");
 		})
 	}), gatedContractTest({
 		capability: "family: non-transactional",
@@ -1467,7 +1916,8 @@ function createIdempotencyStoreContractTests(harness) {
 				const claim = claimedHandle(await env.store.claim(ctx, "key-1", "fp-1"), "a fresh key must be claimed");
 				await env.store.complete(ctx, claim, "uncommitted");
 			});
-			assertChainContainsKitError(await captureRejection(env.run((ctx) => env.store.claim(ctx, "key-1", "fp-1"))), ["IDEMPOTENCY_IN_FLIGHT"], "a staged outcome must never replay; it is in-flight until confirmed");
+			const rejection = await captureRejection(env.run((ctx) => env.store.claim(ctx, "key-1", "fp-1")));
+			assertChainContainsKitError(rejection, ["IDEMPOTENCY_IN_FLIGHT"], "a staged outcome must never replay; it is in-flight until confirmed");
 		})
 	}), gatedContractTest({
 		capability: "family: non-transactional",
@@ -1477,7 +1927,8 @@ function createIdempotencyStoreContractTests(harness) {
 		run: inEnv(async (env) => {
 			const first = claimedHandle(await env.run((ctx) => env.store.claim(ctx, "key-1", "fp-1")), "a fresh key must be claimed");
 			await env.store.abandon(first);
-			assertEqual((await env.run((ctx) => env.store.claim(ctx, "key-1", "fp-1"))).status, "claimed", "an abandoned pending claim must be claimable again");
+			const claim = await env.run((ctx) => env.store.claim(ctx, "key-1", "fp-1"));
+			assertEqual(claim.status, "claimed", "an abandoned pending claim must be claimable again");
 		})
 	}), gatedContractTest({
 		capability: "family: non-transactional",
@@ -1491,7 +1942,8 @@ function createIdempotencyStoreContractTests(harness) {
 				return claim;
 			});
 			await env.store.abandon(first);
-			assertEqual((await env.run((ctx) => env.store.claim(ctx, "key-1", "fp-1"))).status, "claimed", "an abandoned staged outcome must be claimable again");
+			const claim = await env.run((ctx) => env.store.claim(ctx, "key-1", "fp-1"));
+			assertEqual(claim.status, "claimed", "an abandoned staged outcome must be claimable again");
 		})
 	}), gatedContractTest({
 		capability: "family: transactional",
@@ -1504,7 +1956,8 @@ function createIdempotencyStoreContractTests(harness) {
 				const claim = claimedHandle(await env.store.claim(ctx, "key-1", "fp-1"), "a fresh key must be claimed");
 				await env.store.complete(ctx, claim, "rolled back");
 			}).catch(() => {});
-			assertEqual((await env.run((ctx) => env.store.claim(ctx, "key-1", "fp-1"))).status, "claimed", "a rolled-back claim/complete must leave the key claimable");
+			const claim = await env.run((ctx) => env.store.claim(ctx, "key-1", "fp-1"));
+			assertEqual(claim.status, "claimed", "a rolled-back claim/complete must leave the key claimable");
 		})
 	}));
 	return tests;
@@ -1555,7 +2008,8 @@ function createOutboxContractTests(harness) {
 			run: inEnv(async (env) => {
 				await env.addCommitted(commit([harness.createEvent(1), harness.createEvent(2)], 1));
 				await env.addCommitted(commit([harness.createEvent(3)], 3));
-				assert(deepEqual((await takeAndAck(env, 3)).map(({ position }) => position), [
+				const records = await takeAndAck(env, 3);
+				assert(deepEqual(records.map(({ position }) => position), [
 					{
 						aggregateVersion: 1,
 						commitSequence: 0,
@@ -1583,7 +2037,8 @@ function createOutboxContractTests(harness) {
 				const original = commit([harness.createEvent(1)], 1);
 				const collision = commit([harness.createEvent(2)], 1);
 				await env.addCommitted(original);
-				assert(await captureRejection(env.addCommitted(collision)) !== void 0, "a different eventId at one qualified source position must reject");
+				const rejection = await captureRejection(env.addCommitted(collision));
+				assert(rejection !== void 0, "a different eventId at one qualified source position must reject");
 				const [record] = await takeAndAck(env, 1);
 				assertEqual(record?.event.eventId, original[0]?.event.eventId, "the rejected collision must not replace the original record");
 				await env.addCommitted(commit([harness.createEvent(3)], 2));
@@ -1609,7 +2064,8 @@ function createOutboxContractTests(harness) {
 					}
 				];
 				for (const [index, source] of sources.entries()) await env.addCommitted(commit([harness.createEvent(index + 1)], 1, source));
-				assert((await takeAndAck(env, sources.length)).every((record, index) => record.source.aggregateType === sources[index]?.aggregateType && record.source.aggregateId === sources[index]?.aggregateId && record.position.previousEventfulAggregateVersion === null), "colliding raw ids or aggregate types must each retain an independent genesis head");
+				const records = await takeAndAck(env, sources.length);
+				assert(records.every((record, index) => record.source.aggregateType === sources[index]?.aggregateType && record.source.aggregateId === sources[index]?.aggregateId && record.position.previousEventfulAggregateVersion === null), "colliding raw ids or aggregate types must each retain an independent genesis head");
 			})
 		},
 		{
@@ -1668,7 +2124,8 @@ function createOutboxContractTests(harness) {
 				await env.outbox.markDispatched([first.dispatchId]);
 				await env.outbox.markDispatched([first.dispatchId]);
 				await env.outbox.markDispatched(["no-such-dispatch-id"]);
-				assert(!(await env.outbox.getPending(10)).some((r) => r.dispatchId === first.dispatchId), "a dispatched record must never come back");
+				const remaining = await env.outbox.getPending(10);
+				assert(!remaining.some((r) => r.dispatchId === first.dispatchId), "a dispatched record must never come back");
 			})
 		},
 		gatedContractTest({
@@ -1699,7 +2156,8 @@ function createOutboxContractTests(harness) {
 				} catch (error) {
 					throw new Error(`Contract violated: add() must swallow a duplicate eventId, not throw. Dedupe means an idempotent add (INSERT ... ON CONFLICT DO NOTHING or equivalent), not a raised unique violation. Got: ${describeError(error)}`);
 				}
-				assertEqual((await env.outbox.getPending(10)).length, 1, "the same eventId must yield one record (unique-key dedupe)");
+				const pending = await env.outbox.getPending(10);
+				assertEqual(pending.length, 1, "the same eventId must yield one record (unique-key dedupe)");
 			})
 		})
 	];
@@ -1835,7 +2293,8 @@ function createProjectionCheckpointStoreContractTests(harness) {
 		{
 			name: "a never-seen (projection, aggregate) pair loads undefined",
 			run: inEnv(async (env) => {
-				assertEqual(await env.run((ctx) => env.store.load(ctx, "order-list", order("o-1"))), void 0, "a fresh store must report no watermark");
+				const loaded = await env.run((ctx) => env.store.load(ctx, "order-list", order("o-1")));
+				assertEqual(loaded, void 0, "a fresh store must report no watermark");
 			})
 		},
 		gatedContractTest({
@@ -1859,16 +2318,18 @@ function createProjectionCheckpointStoreContractTests(harness) {
 				};
 				assertEqual(await advanceOnce(void 0, 1), 1, "exactly one competing callback may advance a missing checkpoint key; genesis has no row that SELECT FOR UPDATE could lock");
 				assertEqual(await advanceOnce(1, 2), 1, "exactly one competing callback may advance an existing checkpoint key from the observed watermark");
-				assert((await env.run((ctx) => env.store.load(ctx, "order-list", address)))?.position.aggregateVersion === 2, "serialized genesis and existing-row advances must leave the final watermark visible");
+				const stored = await env.run((ctx) => env.store.load(ctx, "order-list", address));
+				assert(stored?.position.aggregateVersion === 2, "serialized genesis and existing-row advances must leave the final watermark visible");
 			})
 		}),
 		{
 			name: "checkpoint locks release after a rejected critical section",
 			run: inEnv(async (env) => {
 				const address = order("o-rejected-lock");
-				assert(await captureRejection(env.run((ctx) => env.store.withCheckpointLocks(ctx, "order-list", [address], async () => {
+				const rejection = await captureRejection(env.run((ctx) => env.store.withCheckpointLocks(ctx, "order-list", [address], async () => {
 					throw new Error("projection failed");
-				}))) !== void 0, "the store must propagate a rejected critical section");
+				})));
+				assert(rejection !== void 0, "the store must propagate a rejected critical section");
 				let retried = false;
 				await env.run((ctx) => env.store.withCheckpointLocks(ctx, "order-list", [address], async () => {
 					retried = true;
@@ -1902,7 +2363,8 @@ function createProjectionCheckpointStoreContractTests(harness) {
 				const loaded = await env.run((ctx) => env.store.load(ctx, "order-list", order("o-1")));
 				assert(loaded !== void 0, "expected a stored watermark");
 				loaded.position.aggregateVersion = 99;
-				assert((await env.run((ctx) => env.store.load(ctx, "order-list", order("o-1"))))?.position.aggregateVersion === 2, "the stored watermark must be immune to mutation of a previously loaded copy");
+				const reloaded = await env.run((ctx) => env.store.load(ctx, "order-list", order("o-1")));
+				assert(reloaded?.position.aggregateVersion === 2, "the stored watermark must be immune to mutation of a previously loaded copy");
 			})
 		},
 		{
@@ -1996,7 +2458,8 @@ function createProjectionCheckpointStoreContractTests(harness) {
 			run: inEnv(async (env) => {
 				if (!env.runRolledBack) throw new Error("Contract violated: harness declared providesRolledBackRuns but the environment lacks runRolledBack");
 				await env.runRolledBack((ctx) => env.store.save(ctx, "order-list", order("o-1"), checkpoint(pos(1, 0)))).catch(() => {});
-				assertEqual(await env.run((ctx) => env.store.load(ctx, "order-list", order("o-1"))), void 0, "a checkpoint from a rolled-back transaction must not exist; otherwise events are lost while marked processed");
+				const loaded = await env.run((ctx) => env.store.load(ctx, "order-list", order("o-1")));
+				assertEqual(loaded, void 0, "a checkpoint from a rolled-back transaction must not exist; otherwise events are lost while marked processed");
 			})
 		})
 	];
@@ -2037,7 +2500,7 @@ function createRepositoryContractTests(harness) {
 	}
 	const reload = (environment, id) => environment.run(({ repository }) => load(repository, id));
 	const eventIds = (events) => sortedCommittedEventIds(events);
-	const pendingEventIds = (events) => mintedPendingEventIds(events, "the harness must record pending events before persistence");
+	const pendingEventIds = (events) => recordedPendingEventIds(events, "the harness must record pending events before persistence");
 	const tests = [
 		{
 			name: "add flushes a new aggregate and its exact event batch atomically",
@@ -2122,7 +2585,8 @@ function createRepositoryContractTests(harness) {
 					repository.add(aggregate);
 					throw new Error("rollback probe");
 				}));
-				assert(await environment.run(({ repository }) => repository.findById(aggregate.id)) === void 0, "a rolled-back add must leave no row");
+				const absent = await environment.run(({ repository }) => repository.findById(aggregate.id));
+				assert(absent === void 0, "a rolled-back add must leave no row");
 				assertEqual((await environment.committedOutboxEvents()).length, 0, "a rolled-back add must leave no outbox record");
 				assert(deepEqual(aggregate.pendingEvents, pending), "rollback must acknowledge none of the registered event batch");
 			})
@@ -2134,10 +2598,12 @@ function createRepositoryContractTests(harness) {
 				harness.mutate(aggregate);
 				const pending = [...aggregate.pendingEvents];
 				environment.failNextOutboxWrite(/* @__PURE__ */ new Error("outbox failure probe"));
-				assert(await captureRejection(environment.run(async ({ repository }) => {
+				const rejection = await captureRejection(environment.run(async ({ repository }) => {
 					repository.add(aggregate);
-				})) !== void 0, "the outbox failure must reject");
-				assert(await environment.run(({ repository }) => repository.findById(aggregate.id)) === void 0, "state flush must roll back when the outbox write fails");
+				}));
+				assert(rejection !== void 0, "the outbox failure must reject");
+				const absent = await environment.run(({ repository }) => repository.findById(aggregate.id));
+				assert(absent === void 0, "state flush must roll back when the outbox write fails");
 				assertEqual((await environment.committedOutboxEvents()).length, 0, "failed outbox write must commit no envelope");
 				assert(deepEqual(aggregate.pendingEvents, pending), "failed commit must acknowledge none of the event batch");
 			})
@@ -2200,7 +2666,8 @@ function createRepositoryContractTests(harness) {
 				mutateVersionOnly.call(harness, aggregate);
 				repository.update(aggregate);
 			});
-			assertEqual((await reload(environment, seeded.id)).version, seeded.version + 1, "a version-only change (empty change set, bumped version) must still be persisted; skipping it desyncs the persisted version and produces false concurrency conflicts later");
+			const reloaded = await reload(environment, seeded.id);
+			assertEqual(reloaded.version, seeded.version + 1, "a version-only change (empty change set, bumped version) must still be persisted; skipping it desyncs the persisted version and produces false concurrency conflicts later");
 			assert(deepEqual(eventIds(await environment.committedOutboxEvents()), eventIds(outboxBefore)), "state-only update must not create an outbox event");
 		})
 	}));
@@ -2217,7 +2684,8 @@ function createRepositoryContractTests(harness) {
 				mutateChildCollection.call(harness, aggregate);
 				repository.update(aggregate);
 			});
-			assertEqual((await reload(environment, seeded.id)).version, seeded.version + 1, "nested collection update must advance the persisted root version");
+			const reloaded = await reload(environment, seeded.id);
+			assertEqual(reloaded.version, seeded.version + 1, "nested collection update must advance the persisted root version");
 		})
 	}));
 	tests.push(gatedContractTest({
@@ -2336,7 +2804,8 @@ function createSnapshotStoreContractTests(harness) {
 					total: 0,
 					items: []
 				}));
-				assertEqual((await env.store.load(address("Order", "o-1")))?.schemaVersion, void 0, "a snapshot stored without schemaVersion must not come back with a fabricated one; restore treats absence as schema 1");
+				const loaded = await env.store.load(address("Order", "o-1"));
+				assertEqual(loaded?.schemaVersion, void 0, "a snapshot stored without schemaVersion must not come back with a fabricated one; restore treats absence as schema 1");
 			})
 		},
 		{
@@ -2413,12 +2882,13 @@ function createSnapshotStoreContractTests(harness) {
 				assert(loaded !== void 0, "expected the saved snapshot");
 				assertEqual(loaded.state.items.length, 1, "save must capture the snapshot by value, not hold the caller's reference");
 				loaded.state.total = 999;
-				assertEqual((await env.store.load(address("Order", "o-1")))?.state.total, 5, "load must hand out a detached copy, never live internal state");
+				const reloaded = await env.store.load(address("Order", "o-1"));
+				assertEqual(reloaded?.state.total, 5, "load must hand out a detached copy, never live internal state");
 			})
 		}
 	];
 }
 
 //#endregion
-export { createCommandOutboxContractTests, createDeadlineStoreContractTests, createEsRepositoryContractTests, createEventStoreContractTests, createIdempotencyStoreContractTests, createOutboxContractTests, createProjectionCheckpointStoreContractTests, createRepositoryContractTests, createSnapshotStoreContractTests };
+export { createCommandOutboxContractTests, createDeadlineStoreContractTests, createEsRepositoryContractTests, createEventBusContractTests, createEventStoreContractTests, createIdempotencyStoreContractTests, createOutboxContractTests, createProjectionCheckpointStoreContractTests, createRepositoryContractTests, createSnapshotStoreContractTests };
 //# sourceMappingURL=testing.js.map