@hot-updater/test-utils 1.0.0-rc.16 → 1.0.0-rc.17

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
 import { NIL_UUID, createReleaseCatalogScopeKey, encodeChannelKey, selectDesiredRelease } from "@hot-updater/core";
-import { DatabaseAdapterContractError, createMemoryAdapter, findPhysicalIndex, indexOrderTuple, verifyAdapter } from "@hot-updater/plugin-core/internal";
+import { DatabaseAdapterContractError, addDistinct, countDistinct, createMemoryAdapter, findPhysicalIndex, indexOrderTuple, verifyAdapter } from "@hot-updater/plugin-core/internal";
 import { createServer } from "node:http";
 //#region src/adminApiTestClient.ts
 const jsonRequest = (method, body) => ({
@@ -100,27 +100,6 @@ const createBundlePatchRowFixture = (suffix, bundleId, baseBundleId, orderIndex
 	byte_size: 3000000002,
 	order_index: orderIndex
 });
-const createBundleEventRowFixture = (suffix, receivedAtMs) => ({
-	id: fixtureId(suffix),
-	type: "UPDATE_APPLIED",
-	install_id: `install-${suffix}`,
-	user_id: null,
-	metadata: {
-		username: null,
-		cohort: "0",
-		update_strategy: "appVersion",
-		fingerprint_hash: null,
-		sdk_version: null
-	},
-	from_bundle_id: fixtureId(`${Number(suffix) + 1e3}`),
-	from_release_id: null,
-	to_bundle_id: fixtureId(`${Number(suffix) + 2e3}`),
-	to_release_id: null,
-	platform: "ios",
-	app_version: "1.0.0",
-	channel: "production",
-	received_at_ms: receivedAtMs
-});
 const createBundleFixture = (suffix, _channel = "production") => ({
 	id: fixtureId(suffix),
 	platform: "ios",
@@ -374,729 +353,6 @@ const setupCoreAdminTestSuite = (options) => {
 	});
 };
 //#endregion
-//#region src/expectInsightsIndex.ts
-/** Allow committed secondary indexes to catch up; query failures still fail. */
-const expectInsightsIndex = async (query, expected) => {
-	const deadline = Date.now() + 5e3;
-	for (;;) {
-		const actual = await query();
-		try {
-			expect(actual).toEqual(expected);
-			return;
-		} catch (error) {
-			if (Date.now() >= deadline) throw error;
-		}
-		await new Promise((resolve) => setTimeout(resolve, 50));
-	}
-};
-//#endregion
-//#region src/setupInsightsHttpTestSuite.ts
-/**
-* The Insights plugin's routes on a database: a client reports an event, and
-* the admin routes read it back. The server must run `insights()`.
-*/
-const setupInsightsHttpTestSuite = (options) => {
-	describe("Insights HTTP routes", () => {
-		it("records a reported event and reads it back", async () => {
-			const client = options.getClient();
-			const installId = `install-${crypto.randomUUID()}`;
-			const userId = `user-${crypto.randomUUID()}`;
-			const channel = `insights-${crypto.randomUUID()}`;
-			const event = {
-				appVersion: "1.0.0",
-				channel,
-				cohort: "default",
-				fingerprintHash: null,
-				fromBundleId: null,
-				fromReleaseId: null,
-				installId,
-				platform: "ios",
-				toBundleId: "00000000-0000-7000-8000-000000000001",
-				toReleaseId: null,
-				type: "UNCHANGED",
-				updateStrategy: null,
-				userId,
-				username: "Jane",
-				sdkVersion: "2.0.0"
-			};
-			const reported = await client.client("/events", jsonRequest("POST", event));
-			expect(reported.status).toBe(204);
-			expect(reported.headers.get("x-hot-updater-insights")).toBeNull();
-			await reported.text();
-			const installation = await client.admin(`/installations/${encodeURIComponent(installId)}`);
-			expect(installation.status).toBe(200);
-			expect(await installation.json()).toMatchObject({
-				installId,
-				latestStatus: "UNCHANGED",
-				lastKnownBundleId: event.toBundleId,
-				channel
-			});
-			await expectInsightsIndex(async () => {
-				return (await (await client.admin(`/installations?userId=${encodeURIComponent(userId)}`)).json()).data.map(({ installId: id }) => id);
-			}, [installId]);
-			await expectInsightsIndex(async () => {
-				return (await (await client.admin(`/overview?platform=ios&channel=${encodeURIComponent(channel)}&window=24h`)).json()).reportingInstallations.count;
-			}, 1);
-		});
-		it("refuses a malformed event", async () => {
-			const response = await options.getClient().client("/events", jsonRequest("POST", { type: "UNCHANGED" }));
-			expect(response.status).toBe(400);
-			await response.text();
-		});
-	});
-};
-//#endregion
-//#region src/databaseTestRunner.ts
-var DatabaseUnavailableError = class extends Error {
-	constructor() {
-		super("The database is unavailable outside the test lifecycle");
-		this.name = "DatabaseUnavailableError";
-	}
-};
-const setupDatabaseTestRunner = (lifecycle, registerTests) => {
-	describe(lifecycle.name, () => {
-		let database;
-		const getDatabase = () => {
-			if (database === void 0) throw new DatabaseUnavailableError();
-			return database;
-		};
-		beforeAll(async () => {
-			await lifecycle.migrate();
-			database = await lifecycle.createDatabase();
-		});
-		beforeEach(async () => {
-			await lifecycle.reset(getDatabase());
-		});
-		afterAll(async () => {
-			await lifecycle.dispose(getDatabase());
-			database = void 0;
-		});
-		registerTests({ getDatabase });
-	});
-};
-//#endregion
-//#region src/insightsModelTests.ts
-const record = (model, event) => model.recordEvent({ event });
-const createMovementEvent = (suffix, receivedAtMs, type, installId) => {
-	const row = createBundleEventRowFixture(suffix, receivedAtMs);
-	return {
-		...row,
-		type,
-		install_id: installId,
-		from_bundle_id: row.to_bundle_id,
-		metadata: {
-			...row.metadata,
-			update_strategy: "appVersion"
-		}
-	};
-};
-/**
-* The Insights report contract on `InsightsModel`: what the Insights plugin
-* records and reads, through `createInsightsModel`, on one database.
-*/
-const registerInsightsModelTests = (state) => {
-	describe("Insights report contract", () => {
-		it("preserves ancillary JSON through event history and latest-event reads", async () => {
-			const model = state.getDatabase();
-			const base = createBundleEventRowFixture("979", 100);
-			const event = {
-				...base,
-				metadata: {
-					...base.metadata,
-					device: {
-						locale: "ko-KR",
-						tags: [
-							"minor",
-							null,
-							true,
-							2
-						]
-					},
-					diagnostic: null
-				}
-			};
-			await record(model, event);
-			await expect(model.findLatestEvents({ installId: event.install_id })).resolves.toEqual([event]);
-			await expectInsightsIndex(() => model.listEvents({
-				filter: { kind: "all" },
-				beforeReceivedAtMs: 101,
-				limit: 10
-			}), [event]);
-		});
-		it("selects the latest complete event across download, replacement, apply, and delayed reports", async () => {
-			const model = state.getDatabase();
-			const download = {
-				...createBundleEventRowFixture("980", 100),
-				type: "UPDATE_DOWNLOADED",
-				from_bundle_id: "00000000-0000-7000-8000-000000001980",
-				metadata: {
-					...createBundleEventRowFixture("980", 100).metadata,
-					update_strategy: "appVersion"
-				},
-				to_release_id: "00000000-0000-7000-8000-000000004980"
-			};
-			await record(model, download);
-			await record(model, download);
-			await expect(model.findLatestEvents({ installId: download.install_id })).resolves.toEqual([download]);
-			await expectInsightsIndex(() => model.listEvents({
-				filter: {
-					kind: "bundle",
-					type: "UPDATE_DOWNLOADED",
-					toBundleId: download.to_bundle_id,
-					platform: "ios",
-					channel: "production"
-				},
-				beforeReceivedAtMs: 200,
-				limit: 10
-			}), [download]);
-			const replacement = {
-				...download,
-				id: createBundleEventRowFixture("981", 110).id,
-				received_at_ms: 110,
-				to_bundle_id: "00000000-0000-7000-8000-000000002981"
-			};
-			await record(model, replacement);
-			await expect(model.findLatestEvents({ installId: download.install_id })).resolves.toEqual([replacement]);
-			const applied = {
-				...replacement,
-				type: "UPDATE_APPLIED",
-				id: createBundleEventRowFixture("982", 120).id,
-				received_at_ms: 120
-			};
-			await record(model, applied);
-			await record(model, {
-				...download,
-				id: createBundleEventRowFixture("983", 105).id,
-				received_at_ms: 105
-			});
-			await expect(model.findLatestEvents({ installId: download.install_id })).resolves.toEqual([applied]);
-			await expectInsightsIndex(() => model.listEvents({
-				filter: {
-					kind: "installationMovement",
-					installId: download.install_id
-				},
-				beforeReceivedAtMs: 200,
-				limit: 10
-			}), [
-				applied,
-				replacement,
-				{
-					...download,
-					id: createBundleEventRowFixture("983", 105).id,
-					received_at_ms: 105
-				},
-				download
-			]);
-		});
-		it("treats duplicate IDs as complete no-ops, including changed retry payloads", async () => {
-			const model = state.getDatabase();
-			const event = createBundleEventRowFixture("901", 100);
-			await Promise.all([
-				record(model, event),
-				record(model, event),
-				record(model, event)
-			]);
-			await record(model, event);
-			const changed = {
-				...event,
-				received_at_ms: 300,
-				user_id: "changed-user"
-			};
-			await record(model, changed);
-			const otherInstallation = {
-				...changed,
-				install_id: "different-install"
-			};
-			await record(model, otherInstallation);
-			await expect(model.findLatestEvents({ installId: event.install_id })).resolves.toEqual([event]);
-			await expect(model.findLatestEvents({ installId: otherInstallation.install_id })).resolves.toEqual([]);
-			await expectInsightsIndex(() => model.listEvents({
-				filter: { kind: "all" },
-				beforeReceivedAtMs: 400,
-				limit: 10
-			}), [event]);
-		});
-		it("keeps all concurrent events and the greatest timestamp/ID state, including logout", async () => {
-			const model = state.getDatabase();
-			const older = {
-				...createBundleEventRowFixture("912", 100),
-				install_id: "concurrent",
-				user_id: "previous"
-			};
-			const tied = {
-				...createBundleEventRowFixture("910", 200),
-				install_id: "concurrent",
-				user_id: "previous"
-			};
-			const newest = {
-				...createBundleEventRowFixture("911", 200),
-				install_id: "concurrent",
-				user_id: null
-			};
-			await Promise.all([
-				record(model, newest),
-				record(model, older),
-				record(model, tied)
-			]);
-			await record(model, older);
-			await expect(model.findLatestEvents({ installId: "concurrent" })).resolves.toEqual([newest]);
-			await expect(model.findLatestEvents({
-				userId: "previous",
-				limit: 10
-			})).resolves.toEqual([]);
-			await expectInsightsIndex(() => model.listEvents({
-				filter: { kind: "all" },
-				beforeReceivedAtMs: 201,
-				limit: 10
-			}), [
-				newest,
-				tied,
-				older
-			]);
-		});
-		it("rejects invalid event metadata before persisting a report", async () => {
-			const model = state.getDatabase();
-			const event = createBundleEventRowFixture("920", 100);
-			await expect(model.recordEvent({ event: {
-				...event,
-				metadata: {
-					...event.metadata,
-					cohort: 123
-				}
-			} })).rejects.toMatchObject({ code: "invalid-data" });
-			await expect(model.findLatestEvents({ installId: event.install_id })).resolves.toEqual([]);
-			await expect(model.listEvents({
-				filter: { kind: "all" },
-				beforeReceivedAtMs: 200,
-				limit: 10
-			})).resolves.toEqual([]);
-		});
-		it("shares scoped list/count predicates, recovery attribution, and half-open time bounds", async () => {
-			const model = state.getDatabase();
-			const bundleA = createBundleEventRowFixture("1", 0).to_bundle_id;
-			const bundleB = createBundleEventRowFixture("2", 0).to_bundle_id;
-			const bundleC = createBundleEventRowFixture("3", 0).to_bundle_id;
-			const applied = {
-				...createBundleEventRowFixture("930", 100),
-				install_id: "target",
-				to_bundle_id: bundleB
-			};
-			const recovered = {
-				...createBundleEventRowFixture("931", 120),
-				install_id: "target",
-				type: "RECOVERED",
-				from_bundle_id: bundleB,
-				to_bundle_id: bundleA,
-				metadata: {
-					...createBundleEventRowFixture("931", 120).metadata,
-					update_strategy: "appVersion"
-				}
-			};
-			const unchanged = {
-				...createBundleEventRowFixture("932", 130),
-				type: "UNCHANGED",
-				from_bundle_id: null,
-				to_bundle_id: bundleB,
-				metadata: {
-					...createBundleEventRowFixture("932", 130).metadata,
-					update_strategy: null
-				}
-			};
-			const excluded = [
-				{
-					...applied,
-					id: createBundleEventRowFixture("933", 99).id,
-					install_id: "before",
-					received_at_ms: 99
-				},
-				{
-					...applied,
-					id: createBundleEventRowFixture("934", 200).id,
-					install_id: "after",
-					received_at_ms: 200
-				},
-				{
-					...applied,
-					id: createBundleEventRowFixture("935", 110).id,
-					install_id: "android",
-					platform: "android"
-				},
-				{
-					...applied,
-					id: createBundleEventRowFixture("936", 110).id,
-					install_id: "preview",
-					channel: "preview"
-				},
-				{
-					...recovered,
-					id: createBundleEventRowFixture("937", 125).id,
-					install_id: "other-source",
-					from_bundle_id: bundleC,
-					to_bundle_id: bundleB
-				}
-			];
-			for (const row of [
-				applied,
-				recovered,
-				unchanged,
-				...excluded
-			]) await record(model, row);
-			await expect(async () => record(model, {
-				...applied,
-				type: "RELEASE_ADOPTED"
-			})).rejects.toThrow();
-			await expect(async () => record(model, {
-				...applied,
-				type: "UNCHANGED",
-				from_bundle_id: bundleB,
-				metadata: {
-					...applied.metadata,
-					update_strategy: "appVersion"
-				}
-			})).rejects.toThrow();
-			await expect(model.findLatestEvents({ installId: "target" })).resolves.toEqual([recovered]);
-			const cases = [
-				[{
-					platform: "ios",
-					channel: "production",
-					type: "UPDATE_APPLIED",
-					toBundleId: bundleB
-				}, applied],
-				[{
-					platform: "ios",
-					channel: "production",
-					type: "RECOVERED",
-					fromBundleId: bundleB
-				}, recovered],
-				[{
-					platform: "ios",
-					channel: "production",
-					type: "UNCHANGED",
-					toBundleId: bundleB
-				}, unchanged]
-			];
-			for (const [filter, expected] of cases) {
-				await expectInsightsIndex(() => model.countEvents({
-					filter,
-					sinceMs: 100,
-					beforeReceivedAtMs: 200
-				}), 1);
-				await expectInsightsIndex(() => model.listEvents({
-					filter: {
-						kind: "bundle",
-						...filter
-					},
-					sinceMs: 100,
-					beforeReceivedAtMs: 200,
-					limit: 1
-				}), [expected]);
-			}
-			await expectInsightsIndex(() => model.countLatestEvents({
-				platform: "ios",
-				channel: "production",
-				sinceMs: 100,
-				bundle: [{
-					field: "to_bundle_id",
-					value: bundleA,
-					types: [
-						"UNCHANGED",
-						"UPDATE_APPLIED",
-						"RECOVERED"
-					]
-				}]
-			}), 1);
-			await expectInsightsIndex(() => model.countLatestEvents({
-				platform: "ios",
-				channel: "production",
-				sinceMs: 100
-			}), 4);
-		});
-		it("uses exact identity and UTF-8 cursor order for user installations", async () => {
-			const model = state.getDatabase();
-			const ids = [
-				"Install-a",
-				"é",
-				"install-a",
-				"install-a ",
-				"é",
-				"",
-				"😀"
-			];
-			const events = ids.map((install_id, index) => ({
-				...createBundleEventRowFixture(String(950 + index), 100),
-				install_id,
-				user_id: "User-é"
-			}));
-			for (const event of events.toReversed()) await record(model, event);
-			const spacedUser = {
-				...createBundleEventRowFixture("960", 100),
-				install_id: "spaced-user-install",
-				user_id: "User-é "
-			};
-			await record(model, spacedUser);
-			await expectInsightsIndex(async () => {
-				const found = [];
-				let afterInstallId;
-				for (let pageIndex = 0; pageIndex <= ids.length; pageIndex++) {
-					const page = await model.findLatestEvents({
-						userId: "User-é",
-						afterInstallId,
-						limit: 2
-					});
-					found.push(...page.map((row) => row.install_id));
-					if (page.length < 2) return found;
-					const nextCursor = page[page.length - 1].install_id;
-					expect(nextCursor, "Insights cursor must advance").not.toBe(afterInstallId);
-					afterInstallId = nextCursor;
-				}
-				throw new Error("Insights pagination did not terminate");
-			}, ids);
-			await expectInsightsIndex(() => model.findLatestEvents({
-				userId: "User-é ",
-				limit: 10
-			}), [spacedUser]);
-			await expect(model.findLatestEvents({
-				userId: "user-é",
-				limit: 10
-			})).resolves.toEqual([]);
-			await expect(model.findLatestEvents({ installId: "INSTALL-a" })).resolves.toEqual([]);
-			await expect(model.findLatestEvents({ installId: "Install-a" })).resolves.toEqual([events[0]]);
-			await expect(model.findLatestEvents({ installId: "install-a " })).resolves.toEqual([events[3]]);
-			await expect(model.findLatestEvents({ installId: "install-a" })).resolves.toEqual([events[2]]);
-		});
-		it("counts overlapping bundle predicates once per latest installation", async () => {
-			const model = state.getDatabase();
-			const event = createBundleEventRowFixture("9700", 100);
-			await record(model, event);
-			const predicate = {
-				field: "to_bundle_id",
-				value: event.to_bundle_id,
-				types: [event.type]
-			};
-			await expectInsightsIndex(() => model.countLatestEvents({
-				platform: event.platform,
-				channel: event.channel,
-				sinceMs: 0,
-				bundle: [predicate, predicate]
-			}), 1);
-		});
-		it("counts a latest installation once when a from and a to predicate both match it", async () => {
-			const model = state.getDatabase();
-			const moved = createBundleEventRowFixture("9701", 100);
-			await record(model, moved);
-			await expectInsightsIndex(() => model.countLatestEvents({
-				platform: moved.platform,
-				channel: moved.channel,
-				sinceMs: 0,
-				bundle: [{
-					field: "from_bundle_id",
-					value: moved.from_bundle_id,
-					types: [moved.type]
-				}, {
-					field: "to_bundle_id",
-					value: moved.to_bundle_id,
-					types: [moved.type]
-				}]
-			}), 1);
-		});
-		it("returns zero for successful empty scalar queries", async () => {
-			const model = state.getDatabase();
-			await expect(model.countLatestEvents({
-				platform: "ios",
-				channel: "production",
-				sinceMs: 0
-			})).resolves.toBe(0);
-			await expect(model.countEvents({
-				filter: {
-					platform: "ios",
-					channel: "production",
-					type: "RECOVERED",
-					fromBundleId: createBundleEventRowFixture("1", 0).to_bundle_id
-				},
-				sinceMs: 0,
-				beforeReceivedAtMs: 100
-			})).resolves.toBe(0);
-		});
-		it("maintains idempotent release, scope, usage, and latest-distribution summaries", async () => {
-			const model = state.getDatabase();
-			const releaseA = "00000000-0000-7000-8000-000000008001";
-			const releaseB = "00000000-0000-7000-8000-000000008002";
-			const download = {
-				...createBundleEventRowFixture("9801", 1e3),
-				type: "UPDATE_DOWNLOADED",
-				install_id: "summary-install-a",
-				from_release_id: releaseA,
-				to_release_id: releaseB
-			};
-			const appliedA = {
-				...download,
-				id: createBundleEventRowFixture("9802", 2e3).id,
-				type: "UPDATE_APPLIED",
-				received_at_ms: 2e3
-			};
-			const appliedB = {
-				...appliedA,
-				id: createBundleEventRowFixture("9803", 2100).id,
-				install_id: "summary-install-b",
-				received_at_ms: 2100
-			};
-			const recovered = {
-				...appliedA,
-				id: createBundleEventRowFixture("9804", 3e3).id,
-				type: "RECOVERED",
-				from_release_id: releaseB,
-				to_release_id: releaseA,
-				received_at_ms: 3e3
-			};
-			for (const event of [
-				download,
-				appliedA,
-				appliedB,
-				appliedB,
-				recovered
-			]) await record(model, event);
-			const releases = [{
-				releaseId: releaseA,
-				platform: "ios",
-				channel: "production"
-			}, {
-				releaseId: releaseB,
-				platform: "ios",
-				channel: "production"
-			}];
-			const lifetime = await model.getReleaseActivity({ releases });
-			expect(lifetime.data.map(({ metrics }) => metrics)).toEqual([{
-				downloads: 0,
-				launches: 1,
-				failedLaunches: 0
-			}, {
-				downloads: 1,
-				launches: 2,
-				failedLaunches: 1
-			}]);
-			const scope = await model.getReleaseActivity({
-				scope: {
-					platform: "ios",
-					channel: "production"
-				},
-				timeRange: {
-					start: 0,
-					end: 36e5
-				}
-			});
-			expect(scope.data[0]?.metrics).toMatchObject({
-				downloads: 1,
-				launches: 3,
-				failedLaunches: 1,
-				uniqueUsers: 2
-			});
-			const usage = await model.getAppUsage({
-				channel: "production",
-				platform: "all",
-				timeRange: {
-					start: 0,
-					end: 36e5
-				},
-				intervalMs: 36e5
-			});
-			expect(usage.activeInstallations).toBe(2);
-			expect(usage.points).toEqual([{
-				startMs: 0,
-				installations: 2
-			}]);
-			expect(usage.bundleDistribution).toEqual(expect.arrayContaining([{
-				appVersion: "1.0.0",
-				platform: "ios",
-				releaseId: releaseA,
-				installations: 1
-			}, {
-				appVersion: "1.0.0",
-				platform: "ios",
-				releaseId: releaseB,
-				installations: 1
-			}]));
-		});
-		it("pages insights events newest first with a stable cursor", async () => {
-			const model = state.getDatabase();
-			const first = createBundleEventRowFixture("701", 100);
-			const second = createBundleEventRowFixture("702", 100);
-			const third = createBundleEventRowFixture("703", 200);
-			await model.recordEvent({ event: third });
-			await model.recordEvent({ event: second });
-			await model.recordEvent({ event: first });
-			await expectInsightsIndex(() => model.listEvents({
-				filter: { kind: "all" },
-				beforeReceivedAtMs: 201,
-				limit: 2
-			}), [third, second]);
-			await expectInsightsIndex(() => model.listEvents({
-				filter: { kind: "all" },
-				after: {
-					receivedAtMs: second.received_at_ms,
-					id: second.id
-				},
-				beforeReceivedAtMs: 201,
-				limit: 2
-			}), [first]);
-			await expectInsightsIndex(() => model.listEvents({
-				filter: { kind: "all" },
-				beforeReceivedAtMs: 200,
-				limit: 10
-			}), [second, first]);
-		});
-		it("filters installation movements before applying the page limit", async () => {
-			const model = state.getDatabase();
-			const unchanged = {
-				...createBundleEventRowFixture("711", 300),
-				type: "UNCHANGED",
-				install_id: "install-target",
-				from_bundle_id: null,
-				metadata: {
-					...createBundleEventRowFixture("711", 300).metadata,
-					update_strategy: null
-				}
-			};
-			const unrelated = createMovementEvent("712", 250, "UPDATE_APPLIED", "install-other");
-			const applied = createMovementEvent("713", 200, "UPDATE_APPLIED", "install-target");
-			const recovered = createMovementEvent("714", 100, "RECOVERED", "install-target");
-			for (const row of [
-				unchanged,
-				unrelated,
-				applied,
-				recovered
-			]) await model.recordEvent({ event: row });
-			await expectInsightsIndex(() => model.listEvents({
-				filter: {
-					kind: "installationMovement",
-					installId: "install-target"
-				},
-				beforeReceivedAtMs: 301,
-				limit: 1
-			}), [applied]);
-			await expectInsightsIndex(() => model.listEvents({
-				filter: {
-					kind: "installationMovement",
-					installId: "install-target"
-				},
-				after: {
-					receivedAtMs: applied.received_at_ms,
-					id: applied.id
-				},
-				beforeReceivedAtMs: 301,
-				limit: 1
-			}), [recovered]);
-		});
-	});
-};
-//#endregion
-//#region src/setupInsightsModelTestSuite.ts
-/**
-* The Insights report contract on one database: pass the Insights plugin's
-* model over it, `createInsightsModel(createDatabasePluginApis(database,
-* [insights()]).insights)`, as `createDatabase`.
-*/
-const setupInsightsModelTestSuite = (lifecycle) => setupDatabaseTestRunner(lifecycle, registerInsightsModelTests);
-//#endregion
 //#region src/setupSemverSatisfiesTestSuite.ts
 /**
 *
@@ -1307,6 +563,35 @@ const setupSemverSatisfiesTestSuite = ({ semverSatisfies }) => {
 	});
 };
 //#endregion
+//#region src/databaseTestRunner.ts
+var DatabaseUnavailableError = class extends Error {
+	constructor() {
+		super("The database is unavailable outside the test lifecycle");
+		this.name = "DatabaseUnavailableError";
+	}
+};
+const setupDatabaseTestRunner = (lifecycle, registerTests) => {
+	describe(lifecycle.name, () => {
+		let database;
+		const getDatabase = () => {
+			if (database === void 0) throw new DatabaseUnavailableError();
+			return database;
+		};
+		beforeAll(async () => {
+			await lifecycle.migrate();
+			database = await lifecycle.createDatabase();
+		});
+		beforeEach(async () => {
+			await lifecycle.reset(getDatabase());
+		});
+		afterAll(async () => {
+			await lifecycle.dispose(getDatabase());
+			database = void 0;
+		});
+		registerTests({ getDatabase });
+	});
+};
+//#endregion
 //#region src/releaseCatalogHttpFixtures.ts
 const releaseCatalogDownloadUrl = (uri) => `https://storage.example.com/${encodeURIComponent(uri)}`;
 const targetId = createBundleRowFixture("302").id;
@@ -1701,10 +986,11 @@ const setupReleaseCatalogTestSuite = (options) => {
 				const otherPath = strategy === "APP_VERSION" ? `/release-catalogs/fingerprint/ios/${scope().channelKey}/fingerprint-a` : `/release-catalogs/app-version/ios/${scope().channelKey}/1.2.3`;
 				expect((await request(otherPath)).status).toBe(404);
 			});
-			it("returns an uncached 404 for an unknown scope", async () => {
+			it("caches an unknown scope's 404 like a catalog", async () => {
 				const response = await request(catalogPath());
 				expect(response.status).toBe(404);
-				expect(response.headers.get("cache-control")).toBe("private, no-store");
+				expect(response.headers.get("cache-control")).toBe("public, max-age=0, s-maxage=5");
+				expect(response.headers.get("x-hot-updater-catalog")).toBe("none");
 				await publish("121");
 				expect((await readCatalog()).releases).toHaveLength(1);
 			});
@@ -2016,9 +1302,8 @@ const setupReleaseCatalogTestSuite = (options) => {
 //#region src/setupDatabaseTestSuite.ts
 /**
 * A provider's database under Hot Updater's server: core's operations, the
-* Release Catalog contract, bundles, and Insights, all through HTTP, on the
-* tables the provider's tooling creates; with `createInsightsModel`, also the
-* Insights report contract in process.
+* Release Catalog contract, and bundles, all through HTTP, on the tables the
+* provider's tooling creates, then each opted-in plugin's suite.
 */
 const setupDatabaseTestSuite = (options) => {
 	setupDatabaseTestRunner(options, ({ getDatabase }) => {
@@ -2040,10 +1325,11 @@ const setupDatabaseTestSuite = (options) => {
 		setupCoreAdminTestSuite({ getClient });
 		setupBundleMethodsTestSuite({ getClient });
 		setupReleaseCatalogTestSuite({ getClient });
-		setupInsightsHttpTestSuite({ getClient });
-		const { createInsightsModel } = options;
-		if (createInsightsModel !== void 0) describe("Insights model", () => {
-			registerInsightsModelTests({ getDatabase: () => createInsightsModel(getDatabase()) });
+		for (const suite of options.plugins ?? []) describe(suite.name, () => {
+			suite.register({
+				getClient,
+				getDatabase
+			});
 		});
 	});
 };
@@ -2170,7 +1456,71 @@ const conformanceCounters = {
 		sort: ["shard"]
 	}]
 };
-const tables = [conformanceItems, conformanceCounters];
+/** Rows expire 1,000 ms after `at`; a null `at` never expires. */
+const conformanceExpiring = {
+	name: "conformance_expiring",
+	columns: [
+		{
+			name: "id",
+			type: "string",
+			nullable: false,
+			maxLength: 64
+		},
+		{
+			name: "grp",
+			type: "string",
+			nullable: false,
+			maxLength: 64
+		},
+		{
+			name: "at",
+			type: "integer",
+			nullable: true
+		},
+		{
+			name: "tags",
+			type: "string",
+			nullable: true,
+			maxLength: 64,
+			multi: true
+		},
+		{
+			name: "_v",
+			type: "integer",
+			nullable: false
+		}
+	],
+	key: ["id"],
+	indexes: [{
+		name: "byGroup",
+		eq: ["grp"],
+		sort: ["id"]
+	}, {
+		name: "byTag",
+		eq: ["tags"],
+		sort: []
+	}],
+	retention: {
+		column: "at",
+		ms: 1e3
+	}
+};
+const tables = [
+	conformanceItems,
+	conformanceCounters,
+	conformanceExpiring
+];
+const expiring = (id, at) => ({
+	type: "insert",
+	table: conformanceExpiring,
+	row: {
+		id,
+		grp: "g",
+		at,
+		tags: ["t"],
+		_v: 0
+	}
+});
 const item = (id, values = {}) => ({
 	id,
 	grp: "g",
@@ -2747,6 +2097,79 @@ const setupDatabaseAdapterConformanceSuite = (options) => {
 			const results = await Promise.all([adapter.write(skew(a, b)), adapter.write(skew(b, a))]);
 			expect(results.filter((result) => result.ok).length).toBeLessThanOrEqual(1);
 		});
+		const expiringIds = async (adapter) => ({
+			byGroup: ids(await adapter.query(conformanceExpiring, {
+				index: "byGroup",
+				eq: ["g"],
+				order: "asc",
+				limit: 500
+			})),
+			byTag: ids(await adapter.query(conformanceExpiring, {
+				index: "byTag",
+				eq: ["t"],
+				order: "asc",
+				limit: 500
+			}))
+		});
+		it.skipIf(options.retention === "ttl")("prunes expired rows oldest first, up to the limit, with their index entries", async () => {
+			const adapter = await setup();
+			await ok(adapter, [
+				expiring("a", 300),
+				expiring("b", 100),
+				expiring("c", 200),
+				expiring("d", null),
+				expiring("e", 5e3),
+				expiring("f", 100)
+			]);
+			expect(await adapter.prune(conformanceExpiring, 250, 2)).toBe(2);
+			expect((await expiringIds(adapter)).byGroup).toEqual([
+				"a",
+				"c",
+				"d",
+				"e"
+			]);
+			expect(await adapter.prune(conformanceExpiring, 250, 10)).toBe(1);
+			expect(await adapter.prune(conformanceExpiring, 250, 10)).toBe(0);
+			expect(await expiringIds(adapter)).toEqual({
+				byGroup: [
+					"a",
+					"d",
+					"e"
+				],
+				byTag: [
+					"a",
+					"d",
+					"e"
+				]
+			});
+			expect(await adapter.get(conformanceExpiring, [
+				["b"],
+				["c"],
+				["d"]
+			])).toEqual([
+				null,
+				null,
+				expect.objectContaining({
+					id: "d",
+					at: null
+				})
+			]);
+			await ok(adapter, [insert(item("kept"))]);
+			expect(await adapter.prune(conformanceExpiring, 1e4, 10)).toBe(2);
+			expect(ids(await query(adapter, {
+				index: "all",
+				eq: []
+			}))).toEqual(["kept"]);
+		});
+		it.skipIf(options.retention !== "ttl")("leaves expired rows to the backend's TTL and reads them until it deletes them", async () => {
+			const adapter = await setup();
+			expect(adapter.prune).toBeUndefined();
+			await ok(adapter, [expiring("old", 0), expiring("never", null)]);
+			expect(await expiringIds(adapter)).toEqual({
+				byGroup: ["never", "old"],
+				byTag: ["never", "old"]
+			});
+		});
 		it.skipIf(options.maxOps === void 0)("rejects an over-limit write before sending it", async () => {
 			const adapter = await setup();
 			const ops = Array.from({ length: (options.maxOps ?? 0) + 1 }, (_, index) => insert(item(`over${index}`)));
@@ -2792,7 +2215,6 @@ const eventOf = (n, overrides = {}) => ({
 	app_version: "1.0.0",
 	channel: "production",
 	metadata: {
-		username: null,
 		cohort: "1",
 		update_strategy: "appVersion",
 		fingerprint_hash: null,
@@ -2802,6 +2224,31 @@ const eventOf = (n, overrides = {}) => ({
 	...overrides
 });
 /**
+* Update failures on day 3, after every other windowed read's range: installs
+* 3 and 5 fail to download release-b, and install 7's update check fails.
+*/
+const failureOf = (n, install, check = false) => eventOf(200 + n, {
+	type: "UPDATE_FAILED",
+	install_id: `install-${install}`,
+	from_release_id: "release-a",
+	from_bundle_id: "bundle-a",
+	to_release_id: check ? null : "release-b",
+	to_bundle_id: check ? "bundle-a" : "bundle-b",
+	metadata: {
+		...eventOf(0).metadata,
+		failure: check ? {
+			stage: "check",
+			reason: "http",
+			http_status: 500
+		} : {
+			stage: "download",
+			reason: "http",
+			http_status: 403
+		}
+	},
+	received_at_ms: T0 + 3 * DAY + n * 10 * 6e4
+});
+/**
 * History event `n` of the day before T0, three an hour, on its own release
 * and bundles: every windowed read, which starts at T0 or later, skips it.
 */
@@ -2894,6 +2341,9 @@ const seed = async (database, server) => {
 		received_at_ms: T0 + 2 * DAY
 	}));
 	for (let n = 1; n <= 72; n += 1) await api.insights.recordEvent(historyOf(n));
+	await api.insights.recordEvent(failureOf(1, 3));
+	await api.insights.recordEvent(failureOf(2, 5));
+	await api.insights.recordEvent(failureOf(3, 7, true));
 	const channel = (name) => core.findChannelByName(name).then((found) => found);
 	const productionId = (await channel("production")).id;
 	return {
@@ -3140,14 +2590,14 @@ const READ_BUDGETS = [
 		read: ({ insights }) => insights.countLatestEvents({
 			platform: "ios",
 			channel: "production",
-			sinceMs: T0 + HOUR
+			sinceMs: T0
 		}),
-		adapter: reads(0, 0, 1, 20),
+		adapter: reads(0, 0, 1, 15),
 		engine: {
 			calls: 1,
-			rows: 5
+			rows: 2
 		},
-		check: (count) => expect(count).toBe(20)
+		check: (count) => expect(count).toBe(24)
 	}),
 	budget({
 		api: "countLatestEvents by bundle: buckets in the window × shards, all used",
@@ -3161,10 +2611,10 @@ const READ_BUDGETS = [
 				types: ["UPDATE_APPLIED"]
 			}]
 		}),
-		adapter: reads(0, 0, 1, 24),
+		adapter: reads(0, 0, 1, 15),
 		engine: {
 			calls: 1,
-			rows: 6
+			rows: 2
 		},
 		check: (count) => expect(count).toBe(24)
 	}),
@@ -3212,16 +2662,79 @@ const READ_BUDGETS = [
 			},
 			intervalMs: DAY
 		}),
-		adapter: reads(0, 0, 3, 39),
+		adapter: reads(0, 0, 4, 30),
 		engine: {
-			calls: 3,
-			rows: 8
+			calls: 4,
+			rows: 4
 		},
 		check: ({ versions }) => expect(versions).toEqual([{
 			name: "1.0.0",
 			installations: 24
 		}])
 	}),
