@classytic/arc 2.30.0 → 2.32.0

package/dist/testing/index.mjs

@@ -1,10 +1,13 @@
-import { t as CRUD_OPERATIONS } from "../constants-DNre0wRg.mjs";
-import { t as BaseController } from "../BaseController-B5DwufbB.mjs";
-import { t as defineResource } from "../defineResource-CxWqDCAy.mjs";
-import { t as defineAggregation } from "../defineAggregation-ufWjUwml.mjs";
-import { n as createApp } from "../createApp-CXrKFciH.mjs";
-import { n as getModuleExports } from "../module-_-M7C5ES.mjs";
-import { n as preloadResourcesAsync, t as preloadResources } from "../preloadResources-DSY5HGpS.mjs";
+/*! @classytic/arc v2.32.0 | MIT | https://classytic.com */
+import { t as CRUD_OPERATIONS } from "../constants-J99LGTJI.mjs";
+import { g as getUserId } from "../types-DXYX7dIR.mjs";
+import { t as BaseController } from "../BaseController-Dk34dxhI.mjs";
+import { t as defineResource } from "../defineResource-XFPPUu2c.mjs";
+import { t as defineAggregation } from "../defineAggregation-gX4No1gt.mjs";
+import { E as requireOrgRole } from "../permissions-Dl_m0NCe.mjs";
+import { n as createApp } from "../createApp-Bv0m-Q6_.mjs";
+import { n as getModuleExports } from "../module-Br81am6m.mjs";
+import { n as preloadResourcesAsync, t as preloadResources } from "../preloadResources-CDs87fTw.mjs";
 import { runStorageContract } from "./storageContract.mjs";
 import Fastify from "fastify";
 import { afterAll, describe, expect, it, vi } from "vitest";