+	budget({
+		api: "update failures of a release over a window: buckets × shards, all used",
+		read: ({ insights }) => insights.getUpdateFailures({
+			platform: "ios",
+			channel: "production",
+			releaseId: "release-b",
+			timeRange: {
+				start: T0 + 3 * DAY,
+				end: T0 + 4 * DAY
+			}
+		}),
+		adapter: reads(0, 0, 3, 5),
+		engine: {
+			calls: 3,
+			rows: 3
+		},
+		check: (failures) => {
+			expect(failures).toMatchObject({ failedUpdates: 2 });
+			expect(failures.breakdown).toEqual([{
+				stage: "download",
+				reason: "http",
+				events: 2,
+				details: [expect.anything()]
+			}]);
+		}
+	}),
+	budget({
+		api: "update failures of a channel over a window: buckets × shards, all used",
+		read: ({ insights }) => insights.getUpdateFailures({
+			platform: "ios",
+			channel: "production",
+			timeRange: {
+				start: T0 + 3 * DAY,
+				end: T0 + 4 * DAY
+			}
+		}),
+		adapter: reads(0, 0, 5, 6),
+		engine: {
+			calls: 5,
+			rows: 4
+		},
+		check: (failures) => expect(failures).toMatchObject({
+			failedUpdates: 2,
+			checks: { failures: 1 }
+		})
+	}),
+	budget({
+		api: "update failures of a release since its first: two kept rows × shards, all used",
+		read: ({ insights }) => insights.getUpdateFailures({
+			platform: "ios",
+			channel: "production",
+			releaseId: "release-b"
+		}),
+		adapter: reads(0, 0, 2, 10),
+		engine: {
+			calls: 2,
+			rows: 2
+		},
+		check: (failures) => expect(failures).toMatchObject({
+			failedUpdates: 2,
+			failedInstallations: 2
+		})
+	}),
 	budget({
 		api: "catalog compile: the scope's enabled releases, all used",
 		read: ({ core }) => core.deploy([{
@@ -3262,7 +2775,7 @@ const READ_BUDGETS = [
 			install_id: "install-2",
 			received_at_ms: T0 + 3 * HOUR
 		})),
-		adapter: reads(5, 21, 0, 0),
+		adapter: reads(4, 7, 0, 0),
 		engine: {
 			calls: 2,
 			rows: 1
@@ -3285,7 +2798,7 @@ const setupReadBudgetTestSuite = (options) => {
 		let writes = 0;
 		beforeAll(async () => {
 			created = await options.createAdapter({
-				tables: options.server.builtInSchema.tables,
+				tables: options.server.toolingTargetOf(options.server.plugins).schema.tables,
 				nativePageSize: NATIVE_PAGE_SIZE
 			});
 			const { adapter } = created;
@@ -3328,6 +2841,266 @@ const setupReadBudgetTestSuite = (options) => {
 	});
 };
 //#endregion
+//#region src/runContentionHarness.ts
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/** Delays every adapter call by `ms`, like a round trip to a remote database. */
+const withAdapterLatency = (adapter, ms) => ({
+	...adapter,
+	get: async (table, keys) => {
+		await sleep(ms);
+		return adapter.get(table, keys);
+	},
+	query: async (table, request) => {
+		await sleep(ms);
+		return adapter.query(table, request);
+	},
+	write: async (ops) => {
+		await sleep(ms);
+		return adapter.write(ops);
+	}
+});
+/**
+* Starts `transactions` runs at a steady arrival rate through a fixed pool and
+* reports how they ended. Retry counts come from the engine's `onRetry`.
+*/
+const runContentionHarness = async (options) => {
+	const started = Date.now();
+	const errors = {};
+	const waiting = [];
+	let free = options.concurrency;
+	let committed = 0;
+	const acquire = () => free > 0 ? (free -= 1, Promise.resolve()) : new Promise((resolve) => waiting.push(resolve));
+	const release = () => {
+		const next = waiting.shift();
+		if (next) next();
+		else free += 1;
+	};
+	await Promise.all(Array.from({ length: options.transactions }, async (_, index) => {
+		await sleep(index * 1e3 / options.ratePerSecond);
+		await acquire();
+		try {
+			await options.run(index);
+			committed += 1;
+		} catch (error) {
+			const name = error instanceof Error ? error.name : "unknown";
+			errors[name] = (errors[name] ?? 0) + 1;
+		} finally {
+			release();
+		}
+	}));
+	return {
+		transactions: options.transactions,
+		committed,
+		errors,
+		durationMs: Date.now() - started
+	};
+};
+//#endregion
+//#region src/setupAggregateBatchingTestSuite.ts
+const identity = (name) => ({ [name]: {
+	type: "string",
+	maxLength: 16
+} });
+/** A module shaped like `defineTable` and `defineAggregate` build them. */
+const module = {
+	id: "batching",
+	schema: {
+		installs: {
+			kind: "table",
+			fields: {
+				id: {
+					type: "string",
+					maxLength: 64
+				},
+				release: {
+					type: "string",
+					maxLength: 16
+				}
+			},
+			key: ["id"],
+			derived: {},
+			indexes: {}
+		},
+		distribution: {
+			kind: "aggregate",
+			fields: identity("release"),
+			key: ["release"],
+			counters: [],
+			gauges: ["installations"],
+			distinct: [],
+			shards: 8,
+			batched: true,
+			indexes: { byRelease: {
+				eq: ["release"],
+				sort: []
+			} }
+		},
+		opens: {
+			kind: "aggregate",
+			fields: { day: { type: "integer" } },
+			key: ["day"],
+			counters: ["opens"],
+			gauges: [],
+			distinct: [],
+			shards: 4,
+			batched: true,
+			indexes: { all: {
+				eq: [],
+				sort: ["day"]
+			} }
+		},
+		users: {
+			kind: "aggregate",
+			fields: { day: { type: "integer" } },
+			key: ["day"],
+			counters: [],
+			gauges: [],
+			distinct: ["users"],
+			shards: 4,
+			batched: true,
+			indexes: { all: {
+				eq: [],
+				sort: ["day"]
+			} }
+		}
+	}
+};
+const RELEASES = [
+	"A",
+	"B",
+	"C"
+];
+/** Step `step`: 12 installations, each moving to the next release every round of 12. */
+const stepOf = (step) => ({
+	id: `i${step % 12}`,
+	release: RELEASES[(Math.floor(step / 12) + step) % 3],
+	day: 1 + step % 2
+});
+/** An installation opens the app on `release`, moving its gauge when the release changed. */
+const open = (db, step) => {
+	const { id, release, day } = stepOf(step);
+	return db.transaction(async (tx) => {
+		const head = await tx.findOne("installs", { id });
+		if (head === null) tx.create("installs", {
+			id,
+			release
+		});
+		else if (head.release !== release) {
+			tx.update("installs", head, { release });
+			const from = { release: head.release };
+			tx.aggregate("distribution", from, { installations: -1 }, { shardBy: id });
+		}
+		if (head?.release !== release) tx.aggregate("distribution", { release }, { installations: 1 }, { shardBy: id });
+		tx.aggregate("opens", { day }, { opens: 1 }, { shardBy: id });
+		const users = addDistinct(null, id);
+		tx.aggregate("users", { day }, { users }, { shardBy: id });
+	});
+};
+/** Every aggregate as reads see it, sketches as their estimates. */
+const snapshot = async (db) => {
+	const read = (model, index, where = {}) => db.findAggregates(model, {
+		index,
+		where,
+		limit: 100
+	});
+	const releases = await Promise.all(RELEASES.map((release) => read("distribution", "byRelease", { release })));
+	const [opens, users] = await Promise.all([read("opens", "all"), read("users", "all")]);
+	return {
+		distribution: releases.flatMap(({ rows }) => rows),
+		opens: opens.rows,
+		users: users.rows.map((row) => ({
+			day: row.day,
+			users: countDistinct(row.users)
+		}))
+	};
+};
+/**
+* Aggregates declared `batched` on a key-value store: log rows the store
+* writes with each transaction and a compaction merges once, and a memory
+* buffer, read back exactly as transactional writes read.
+*/
+const setupAggregateBatchingTestSuite = ({ name, engine, createAdapter, oversizedRows }) => {
+	const schema = engine.resolveSchema([module, engine.aggregateBatchingModule]);
+	const cleanups = [];
+	const store = async () => {
+		const { adapter, cleanup } = await createAdapter();
+		if (cleanup) cleanups.push(cleanup);
+		await adapter.migrations?.apply(schema.tables);
+		return adapter;
+	};
+	const server = (adapter, batching) => {
+		const created = engine.createDatabaseEngine({
+			adapter,
+			schema,
+			...batching === void 0 ? {} : { batching },
+			retry: { attempts: 64 }
+		});
+		return {
+			db: created.database(module),
+			flush: created.flush
+		};
+	};
+	/** The reference: transactional writes on a memory adapter. */
+	const expected = async (steps) => {
+		const memory = createMemoryAdapter();
+		await memory.migrations?.apply(schema.tables);
+		const { db } = server(memory);
+		for (let step = 0; step < steps; step += 1) await open(db, step);
+		return snapshot(db);
+	};
+	describe(`${name} aggregate batching`, () => {
+		afterEach(async () => {
+			for (const cleanup of cleanups.splice(0)) await cleanup();
+		});
+		for (const mode of ["log", "memory"]) it(`reads what transactional writes read, in ${mode} mode`, async () => {
+			const { db } = server(await store(), { mode });
+			for (let step = 0; step < 36; step += 1) await open(db, step);
+			expect(await snapshot(db)).toEqual(await expected(36));
+		}, 12e4);
+		it("applies each log row once when two servers compact while 16 writers commit", async () => {
+			const adapter = await store();
+			const first = server(adapter, {
+				mode: "log",
+				windowMs: 0
+			});
+			const second = server(adapter, {
+				mode: "log",
+				windowMs: 0
+			});
+			const report = await runContentionHarness({
+				transactions: 12,
+				ratePerSecond: 1e3,
+				concurrency: 16,
+				run: async (install) => {
+					for (let round = 0; round < 4; round += 1) {
+						const db = (install + round) % 2 === 0 ? first.db : second.db;
+						await open(db, round * 12 + install);
+					}
+				}
+			});
+			expect(report.errors).toEqual({});
+			await Promise.all([first.flush(), second.flush()]);
+			await first.flush();
+			expect(await snapshot(second.db)).toEqual(await expected(48));
+		}, 3e5);
+		it("applies a log row larger than one write in parts, each change once", async () => {
+			const { db, flush } = server(await store(), { mode: "log" });
+			await db.transaction(async (tx) => {
+				for (let day = 1; day <= oversizedRows; day += 1) tx.aggregate("opens", { day }, { opens: day }, { shardBy: "i" });
+			});
+			await flush();
+			const { rows } = await db.findAggregates("opens", {
+				index: "all",
+				where: {},
+				limit: 500
+			});
+			const days = Math.min(oversizedRows, 500);
+			expect(rows).toHaveLength(days);
+			expect(rows.every((row) => row.opens === row.day)).toBe(true);
+		}, 3e5);
+	});
+};
+//#endregion
 //#region src/sqlRowsExamined.ts
 /** Wraps executors so each read they run while counting is examined first. */
 const examineReads = (hooks) => {
@@ -3449,63 +3222,7 @@ const mysqlRowsExamined = (query) => {
 	});
 };
 //#endregion
-//#region src/runContentionHarness.ts
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-/** Delays every adapter call by `ms`, like a round trip to a remote database. */
-const withAdapterLatency = (adapter, ms) => ({
-	...adapter,
-	get: async (table, keys) => {
-		await sleep(ms);
-		return adapter.get(table, keys);
-	},
-	query: async (table, request) => {
-		await sleep(ms);
-		return adapter.query(table, request);
-	},
-	write: async (ops) => {
-		await sleep(ms);
-		return adapter.write(ops);
-	}
-});
-/**
-* Starts `transactions` runs at a steady arrival rate through a fixed pool and
-* reports how they ended. Retry counts come from the engine's `onRetry`.
-*/
-const runContentionHarness = async (options) => {
-	const started = Date.now();
-	const errors = {};
-	const waiting = [];
-	let free = options.concurrency;
-	let committed = 0;
-	const acquire = () => free > 0 ? (free -= 1, Promise.resolve()) : new Promise((resolve) => waiting.push(resolve));
-	const release = () => {
-		const next = waiting.shift();
-		if (next) next();
-		else free += 1;
-	};
-	await Promise.all(Array.from({ length: options.transactions }, async (_, index) => {
-		await sleep(index * 1e3 / options.ratePerSecond);
-		await acquire();
-		try {
-			await options.run(index);
-			committed += 1;
-		} catch (error) {
-			const name = error instanceof Error ? error.name : "unknown";
-			errors[name] = (errors[name] ?? 0) + 1;
-		} finally {
-			release();
-		}
-	}));
-	return {
-		transactions: options.transactions,
-		committed,
-		errors,
-		durationMs: Date.now() - started
-	};
-};
-//#endregion
 //#region src/createPluginTestHarness.ts
-const builtInPlugin = Symbol.for("@hot-updater/server/built-in-plugin");
 /**
 * Runs one plugin the way `createHotUpdater` does, on a memory adapter in
 * verify mode, so tests can call its API and measure what each call reads.
@@ -3515,7 +3232,7 @@ const createPluginTestHarness = async (plugin, options) => {
 	const module = {
 		id: plugin.id,
 		schema: plugin.schema,
-		...builtInPlugin in plugin ? {} : { namespace: plugin.id }
+		...plugin.namespace === false ? {} : { namespace: plugin.id }
 	};
 	const schema = options.engine.resolveSchema([module]);
 	await adapter.migrations?.apply(schema.tables);
@@ -3615,4 +3332,4 @@ async function startHttpTestServer(handlers) {
 	};
 }
 //#endregion
-export { RELEASE_CATALOG_DOWNLOAD_HASH, RELEASE_CATALOG_MANIFEST_URIS, RELEASE_CATALOG_STORAGE_FIXTURES, conformanceCounters, conformanceItems, createAdminApiTestClient, createHandlerHttpTestClient, createHttpTestClient, createPluginTestHarness, createReleaseCatalogTestStorage, jsonRequest, mysqlRowsExamined, postgresRowsExamined, releaseCatalogArtifact, releaseCatalogDownloadUrl, runContentionHarness, setupBundleMethodsTestSuite, setupCoreAdminTestSuite, setupDatabaseAdapterConformanceSuite, setupDatabaseTestSuite, setupInsightsHttpTestSuite, setupInsightsModelTestSuite, setupReadBudgetTestSuite, setupReleaseCatalogTestSuite, setupSemverSatisfiesTestSuite, startHttpTestServer, toDeployBundle, withAdapterLatency };
+export { RELEASE_CATALOG_DOWNLOAD_HASH, RELEASE_CATALOG_MANIFEST_URIS, RELEASE_CATALOG_STORAGE_FIXTURES, conformanceCounters, conformanceExpiring, conformanceItems, createAdminApiTestClient, createHandlerHttpTestClient, createHttpTestClient, createPluginTestHarness, createReleaseCatalogTestStorage, jsonRequest, mysqlRowsExamined, postgresRowsExamined, releaseCatalogArtifact, releaseCatalogDownloadUrl, runContentionHarness, setupAggregateBatchingTestSuite, setupBundleMethodsTestSuite, setupCoreAdminTestSuite, setupDatabaseAdapterConformanceSuite, setupDatabaseTestSuite, setupReadBudgetTestSuite, setupReleaseCatalogTestSuite, setupSemverSatisfiesTestSuite, startHttpTestServer, toDeployBundle, withAdapterLatency };