@@ -61,7 +64,8 @@ function expectArc(response) {
 		failed(status) {
 			if (status !== void 0) expect(response.statusCode).toBe(status);
 			else expect(response.statusCode).toBeGreaterThanOrEqual(400);
-			expect(getBody().code, "expected ErrorContract.code on failed response").toBeDefined();
+			const body = getBody();
+			expect(body.code, "expected ErrorContract.code on failed response").toBeDefined();
 			return assertion;
 		},
 		unauthorized() {
@@ -81,7 +85,8 @@ function expectArc(response) {
 		},
 		hasData() {
 			const body = getBody();
-			expect(Object.keys(body).length > 0, "expected response body to be defined").toBe(true);
+			const hasContent = Object.keys(body).length > 0;
+			expect(hasContent, "expected response body to be defined").toBe(true);
 			return assertion;
 		},
 		hasStatus(status) {
@@ -89,11 +94,13 @@ function expectArc(response) {
 			return assertion;
 		},
 		hidesField(field) {
-			expect(getBody(), `expected field '${field}' to be hidden from response`).not.toHaveProperty(field);
+			const body = getBody();
+			expect(body, `expected field '${field}' to be hidden from response`).not.toHaveProperty(field);
 			return assertion;
 		},
 		showsField(field) {
-			expect(getBody(), `expected field '${field}' on response`).toHaveProperty(field);
+			const body = getBody();
+			expect(body, `expected field '${field}' on response`).toHaveProperty(field);
 			return assertion;
 		},
 		paginated(expected) {
@@ -304,18 +311,30 @@ function createSpy(_name = "spy") {
 	return spy;
 }
 /**
-* Wait for a condition to be true
+* Wait until `condition` holds — the standard way to assert on asynchronous
+* effects in arc's suites.
 *
-* Useful for async testing
+* **Prefer this over `await sleep(n)` + assert.** A fixed delay encodes a guess
+* about scheduling: too short and it flakes the moment the pool is busy, too
+* long and every run pays for the worst case. Polling returns as soon as the
+* effect lands, so the fast path stays fast and a loaded machine simply waits —
+* and the failure mode becomes "this never happened", which is the thing worth
+* asserting.
+*
+* Supply `label`: without it a timeout reports only its own duration, which is
+* the least useful sentence a flaky test can print.
+*
+* @example
+* await waitFor(() => runs >= 3, { label: "3 scheduler ticks" });
 */
 async function waitFor(condition, options = {}) {
-	const { timeout = 5e3, interval = 100 } = options;
+	const { timeout = 5e3, interval = 25, label } = options;
 	const startTime = Date.now();
 	while (Date.now() - startTime < timeout) {
 		if (await condition()) return;
 		await new Promise((resolve) => setTimeout(resolve, interval));
 	}
-	throw new Error(`Timeout waiting for condition after ${timeout}ms`);
+	throw new Error(label ? `Timed out after ${timeout}ms waiting for: ${label}` : `Timed out after ${timeout}ms waiting for a condition (pass "label" to name it)`);
 }
 /**
 * Create a test timer that can be controlled
@@ -363,6 +382,7 @@ function createTestTimer() {
 async function runAuthorizationConformance(opts) {
 	const rows = opts.rows ?? [{ _id: "1" }];
 	let listFilter;
+	let getFilter;
 	let aggFilter;
 	const repo = createMockRepository({
 		getAll: (async (params = {}) => {
@@ -378,6 +398,25 @@ async function runAuthorizationConformance(opts) {
 				hasPrev: false
 			};
 		}),
+		getOne: (async (filter) => {
+			getFilter = filter;
+			return rows[0] ?? null;
+		}),
+		/**
+		* The single-record read has TWO paths, and the harness must be able to observe both.
+		*
+		* `fetchDetailed` only builds a compound filter and calls `getOne` when there is something to
+		* compound — a row policy, a tenant field, or a non-default id field. A permission that simply
+		* ALLOWS (no policy) leaves `{ _id }` alone and takes the plain `getById` path instead. The base
+		* mock stubs that as `null`, so before this stub the `get` surface reported **404 on every
+		* policy-free allow** while `list` and `aggregation` reported 200.
+		*
+		* That reads as partial enforcement and it is not: it is the harness failing to answer. A host
+		* asserting `get.status === 200` for its own allow-gate — the obvious falsification case to pair
+		* with a deny-parity suite — was told its gate broke the single-record surface. Found from
+		* be-prod, whose conformance suite does exactly that.
+		*/
+		getById: (async () => rows[0] ?? null),
 		aggregate: (async (req = {}) => {
 			aggFilter = req.filter;
 			return { rows: [{ tally: rows.length }] };
@@ -419,6 +458,10 @@ async function runAuthorizationConformance(opts) {
 		method: "GET",
 		url: "/confs"
 	});
+	const get = await app.inject({
+		method: "GET",
+		url: "/confs/1"
+	});
 	const aggregation = await app.inject({
 		method: "GET",
 		url: "/confs/aggregations/tally"
@@ -428,6 +471,10 @@ async function runAuthorizationConformance(opts) {
 			status: list.statusCode,
 			filter: listFilter
 		},
+		get: {
+			status: get.statusCode,
+			filter: getFilter
+		},
 		aggregation: {
 			status: aggregation.statusCode,
 			filter: aggFilter
@@ -775,6 +822,127 @@ async function setupBetterAuthTestApp(input) {
 	};
 }
 //#endregion
+//#region src/testing/testActor.ts
+/**
+* Test-only actor installation — how a package's HTTP tests say "run this
+* request as a manager in org X".
+*
+* Identity in arc comes from `request.scope` and only from `request.scope`;
+* headers like `x-role` are not identity. That rule left tests with no seam —
+* `bootModuleApp` boots with `auth: false`, so every injected request arrived as
+* `PUBLIC_SCOPE` and any role-gated route answered 401 with no supported way to
+* be somebody.
+*
+* The `x-test-actor` header is a TRANSPORT for the test's intent, not a trusted
+* claim. The authenticator that reads it is installed by `bootModuleApp` alone,
+* behind the `@classytic/arc/testing` entrypoint; `createApp` never registers
+* it, so no production build turns a forged header into identity. It is
+* per-request rather than boot-only because the interesting authorization tests
+* are the ones where a cashier is refused what a manager is allowed.
+*
+* Gate the routes under test with arc's own primitives — `requireRoles`,
+* `requireOrgMembership`, `allOf(...)`. A test-specific gate would be a second
+* implementation of authorization whose semantics could drift from the one
+* actually shipping.
+*/
+/** The header the testing harness uses to carry a request's actor. */
+const TEST_ACTOR_HEADER = "x-test-actor";
+/**
+* Build the headers that make an injected request act as `actor`.
+*
+* A string is shorthand for a single role. `null` means "stay public", so a test
+* can prove an endpoint is reachable anonymously.
+*
+* @example
+* ```ts
+* t.app.inject({ method: 'GET', url: '/pos/shifts/current',
+*   headers: testActorHeaders('manager', ORG) });
+* ```
+*/
+function testActorHeaders(actor, organizationId) {
+	if (actor === null) return {};
+	const org = organizationId !== void 0 ? { organizationId } : {};
+	const spec = typeof actor === "string" ? {
+		roles: [actor],
+		...org
+	} : {
+		...actor,
+		...org
+	};
+	return { [TEST_ACTOR_HEADER]: JSON.stringify(spec) };
+}
+/**
+* Turn a spec into a `RequestScope`.
+*
+* `orgRoles` defaults to `roles`: a test that says "manager" means it at both
+* levels, and making the caller repeat itself only produces tests that pass a
+* global gate and mysteriously fail an org one.
+*/
+function scopeFromTestActor(spec) {
+	const roles = spec.roles ?? [];
+	const userId = spec.userId ?? `test-${roles.join("-") || "anon"}`;
+	if (spec.elevated !== void 0 && spec.elevated !== false) return {
+		kind: "elevated",
+		userId,
+		elevatedBy: spec.elevated === true ? "test" : spec.elevated,
+		...spec.organizationId !== void 0 ? { organizationId: spec.organizationId } : {},
+		...spec.context !== void 0 ? { context: Object.freeze({ ...spec.context }) } : {}
+	};
+	if (spec.organizationId !== void 0) return {
+		kind: "member",
+		userId,
+		userRoles: roles,
+		organizationId: spec.organizationId,
+		orgRoles: spec.orgRoles ?? roles,
+		...spec.teamId !== void 0 ? { teamId: spec.teamId } : {},
+		...spec.context !== void 0 ? { context: Object.freeze({ ...spec.context }) } : {}
+	};
+	return {
+		kind: "authenticated",
+		userId,
+		userRoles: roles
+	};
+}
+/**
+* Build the `auth` option that makes the test actor arc's authenticator.
+*
+* It must be an authenticator, not a hook. Fastify encapsulates plugins and
+* modules register DURING `createApp`, so a hook added to the root instance
+* afterwards never runs for their routes — every request still resolves as
+* public and every role gate still answers 401, which reads exactly like a
+* broken authorization rule in the code under test. Registering as
+* `auth: { type: 'authenticator' }` puts the scope where arc's own auth would,
+* at the phase arc expects, so tenant filtering and permission checks behave
+* identically to production.
+*
+* `defaultActor` applies to requests carrying no header. A malformed header
+* REJECTS rather than falling back to public — a test that meant to be an admin
+* and got quietly demoted is the most expensive way to fail.
+*/
+function testActorAuth(defaultActor) {
+	const authenticate = async (request) => {
+		const req = request;
+		const raw = req.headers[TEST_ACTOR_HEADER];
+		let spec = defaultActor;
+		if (typeof raw === "string") try {
+			spec = JSON.parse(raw);
+		} catch {
+			throw new Error(`[arc-testing] malformed ${TEST_ACTOR_HEADER} header: ${raw}. Build it with testActorHeaders() rather than by hand.`);
+		}
+		if (spec === void 0) return;
+		req.scope = scopeFromTestActor(spec);
+		req.user = {
+			id: getUserId(req.scope) ?? "test-anon",
+			...spec.roles !== void 0 ? { role: spec.roles } : {},
+			...spec.organizationId !== void 0 ? { organizationId: spec.organizationId } : {}
+		};
+	};
+	return {
+		type: "authenticator",
+		authenticate
+	};
+}
+//#endregion
 //#region src/testing/bootModuleApp.ts
 /**
 * The built-in DB factory: in-memory MongoDB via lazy devDep imports.
@@ -807,7 +975,6 @@ async function bootModuleApp(modules, options = {}) {
 	const db = await (options.database ?? mongoMemoryDatabase)({ replset: options.replset ?? false });
 	const ctx = {
 		uri: db.uri,
-		mongoUri: db.uri,
 		connection: db.connection
 	};
 	const resolved = typeof modules === "function" ? await modules(ctx) : modules;
@@ -816,7 +983,17 @@ async function bootModuleApp(modules, options = {}) {
 	try {
 		app = await createApp({
 			preset: "testing",
-			auth: false,
+			/**
+			* The test actor is arc's AUTHENTICATOR rather than a bolted-on hook, so the scope
+			* lands at the phase the rest of the pipeline expects — tenant filtering and
+			* permission checks then behave exactly as they do in production.
+			*
+			* This replaces the old `auth: false`. The authenticator is inert for a request
+			* carrying no `x-test-actor` header and no configured default, so a suite that
+			* never mentions an actor behaves as it did before. `options.app` still wins, so a
+			* suite exercising real auth can override it.
+			*/
+			auth: testActorAuth(options.actor),
 			sensible: false,
 			...options.app,
 			modules: list
@@ -830,7 +1007,6 @@ async function bootModuleApp(modules, options = {}) {
 	return {
 		app,
 		uri: db.uri,
-		mongoUri: db.uri,
 		connection: db.connection,
 		exports: (name) => getModuleExports(app, name),
 		close: async () => {
@@ -1009,12 +1185,13 @@ var HttpTestHarness = class {
 				it(`${verb} /:id with non-existent ID should return 404`, async () => {
 					const { app, fixtures } = this.getOptions();
 					const payload = fixtures.update ?? fixtures.valid;
-					expect((await app.inject({
+					const res = await app.inject({
 						method: verb,
 						url: `${this.getBaseUrl()}/000000000000000000000000`,
 						headers: this.adminHeaders(),
 						payload
-					})).statusCode).toBe(404);
+					});
+					expect(res.statusCode).toBe(404);
 				});
 			}
 			if (enabledRoutes.has("delete")) {
@@ -1031,24 +1208,29 @@ var HttpTestHarness = class {
 						deleteId = JSON.parse(createRes.body)._id;
 					}
 					if (!deleteId) return;
-					expect((await app.inject({
+					const res = await app.inject({
 						method: "DELETE",
 						url: `${this.getBaseUrl()}/${deleteId}`,
 						headers: this.adminHeaders()
-					})).statusCode).toBe(200);
-					if (enabledRoutes.has("get")) expect((await app.inject({
-						method: "GET",
-						url: `${this.getBaseUrl()}/${deleteId}`,
-						headers: this.adminHeaders()
-					})).statusCode).toBe(404);
+					});
+					expect(res.statusCode).toBe(200);
+					if (enabledRoutes.has("get")) {
+						const getRes = await app.inject({
+							method: "GET",
+							url: `${this.getBaseUrl()}/${deleteId}`,
+							headers: this.adminHeaders()
+						});
+						expect(getRes.statusCode).toBe(404);
+					}
 				});
 				it("DELETE /:id with non-existent ID should return 404", async () => {
 					const { app } = this.getOptions();
-					expect((await app.inject({
+					const res = await app.inject({
 						method: "DELETE",
 						url: `${this.getBaseUrl()}/000000000000000000000000`,
 						headers: this.adminHeaders()
-					})).statusCode).toBe(404);
+					});
+					expect(res.statusCode).toBe(404);
 				});
 			}
 		});
@@ -1067,49 +1249,55 @@ var HttpTestHarness = class {
 		describe(`${resource.displayName} HTTP Permissions`, () => {
 			if (enabledRoutes.has("list") && protectedOps.list) it("GET list without auth should return 401", async () => {
 				const { app } = this.getOptions();
-				expect((await app.inject({
+				const res = await app.inject({
 					method: "GET",
 					url: this.getBaseUrl()
-				})).statusCode).toBe(401);
+				});
+				expect(res.statusCode).toBe(401);
 			});
 			if (enabledRoutes.has("get") && protectedOps.get) it("GET /:id without auth should return 401", async () => {
 				const { app } = this.getOptions();
-				expect((await app.inject({
+				const res = await app.inject({
 					method: "GET",
 					url: `${this.getBaseUrl()}/000000000000000000000000`
-				})).statusCode).toBe(401);
+				});
+				expect(res.statusCode).toBe(401);
 			});
 			if (enabledRoutes.has("create") && protectedOps.create) it("POST without auth should return 401", async () => {
 				const { app, fixtures } = this.getOptions();
-				expect((await app.inject({
+				const res = await app.inject({
 					method: "POST",
 					url: this.getBaseUrl(),
 					payload: fixtures.valid
-				})).statusCode).toBe(401);
+				});
+				expect(res.statusCode).toBe(401);
 			});
 			if (enabledRoutes.has("update") && protectedOps.update) for (const verb of updateMethods) it(`${verb} without auth should return 401`, async () => {
 				const { app, fixtures } = this.getOptions();
 				const payload = fixtures.update ?? fixtures.valid;
-				expect((await app.inject({
+				const res = await app.inject({
 					method: verb,
 					url: `${this.getBaseUrl()}/000000000000000000000000`,
 					payload
-				})).statusCode).toBe(401);
+				});
+				expect(res.statusCode).toBe(401);
 			});
 			if (enabledRoutes.has("delete") && protectedOps.delete) it("DELETE without auth should return 401", async () => {
 				const { app } = this.getOptions();
-				expect((await app.inject({
+				const res = await app.inject({
 					method: "DELETE",
 					url: `${this.getBaseUrl()}/000000000000000000000000`
-				})).statusCode).toBe(401);
+				});
+				expect(res.statusCode).toBe(401);
 			});
 			if (enabledRoutes.has("list")) it("admin should access list endpoint", async () => {
 				const { app } = this.getOptions();
-				expect((await app.inject({
+				const res = await app.inject({
 					method: "GET",
 					url: this.getBaseUrl(),
 					headers: this.adminHeaders()
-				})).statusCode).toBeLessThan(400);
+				});
+				expect(res.statusCode).toBeLessThan(400);
 			});
 			if (enabledRoutes.has("create")) it("admin should access create endpoint", async () => {
 				const { app, fixtures } = this.getOptions();
@@ -1156,6 +1344,90 @@ function createHttpTestHarness(resource, optionsOrGetter) {
 	return new HttpTestHarness(resource, optionsOrGetter);
 }
 //#endregion
+//#region src/testing/moduleSetup.ts
+function createTestModuleSetup() {
+	const deferred = [];
+	return {
+		context: { defer(disposer) {
+			if (typeof disposer !== "function") throw new TypeError(`[arc/testing] defer() expected a function, received ${typeof disposer}.`);
+			deferred.push(disposer);
+		} },
+		deferred,
+		async dispose() {
+			const errors = [];
+			for (let i = deferred.length - 1; i >= 0; i--) {
+				const dispose = deferred[i];
+				if (!dispose) continue;
+				try {
+					await dispose();
+				} catch (err) {
+					errors.push(err);
+				}
+			}
+			deferred.length = 0;
+			if (errors.length === 1) throw errors[0];
+			if (errors.length > 1) throw new AggregateError(errors, `[arc/testing] ${errors.length} disposers threw`);
+		}
+	};
+}
+//#endregion
+//#region src/testing/scopeRoleGate.ts
+/**
+* `scopeRoleGate` — the ONE role gate for package tests.
+*
+* ## Why this is in the framework
+*
+* Nine `@classytic/arc-*` packages had their own copy of this helper, and all nine were
+* wrong in the same two ways:
+*
+* 1. They read the role from an `x-role` HEADER and INSTALLED the request scope from
+*    inside the check — so identity came from the caller's own claim, and it arrived too
+*    late for arc's tenant-filtering pipeline to see it.
+* 2. They returned the pre-2.30 `{ granted: boolean }` shape, which is neither a boolean
+*    nor an `AuthorizationDecision`. It passed through `normalizeToDecision` untouched,
+*    arrived with `effect: undefined`, and was read as DENY — the gate said yes and arc
+*    refused anyway. Nothing type-errored, because the gate is cast at the call site.
+*
+* Two of the nine had already been fixed by hand, each with a docstring describing this
+* exact discovery. The knowledge reached neither of the other seven. That is the whole
+* case for a shared seam: a copy does not fail, it diverges.
+*
+* A test role gate is generic — "does the verified scope hold one of these roles" has no
+* domain in it — so it belongs here, beside the contract it depends on.
+*
+* Identity itself comes from `testActorHeaders()` + `bootModuleApp`'s authenticator
+* (see `testActor.ts`), which puts the scope where production puts it. This stays a pure
+* predicate over what arc verified.
+*
+* Kept in its own module rather than beside `testActor.ts` so the two can be edited
+* independently.
+*/
+/**
+* Grants iff the caller is an org member holding one of `allowed` as an ORG role.
+*
+* This is `requireOrgRole` under a name package tests reach for — deliberately a
+* delegation, not a reimplementation. It previously read `scope.userRoles` while
+* requiring an organization, so it disagreed with production for any actor whose
+* global and org roles differ: given
+* `{ roles: ["employee"], orgRoles: ["manager"], organizationId: "org-1" }`,
+* `requireOrgRole("manager")` allowed and this denied. The tests never caught it
+* because `scopeFromTestActor` defaults `orgRoles` to `roles`, making the two
+* dimensions identical for the common actor.
+*
+* Delegating also inherits the semantics a hand-rolled gate kept missing:
+* elevated scopes pass, and a service (API-key) identity is refused with a
+* message naming `requireServiceScope` instead of silently failing a role test.
+*
+* **Pair it with an org-bearing actor.** `testActorHeaders('manager', ORG)`
+* yields a `member` scope and passes; `testActorHeaders('manager')` yields an
+* `authenticated` scope with no tenant, which is refused — arc's generated CRUD
+* filters by tenant, so a gate that waves a tenant-less request through is how a
+* green test reads another org's rows.
+*/
+function scopeRoleGate(...allowed) {
+	return requireOrgRole(...allowed);
+}
+//#endregion
 //#region src/testing/testApp.ts
 /**
 * createTestApp — test app factory for arc
@@ -1221,7 +1493,7 @@ function pickDefaultAuth(authMode, callerAuth) {
 	};
 }
 async function createTestApp(options = {}) {
-	const { createApp } = await import("../createApp-CXrKFciH.mjs").then((n) => n.r);
+	const { createApp } = await import("../createApp-Bv0m-Q6_.mjs").then((n) => n.r);
 	const { resources = [], db = "in-memory", connectMongoose = false, authMode = "jwt", defaultOrgId, plugins, auth: callerAuth, ...appOptions } = options;
 	let dbHandle;
 	let dbUri;
@@ -1291,4 +1563,4 @@ function createMinimalTestApp(options = {}) {
 	});
 }
 //#endregion
-export { HttpTestHarness, bootModuleApp, createBetterAuthProvider, createBetterAuthTestHelpers, createCustomAuthProvider, createDataFactory, createHttpTestHarness, createJwtAuthProvider, createMinimalTestApp, createMockController, createMockReply, createMockRepository, createMockRequest, createMockUser, createSpy, createTestApp, createTestFixtures, createTestTimer, expectArc, mongoMemoryDatabase, preloadResources, preloadResourcesAsync, runAuthorizationConformance, runStorageContract, safeParseBody, setupBetterAuthTestApp, waitFor };
+export { HttpTestHarness, TEST_ACTOR_HEADER, bootModuleApp, createBetterAuthProvider, createBetterAuthTestHelpers, createCustomAuthProvider, createDataFactory, createHttpTestHarness, createJwtAuthProvider, createMinimalTestApp, createMockController, createMockReply, createMockRepository, createMockRequest, createMockUser, createSpy, createTestApp, createTestFixtures, createTestModuleSetup, createTestTimer, expectArc, mongoMemoryDatabase, preloadResources, preloadResourcesAsync, runAuthorizationConformance, runStorageContract, safeParseBody, scopeFromTestActor, scopeRoleGate, setupBetterAuthTestApp, testActorAuth, testActorHeaders, waitFor };

package/dist/testing/outboxStoreContract.d.mts

@@ -1,11 +1,21 @@
+
 import { OutboxStore } from "@classytic/primitives/outbox";
 //#region src/testing/outboxStoreContract.d.ts
 interface OutboxStoreContractSetupResult {
   store: OutboxStore;
   /** Called once after the suite. */
   teardown?: () => Promise<void>;
-  /** Empty the store between tests. Strongly recommended for isolation. */
-  reset?: () => Promise<void>;
+  /**
+   * Empty the store. REQUIRED, and run before every test.
+   *
+   * Not a recommendation: several assertions are absolute rather than relative —
+   * "exactly zero pending", "exactly two", "`oldestPendingAgeMs()` is null on an
+   * empty queue". Without a reset those read whatever the previous test left, so the
+   * suite passes on ORDER rather than on behaviour, and inserting one unrelated case
+   * turns a conforming store red. A store that cannot empty itself cannot be
+   * conformance-tested.
+   */
+  reset: () => Promise<void>;
 }
 type OutboxStoreContractSetup = () => Promise<OutboxStoreContractSetupResult>;
 declare function runOutboxStoreContract(name: string, setup: OutboxStoreContractSetup): void;