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

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, addDistinct, countDistinct, createMemoryAdapter, findPhysicalIndex, indexOrderTuple, verifyAdapter } from "@hot-updater/plugin-core/internal";
+import { NIL_UUID, createReleaseCatalogScopeKey, encodeChannelKey, selectDesiredRelease } from "@hot-updater/protocol";
+import { DATABASE_VERSION_COLUMN, DatabaseAdapterContractError, SETTINGS_TABLE, addDistinct, aggregateBatchingTables, assertStorageOperations, bundleToPatchRows, bundleToRow, compareUtf8, coreSchema, countDistinct, createBundleStorageKey, createEngine, createMemoryAdapter, createStorageKeyBuilder, createStorageRootUriWithPath, createStorageUri, createStorageUriWithRelativePath, findPhysicalIndex, getBundleArchiveStorageUri, getContentAddressedAssetStoragePath, indexOrderColumns, meterReads, parseStorageDownloadPath, parseStorageUri, targetBaseCandidateKey, toolingTargetOf, verifyAdapter } from "@hot-updater/plugin-core";
 import { createServer } from "node:http";
 //#region src/adminApiTestClient.ts
 const jsonRequest = (method, body) => ({
@@ -80,9 +80,18 @@ const createAdminApiTestClient = (getClient) => {
 };
 //#endregion
 //#region src/databaseTestFixtures.ts
-const fixtureId = (suffix) => `00000000-0000-7000-8000-${suffix.padStart(12, "0")}`;
+const fixtureId$1 = (suffix) => `00000000-0000-7000-8000-${suffix.padStart(12, "0")}`;
+const channelFixtureSuffix = (name) => {
+	let hash = 0;
+	for (const character of name) hash = (hash * 31 + character.codePointAt(0)) % 0xe8d4a51000;
+	return String(hash);
+};
+const createChannelRowFixture = (name = "production") => ({
+	id: fixtureId$1(channelFixtureSuffix(name)),
+	name
+});
 const createBundleRowFixture = (suffix, _channel = "production") => ({
-	id: fixtureId(suffix),
+	id: fixtureId$1(suffix),
 	platform: "ios",
 	git_commit_hash: null,
 	metadata: { app_version: suffix },
@@ -100,8 +109,29 @@ const createBundlePatchRowFixture = (suffix, bundleId, baseBundleId, orderIndex
 	byte_size: 3000000002,
 	order_index: orderIndex
 });
+const createReleaseRowFixture = (suffix, bundle, channel) => ({
+	id: fixtureId$1(`${Number(suffix) + 5e3}`),
+	scope_key: `v1:app-version:ios:${channel.name}`,
+	channel_id: channel.id,
+	platform: bundle.platform,
+	kind: "BUNDLE",
+	bundle_id: bundle.id,
+	strategy: "APP_VERSION",
+	target_app_version: "1.0.0",
+	fingerprint_hash: null,
+	enabled: true,
+	should_force_update: false,
+	message: `release-${suffix}`,
+	rollout_cohort_count: 1e3,
+	target_cohorts: [],
+	operation: "DEPLOY",
+	source_release_id: null,
+	revision: 1,
+	created_at_ms: Number(suffix),
+	updated_at_ms: Number(suffix)
+});
 const createBundleFixture = (suffix, _channel = "production") => ({
-	id: fixtureId(suffix),
+	id: fixtureId$1(suffix),
 	platform: "ios",
 	gitCommitHash: null,
 	metadata: { app_version: suffix },
@@ -941,18 +971,32 @@ const setupReleaseCatalogTestSuite = (options) => {
 				});
 				expect((await adminJson(catalogRowPath())).data).toMatchObject({ generation: catalog.generation + 1 });
 			});
-			it("hard deletes a Release, rebuilds its Catalog, and retains Bundle bytes", async () => {
+			const hardDelete = async (release) => {
+				await adminJson(`/releases/${release.id}?confirm=${release.id}&expectedRevision=${release.revision}`, jsonRequest("DELETE"));
+				api.forget(release.id);
+			};
+			it("hard deletes a Release, rebuilds its Catalog, and deletes the artifact no other Release uses", async () => {
 				const current = await publish("741", { enabled: false });
-				await adminJson(`/releases/${current.release.id}?confirm=${current.release.id}&expectedRevision=1`, jsonRequest("DELETE"));
-				api.forget(current.release.id);
+				await hardDelete(current.release);
 				expect((await admin(`/releases/${current.release.id}`)).status).toBe(404);
 				expect(await readCatalog()).toMatchObject({
 					releases: [],
 					rollbackReleases: []
 				});
-				const artifact = await request(`/artifacts/v1/${current.bundle.id}/from/${NIL_UUID$1}`);
+				expect((await request(`/artifacts/v1/${current.bundle.id}/from/${NIL_UUID$1}`)).status).toBe(404);
+			});
+			it("keeps serving an artifact while another Release uses it", async () => {
+				const first = await publish("742", { enabled: false });
+				const second = await publish("742", {
+					bundle_id: first.bundle.id,
+					enabled: false
+				}, scope("other"));
+				await hardDelete(first.release);
+				const artifact = await request(`/artifacts/v1/${first.bundle.id}/from/${NIL_UUID$1}`);
 				expect(artifact.status).toBe(200);
-				expect(await artifact.json()).toMatchObject({ manifestUrl: releaseCatalogDownloadUrl(current.bundle.manifest_storage_uri) });
+				expect(await artifact.json()).toMatchObject({ manifestUrl: releaseCatalogDownloadUrl(first.bundle.manifest_storage_uri) });
+				await hardDelete(second.release);
+				expect((await request(`/artifacts/v1/${first.bundle.id}/from/${NIL_UUID$1}`)).status).toBe(404);
 			});
 			it("serves enabled Releases newest first and resolves artifacts by Bundle identity", async () => {
 				const first = await publish("101");
@@ -1915,7 +1959,7 @@ const setupDatabaseAdapterConformanceSuite = (options) => {
 				for (;;) {
 					const last = read.at(-1);
 					const bound = last === void 0 ? {} : { [order === "asc" ? "lower" : "upper"]: {
-						values: indexOrderTuple(conformanceItems, findPhysicalIndex(conformanceItems, "byGroup"), last),
+						values: indexOrderColumns(conformanceItems, findPhysicalIndex(conformanceItems, "byGroup")).map((column) => last[column]),
 						inclusive: false
 					} };
 					const page = await query(adapter, {
@@ -2183,6 +2227,575 @@ const setupDatabaseAdapterConformanceSuite = (options) => {
 	});
 };
 //#endregion
+//#region src/storageAdapterTestCases.ts
+const BUNDLE_ID = "0199a0c3-6f6e-7c3a-9a3e-1b2c3d4e5f60";
+/** `sha256/9f/<hash>.png`: where deploy keeps a shared asset below `assets/`. */
+const ASSET_PATH = getContentAddressedAssetStoragePath({
+	assetPath: "assets/logo.png",
+	fileHash: "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"
+});
+const MANIFEST_KEY = createBundleStorageKey(BUNDLE_ID, "manifest.json");
+const ARCHIVE_KEY = createBundleStorageKey(BUNDLE_ID, "bundle.tar.br");
+const ASSET_KEY = `assets/${ASSET_PATH}`;
+const UNICODE_FOLDER = "unicode/한글 폴더";
+const UNICODE_KEY = `${UNICODE_FOLDER}/ünïcödé 😀.txt`;
+/** Keys whose URIs encode spaces, `#`, `%`, `@`, `+`, and Unicode. */
+const SPECIAL_KEYS = [
+	"with space/file name.txt",
+	"hash#1/100%.txt",
+	"symbols/logo@2x+dark.png",
+	UNICODE_KEY
+];
+/** How far a listed modification time may be from its put. */
+const CLOCK_SKEW_MS = 9e5;
+const encode = (text) => new TextEncoder().encode(text);
+const messageOf = (error) => error instanceof Error ? error.message : String(error);
+/** Deterministic bytes, so a reordered or dropped chunk shows up. */
+const patternBytes = (length, seed) => {
+	const bytes = new Uint8Array(length);
+	let state = seed;
+	for (let index = 0; index < length; index += 1) {
+		state ^= state << 13;
+		state ^= state >>> 17;
+		state ^= state << 5;
+		bytes[index] = state;
+	}
+	return bytes;
+};
+/**
+* A one-shot body that hands out a chunk only when its reader asks for one,
+* so `read()` tells whether the adapter read all of it.
+*/
+const bodyOf = (bytes, chunkSize = 16384) => {
+	let offset = 0;
+	return {
+		stream: new ReadableStream({ pull(controller) {
+			if (offset >= bytes.byteLength) {
+				controller.close();
+				return;
+			}
+			const end = Math.min(offset + chunkSize, bytes.byteLength);
+			controller.enqueue(bytes.slice(offset, end));
+			offset = end;
+		} }, { highWaterMark: 0 }),
+		read: () => offset === bytes.byteLength
+	};
+};
+/** A body that fails after its first chunk, like a file removed mid-upload. */
+const failingBody = (chunk) => {
+	let sent = false;
+	return new ReadableStream({ pull(controller) {
+		if (sent) {
+			controller.error(/* @__PURE__ */ new Error("The upload source failed."));
+			return;
+		}
+		sent = true;
+		controller.enqueue(chunk);
+	} }, { highWaterMark: 0 });
+};
+/** The bucket and base path of a URI `put` returned for `key`. */
+const locate = (storage, storageUri, key, basePath) => {
+	let parsed;
+	try {
+		parsed = parseStorageUri(storageUri, storage.protocol);
+	} catch (error) {
+		throw new Error(`put("${key}") returned "${storageUri}", which is not a canonical ${storage.protocol} storage URI: ${messageOf(error)}`);
+	}
+	if (basePath !== void 0) {
+		const expected = createStorageKeyBuilder(basePath)(key);
+		expect(parsed.key, `put("${key}") returned "${storageUri}"; below base path "${basePath}" its key is "${expected}"`).toBe(expected);
+	}
+	if (parsed.key === key) return {
+		bucket: parsed.bucket,
+		prefix: ""
+	};
+	if (parsed.key.endsWith(`/${key}`)) return {
+		bucket: parsed.bucket,
+		prefix: parsed.key.slice(0, -key.length - 1)
+	};
+	throw new Error(`put("${key}") returned "${storageUri}", whose key does not end with "${key}". Deploy derives the URIs of other objects from it.`);
+};
+/**
+* Puts objects the way deploy does and checks each URI `put` returns: a
+* canonical URI of the key, in the same bucket and below the same base path
+* as every other object.
+*/
+const objectsOf = (storage, basePath) => {
+	let root;
+	return {
+		async put(key, bytes, { knownLength = true, chunkSize } = {}) {
+			const body = bodyOf(bytes, chunkSize);
+			const { storageUri } = await storage.put({
+				key,
+				body: body.stream,
+				...knownLength ? { contentLength: bytes.byteLength } : {},
+				contentType: "application/octet-stream"
+			});
+			expect(body.read(), `put("${key}") resolved before it read the whole body`).toBe(true);
+			const location = locate(storage, storageUri, key, basePath);
+			root ??= location;
+			expect(location, `put("${key}") returned "${storageUri}", outside the bucket or base path of the objects before it`).toEqual(root);
+			return storageUri;
+		},
+		/** The URI `put` returns for `key`, which the case has not put. */
+		uriOf(key) {
+			if (root === void 0) throw new Error("Put an object before deriving another one's URI.");
+			return createStorageUri({
+				protocol: storage.protocol,
+				bucket: root.bucket,
+				key: createStorageKeyBuilder(root.prefix)(key)
+			});
+		}
+	};
+};
+/** The object's bytes through `get`, or null when `get` finds none. */
+const readObject = async (storage, storageUri) => {
+	const { response } = await storage.get({ storageUri });
+	if (response === null) return null;
+	expect(response, `get("${storageUri}") returned no Web Response`).toBeInstanceOf(Response);
+	let bytes;
+	try {
+		bytes = new Uint8Array(await response.arrayBuffer());
+	} catch (error) {
+		throw new Error(`get("${storageUri}") returned a response whose body could not be read: ${messageOf(error)}`, { cause: error });
+	}
+	const contentLength = response.headers.get("content-length");
+	if (contentLength !== null) expect(Number(contentLength), `get("${storageUri}") sent a content-length other than the object's size`).toBe(bytes.byteLength);
+	return bytes;
+};
+const expectBytes = (actual, expected, label) => {
+	expect(actual, `${label} found no object`).not.toBeNull();
+	expect(actual.byteLength, `${label} returned a body of the wrong size`).toBe(expected.byteLength);
+	expect(actual.findIndex((byte, index) => byte !== expected[index]), `${label} returned other bytes; first difference at index`).toBe(-1);
+};
+const expectObject = async (storage, storageUri, bytes) => {
+	expectBytes(await readObject(storage, storageUri), bytes, `get("${storageUri}")`);
+	if (storage.exists) expect(await storage.exists({ storageUri }), `exists("${storageUri}")`).toEqual({ exists: true });
+};
+const expectMissing = async (storage, storageUri) => {
+	expect((await storage.get({ storageUri })).response, `get("${storageUri}") of a missing object`).toBeNull();
+	if (storage.exists) expect((await storage.exists({ storageUri })).exists, `exists("${storageUri}") of a missing object`).toBe(false);
+};
+/** Expects a rejected promise: not a result, and not a synchronous throw. */
+const expectRejection = async (label, operation) => {
+	let pending;
+	try {
+		pending = operation();
+	} catch (error) {
+		throw new Error(`${label} threw instead of returning a rejected promise: ${messageOf(error)}`);
+	}
+	const outcome = await Promise.resolve(pending).then(() => "resolved", () => "rejected");
+	expect(outcome, label).toBe("rejected");
+};
+/** Every operation the adapter has that takes a storage URI rejects it. */
+const expectRejectedUri = async (storage, storageUri, owner) => {
+	const calls = {
+		get: storage.get && (() => storage.get({ storageUri })),
+		exists: storage.exists && (() => storage.exists({ storageUri })),
+		delete: storage.delete && (() => storage.delete({ storageUri })),
+		getDownloadUrl: storage.getDownloadUrl && (() => storage.getDownloadUrl({ storageUri }))
+	};
+	for (const [operation, call] of Object.entries(calls)) {
+		if (call === void 0) continue;
+		await expectRejection(`${operation}("${storageUri}") of ${owner}`, call);
+	}
+};
+const byKey = (left, right) => left.key < right.key ? -1 : left.key > right.key ? 1 : 0;
+const expectListing = (label, listed, expected, putWindow) => {
+	expect(listed.map(({ key, storageUri, size }) => ({
+		key,
+		storageUri,
+		size
+	})).sort(byKey), label).toEqual([...expected].sort(byKey));
+	for (const { key, lastModifiedAt } of listed) {
+		if (lastModifiedAt === void 0) continue;
+		expect(lastModifiedAt, `${label}: lastModifiedAt of "${key}"`).toBeInstanceOf(Date);
+		const time = lastModifiedAt.getTime();
+		expect(time >= putWindow.from - CLOCK_SKEW_MS && time <= putWindow.to + CLOCK_SKEW_MS, `${label}: "${key}" has lastModifiedAt ${String(lastModifiedAt)}, not the time it was put`).toBe(true);
+	}
+};
+const OPERATIONS = [
+	"put",
+	"get",
+	"getDownloadUrl",
+	"exists",
+	"delete",
+	"listObjects",
+	"deleteObjects"
+];
+const describeArgument = (value) => {
+	if (Array.isArray(value)) return `[${value.map((item) => JSON.stringify(item)).join(", ")}]`;
+	if (typeof value === "object" && value !== null) {
+		const { key, storageUri } = value;
+		return JSON.stringify(storageUri ?? key);
+	}
+	return value === void 0 ? "" : JSON.stringify(value);
+};
+/**
+* The adapter with each rejection naming its call, such as
+* `delete("s3://bucket/key") rejected: ...`. A synchronous throw stays one.
+*/
+const namingCalls = (storage) => {
+	const named = {
+		name: storage.name,
+		protocol: storage.protocol
+	};
+	for (const operation of OPERATIONS) {
+		const call = storage[operation];
+		if (typeof call !== "function") continue;
+		named[operation] = (...args) => Promise.resolve(call.apply(storage, args)).catch((error) => {
+			throw new Error(`${operation}(${args.map(describeArgument).join(", ")}) rejected: ${messageOf(error)}`, { cause: error });
+		});
+	}
+	return named;
+};
+const storageCase = (title, operations, run) => ({
+	title,
+	operations,
+	run: async ({ storage, ...context }) => {
+		assertStorageOperations(storage, [
+			"put",
+			"get",
+			...operations
+		]);
+		await run({
+			...context,
+			storage: namingCalls(storage)
+		});
+	}
+});
+/**
+* The storage adapter contract, from what its consumers rely on: deploy and
+* patch (`put`, `get`, `exists`, `delete`), the Console, the server's update
+* responses and signed downloads (`get`, `getDownloadUrl`), and
+* `storage prune` (`listObjects`, `deleteObjects`).
+*/
+const storageAdapterTestCases = [
+	storageCase("names the adapter and its URI protocol", [], async ({ storage }) => {
+		expect(typeof storage.name, "name").toBe("string");
+		expect(storage.name.length, "name length").toBeGreaterThan(0);
+		expect(storage.protocol, "protocol").toMatch(/^[a-z][a-z\d+.-]*$/);
+	}),
+	storageCase("stores a streamed body and reads it back", [], async ({ storage, basePath }) => {
+		const objects = objectsOf(storage, basePath);
+		const bytes = patternBytes(100003, 1);
+		const storageUri = await objects.put("round-trip/known-length.bin", bytes, { chunkSize: 4096 });
+		expectBytes(await readObject(storage, storageUri), bytes, `get("${storageUri}")`);
+		expectBytes(await readObject(storage, storageUri), bytes, `a second get("${storageUri}")`);
+	}),
+	storageCase("stores a streamed body of unknown length", [], async ({ storage, basePath }) => {
+		const objects = objectsOf(storage, basePath);
+		const bytes = patternBytes(20011, 2);
+		const storageUri = await objects.put("round-trip/unknown-length.bin", bytes, {
+			chunkSize: 1e3,
+			knownLength: false
+		});
+		expectBytes(await readObject(storage, storageUri), bytes, `get("${storageUri}")`);
+	}),
+	storageCase("stores an empty object", [], async ({ storage, basePath }) => {
+		const storageUri = await objectsOf(storage, basePath).put("round-trip/empty.txt", /* @__PURE__ */ new Uint8Array());
+		expectBytes(await readObject(storage, storageUri), /* @__PURE__ */ new Uint8Array(), `get("${storageUri}")`);
+	}),
+	storageCase("keeps concurrent puts of different keys apart", [], async ({ storage, basePath }) => {
+		const objects = objectsOf(storage, basePath);
+		const entries = Array.from({ length: 8 }, (_, index) => ({
+			key: `concurrent/${index}.bin`,
+			bytes: patternBytes(4e3 + index, 10 + index)
+		}));
+		const storageUris = await Promise.all(entries.map(({ key, bytes }) => objects.put(key, bytes, { chunkSize: 512 })));
+		for (const [index, { bytes }] of entries.entries()) expectBytes(await readObject(storage, storageUris[index]), bytes, `get("${storageUris[index]}")`);
+	}),
+	storageCase("returns the canonical URI of each key below the base path", [], async ({ storage, basePath }) => {
+		const objects = objectsOf(storage, basePath);
+		for (const key of [
+			MANIFEST_KEY,
+			ASSET_KEY,
+			"nested/one/two/three/deep.txt",
+			...SPECIAL_KEYS
+		]) {
+			const bytes = encode(`object at ${key}`);
+			const storageUri = await objects.put(key, bytes);
+			expectBytes(await readObject(storage, storageUri), bytes, `get("${storageUri}")`);
+		}
+	}),
+	storageCase("reads objects at the URIs deploy derives from a manifest's URI", [], async ({ storage, basePath }) => {
+		const objects = objectsOf(storage, basePath);
+		const archive = patternBytes(3001, 3);
+		const asset = patternBytes(1234, 4);
+		const manifestUri = await objects.put(MANIFEST_KEY, encode(JSON.stringify({
+			bundleId: BUNDLE_ID,
+			assets: {}
+		})));
+		const archiveUri = await objects.put(ARCHIVE_KEY, archive);
+		const assetUri = await objects.put(ASSET_KEY, asset);
+		const derivedArchiveUri = getBundleArchiveStorageUri({
+			manifestStorageUri: manifestUri,
+			bundleId: BUNDLE_ID
+		});
+		const derivedAssetUri = createStorageUriWithRelativePath({
+			baseStorageUri: createStorageRootUriWithPath(manifestUri, BUNDLE_ID, "assets"),
+			relativePath: ASSET_PATH
+		});
+		expect(derivedArchiveUri, "the archive URI derived from the manifest's").toBe(archiveUri);
+		expect(derivedAssetUri, "the asset URI derived from the manifest's").toBe(assetUri);
+		await expectObject(storage, derivedArchiveUri, archive);
+		await expectObject(storage, derivedAssetUri, asset);
+	}),
+	storageCase("replaces an object put again under the same key", [], async ({ storage, basePath }) => {
+		const objects = objectsOf(storage, basePath);
+		const key = "overwrite/object.txt";
+		const storageUri = await objects.put(key, encode("first"));
+		expect(await objects.put(key, encode("second")), "a second put").toBe(storageUri);
+		expectBytes(await readObject(storage, storageUri), encode("second"), `get("${storageUri}")`);
+		expect(await Promise.all([objects.put(key, encode("shared")), objects.put(key, encode("shared"))]), "concurrent puts of one key").toEqual([storageUri, storageUri]);
+		expectBytes(await readObject(storage, storageUri), encode("shared"), `get("${storageUri}")`);
+	}),
+	storageCase("rejects a put whose body fails and keeps no object", [], async ({ storage, basePath }) => {
+		const objects = objectsOf(storage, basePath);
+		await objects.put("failed-put/other.txt", encode("other"));
+		const key = "failed-put/object.bin";
+		await expectRejection(`put("${key}") of a body that fails`, () => storage.put({
+			key,
+			body: failingBody(patternBytes(4e3, 5)),
+			contentLength: 1e4,
+			contentType: "application/octet-stream"
+		}));
+		await expectMissing(storage, objects.uriOf(key));
+	}),
+	storageCase("returns a null response for a missing object", [], async ({ storage, basePath }) => {
+		const objects = objectsOf(storage, basePath);
+		await objects.put("missing/object.txt", encode("present"));
+		for (const key of [
+			"missing/absent.txt",
+			"missing/object.tx",
+			"missing/object.txt.bak",
+			"missing"
+		]) {
+			const storageUri = objects.uriOf(key);
+			expect(await storage.get({ storageUri }), `get("${storageUri}") of a missing object`).toEqual({ response: null });
+		}
+	}),
+	storageCase("tells whether an object exists", ["exists"], async ({ storage, basePath }) => {
+		const objects = objectsOf(storage, basePath);
+		const storageUri = await objects.put("exists/object.txt", encode("present"));
+		expect(await storage.exists({ storageUri }), `exists("${storageUri}")`).toEqual({ exists: true });
+		for (const key of [
+			"exists/absent.txt",
+			"exists/object.tx",
+			"exists"
+		]) {
+			const missingUri = objects.uriOf(key);
+			expect(await storage.exists({ storageUri: missingUri }), `exists("${missingUri}")`).toEqual({ exists: false });
+		}
+	}),
+	storageCase("deletes exactly one object, and deleting it again succeeds", ["delete"], async ({ storage, basePath }) => {
+		const objects = objectsOf(storage, basePath);
+		const storageUri = await objects.put("delete/object.txt", encode("gone"));
+		const sibling = encode("kept");
+		const siblingUri = await objects.put("delete/object.txt.bak", sibling);
+		const child = encode("kept child");
+		const childUri = await objects.put("delete/object/child.txt", child);
+		expect(await storage.delete({ storageUri }), `delete("${storageUri}")`).toEqual({ deleted: true });
+		await expectMissing(storage, storageUri);
+		expect(await storage.delete({ storageUri }), `a second delete("${storageUri}")`).toEqual({ deleted: true });
+		for (const key of ["delete/never-stored.txt", "delete/object"]) {
+			const missingUri = objects.uriOf(key);
+			expect(await storage.delete({ storageUri: missingUri }), `delete("${missingUri}")`).toEqual({ deleted: true });
+		}
+		await expectObject(storage, siblingUri, sibling);
+		await expectObject(storage, childUri, child);
+	}),
+	storageCase("rejects the URI of an object in another bucket", [], async ({ storage, basePath }) => {
+		const objects = objectsOf(storage, basePath);
+		const bytes = encode("kept");
+		const storageUri = await objects.put("foreign/object.txt", bytes);
+		const { bucket, key } = parseStorageUri(storageUri, storage.protocol);
+		await expectRejectedUri(storage, createStorageUri({
+			protocol: storage.protocol,
+			bucket: `${bucket}-other`,
+			key
+		}), "another bucket");
+		await expectObject(storage, storageUri, bytes);
+	}),
+	storageCase("rejects the URI of another protocol", [], async ({ storage, basePath }) => {
+		const objects = objectsOf(storage, basePath);
+		const bytes = encode("kept");
+		const storageUri = await objects.put("foreign/object.txt", bytes);
+		const { bucket, key } = parseStorageUri(storageUri, storage.protocol);
+		await expectRejectedUri(storage, createStorageUri({
+			protocol: `not-${storage.protocol}`,
+			bucket,
+			key
+		}), "another protocol");
+		await expectObject(storage, storageUri, bytes);
+	}),
+	storageCase("resolves a download URL for a stored object", ["getDownloadUrl"], async ({ storage, basePath, fetchDownloadUrls }) => {
+		const objects = objectsOf(storage, basePath);
+		for (const key of ["download/object.txt", ...SPECIAL_KEYS]) {
+			const bytes = encode(key);
+			const storageUri = await objects.put(key, bytes);
+			const { url } = await storage.getDownloadUrl({ storageUri });
+			const label = `getDownloadUrl("${storageUri}") returned "${url}"`;
+			expect(typeof url, label).toBe("string");
+			if (/^[a-z][a-z\d+.-]*:/i.test(url)) {
+				expect(["http:", "https:"], `${label}; a URL must use http(s)`).toContain(new URL(url).protocol);
+				if (fetchDownloadUrls) {
+					const response = await fetch(url);
+					expect(response.status, `${label}, which answered`).toBe(200);
+					expectBytes(new Uint8Array(await response.arrayBuffer()), bytes, `${label}, whose download`);
+				}
+				continue;
+			}
+			expect(parseStorageDownloadPath(url)?.storageUri, `${label}; a path must be the /storage/ path of the same URI`).toBe(storageUri);
+			expect((await storage.getDownloadUrl({ storageUri })).url, `${label}, then another path`).toBe(url);
+		}
+	}),
+	storageCase("lists every object with its key relative to the base path", ["listObjects"], async ({ storage, basePath }) => {
+		const objects = objectsOf(storage, basePath);
+		const entries = [
+			[MANIFEST_KEY, encode("{}")],
+			[ARCHIVE_KEY, patternBytes(3001, 6)],
+			[ASSET_KEY, patternBytes(1234, 7)],
+			["bundles-other/object.txt", encode("next to bundles/")],
+			...SPECIAL_KEYS.map((key) => [key, encode(key)])
+		];
+		const from = Date.now();
+		const stored = [];
+		for (const [key, bytes] of entries) stored.push({
+			key,
+			storageUri: await objects.put(key, bytes),
+			size: bytes.byteLength
+		});
+		const putWindow = {
+			from,
+			to: Date.now()
+		};
+		const below = (folder) => stored.filter(({ key }) => key.startsWith(`${folder}/`));
+		expectListing("listObjects()", await storage.listObjects(), stored, putWindow);
+		expectListing("listObjects(\"bundles\")", await storage.listObjects("bundles"), below("bundles"), putWindow);
+		expectListing(`listObjects("${UNICODE_FOLDER}")`, await storage.listObjects(UNICODE_FOLDER), below(UNICODE_FOLDER), putWindow);
+	}),
+	storageCase("deletes exactly the keys it receives", ["deleteObjects"], async ({ storage, basePath }) => {
+		const objects = objectsOf(storage, basePath);
+		const put = async (key) => {
+			const bytes = encode(key);
+			return {
+				key,
+				bytes,
+				storageUri: await objects.put(key, bytes)
+			};
+		};
+		const removed = [await put("delete-objects/object.txt"), await put(`delete-objects/${UNICODE_KEY}`)];
+		const kept = [await put("delete-objects/object.txt.bak"), await put("delete-objects/folder/child.txt")];
+		await storage.deleteObjects([]);
+		for (const object of [...removed, ...kept]) await expectObject(storage, object.storageUri, object.bytes);
+		await storage.deleteObjects([
+			...removed.map(({ key }) => key),
+			"delete-objects/never-stored.txt",
+			"delete-objects/folder"
+		]);
+		for (const object of removed) await expectMissing(storage, object.storageUri);
+		for (const object of kept) await expectObject(storage, object.storageUri, object.bytes);
+		if (storage.listObjects) expect((await storage.listObjects()).map(({ key }) => key).sort(), "listObjects() after deleteObjects").toEqual(kept.map(({ key }) => key).sort());
+	})
+];
+//#endregion
+//#region src/setupStorageAdapterTestSuite.ts
+/**
+* The storage adapter contract that deploy, patch, the Console, the server,
+* and `storage prune` rely on. Every official storage adapter runs it.
+*/
+const setupStorageAdapterTestSuite = (options) => {
+	const declared = options.operations;
+	const required = [.../* @__PURE__ */ new Set([
+		"put",
+		"get",
+		...declared ?? []
+	])];
+	describe(`${options.name} storage adapter`, () => {
+		it(`implements ${required.join(", ")}`, async () => {
+			const { storage, cleanup } = await options.createStorage();
+			try {
+				assertStorageOperations(storage, required);
+			} finally {
+				await cleanup?.();
+			}
+		});
+		for (const testCase of storageAdapterTestCases) {
+			const undeclared = declared === void 0 ? [] : testCase.operations.filter((operation) => !declared.includes(operation));
+			it.skipIf(undeclared.length > 0)(testCase.title, async (context) => {
+				const { storage, basePath, cleanup } = await options.createStorage();
+				try {
+					const missing = testCase.operations.filter((operation) => typeof storage[operation] !== "function");
+					if (declared === void 0 && missing.length > 0) context.skip(`${storage.name} lacks ${missing.join(", ")}`);
+					await testCase.run({
+						storage,
+						basePath,
+						fetchDownloadUrls: options.fetchDownloadUrls
+					});
+				} finally {
+					await cleanup?.();
+				}
+			});
+		}
+	});
+};
+//#endregion
+//#region src/createMeasuredDatabase.ts
+const storageOf = (storage) => ({
+	name: "measuredStorage",
+	protocol: "storage",
+	get: async ({ storageUri }) => {
+		const text = await storage.readStorageText?.(storageUri) ?? null;
+		return { response: text === null ? null : new Response(text) };
+	},
+	getDownloadUrl: async ({ storageUri }) => ({ url: await storage.resolveFileUrl(storageUri) })
+});
+/**
+* Core and the plugins over `adapter` as `createHotUpdater` runs them: what
+* read-budget suites measure. The database is `meterReads` over
+* `verifyAdapter(adapter)`, so every adapter call is checked against the
+* contract and `measureReads` reports each call's reads; the adapter runs
+* as given, without the schema fence. It loads `@hot-updater/server`, an
+* optional peer, when called.
+*/
+const createMeasuredDatabase = async (adapter, plugins, options = {}) => {
+	const { createHotUpdater } = await import("@hot-updater/server");
+	let clientAuth;
+	const observed = plugins.map((plugin) => Object.defineProperties({}, {
+		...Object.getOwnPropertyDescriptors(plugin),
+		init: {
+			configurable: true,
+			enumerable: true,
+			writable: true,
+			value: (context) => {
+				const instance = plugin.init(options.now === void 0 ? context : {
+					...context,
+					now: options.now
+				});
+				if (instance.clientAuth !== void 0) clientAuth = instance.clientAuth;
+				return instance;
+			}
+		}
+	}));
+	const database = meterReads({
+		name: "measured",
+		adapter: verifyAdapter(adapter)
+	});
+	const hotUpdater = createHotUpdater({
+		database,
+		storage: options.storage === void 0 ? [] : [storageOf(options.storage)],
+		plugins: observed,
+		...plugins.some((plugin) => plugin.provides?.clientAuth === true) ? {} : { clientAccess: "public" }
+	});
+	return {
+		core: hotUpdater.core,
+		api: hotUpdater.api,
+		...clientAuth === void 0 ? {} : { clientAuth },
+		measureReads: database.measureReads
+	};
+};
+//#endregion
 //#region src/setupReadBudgetTestSuite.ts
 const DAY = 864e5;
 const HOUR = 36e5;
@@ -2286,7 +2899,7 @@ const storage = {
 		bundleId: createBundleFixture("106").id,
 		assets: { "index.ios.bundle": { fileHash: "hbc-hash-106" } }
 	}) : null,
-	resolveFileUrl: async (storageUri) => storageUri === null ? null : `https://storage.example.com/${encodeURIComponent(storageUri)}`
+	resolveFileUrl: async (storageUri) => `https://storage.example.com/${encodeURIComponent(storageUri)}`
 };
 /**
 * Core's bundles, releases, channels, and a client API key, and 25 Insights
@@ -2294,8 +2907,8 @@ const storage = {
 * days later; and the day of history before T0, as a production database
 * holds, so a read that scans beyond its window examines more rows.
 */
-const seed = async (database, server) => {
-	const { core } = database;
+const seed = async (database) => {
+	const core = database.core;
 	const api = database.api;
 	for (const name of [
 		"staging",
@@ -2354,7 +2967,7 @@ const seed = async (database, server) => {
 		productionId,
 		nightlyId: (await channel("nightly")).id,
 		/** The auto-patch base key of a new production iOS 1.0.0 bundle. */
-		candidateKey: server.targetBaseCandidateKey({
+		candidateKey: targetBaseCandidateKey({
 			channel: "production",
 			platform: "ios",
 			fingerprintHash: null,
@@ -2784,11 +3397,12 @@ const READ_BUDGETS = [
 	})
 ];
 /**
-* The read-budget suite (PRD S4) on one backend: core and the built-in
-* plugins in verify mode over the backend's adapter, native pages capped at
-* two rows. Every API in the read-budget list reads exactly its budget at the
-* adapter and at the engine; with `examined`, the database examines no more
-* rows than the adapter read, within the backend's native multipliers.
+* The read-budget suite (PRD S4) on one backend: core and the server's
+* built-in plugins on `createMeasuredDatabase` over the backend's adapter,
+* native pages capped at two rows. Every API in the read-budget list reads
+* exactly its budget at the adapter and at the engine; with `examined`, the
+* database examines no more rows than the adapter read, within the backend's
+* native multipliers. It loads `@hot-updater/server`, an optional peer.
 */
 const setupReadBudgetTestSuite = (options) => {
 	describe(`${options.name} read budgets`, () => {
@@ -2797,22 +3411,24 @@ const setupReadBudgetTestSuite = (options) => {
 		let seeded;
 		let writes = 0;
 		beforeAll(async () => {
+			const [{ insights }, { apiKeys }] = await Promise.all([import("@hot-updater/server/plugins/insights"), import("@hot-updater/server/plugins/api-keys")]);
+			const plugins = [insights(), apiKeys()];
 			created = await options.createAdapter({
-				tables: options.server.toolingTargetOf(options.server.plugins).schema.tables,
+				tables: [...toolingTargetOf(plugins).schema.tables, SETTINGS_TABLE],
 				nativePageSize: NATIVE_PAGE_SIZE
 			});
 			const { adapter } = created;
-			database = options.server.createMeasuredDatabase({
+			database = await createMeasuredDatabase({
 				...adapter,
 				write: (ops) => {
 					writes += 1;
 					return adapter.write(ops);
 				}
-			}, options.server.plugins, {
+			}, plugins, {
 				now: () => T0 + 10 * DAY,
 				storage
 			});
-			seeded = await seed(database, options.server);
+			seeded = await seed(database);
 		}, 3e5);
 		afterAll(async () => {
 			await created?.cleanup?.();
@@ -2901,9 +3517,14 @@ const identity = (name) => ({ [name]: {
 	type: "string",
 	maxLength: 16
 } });
-/** A module shaped like `defineTable` and `defineAggregate` build them. */
-const module = {
+/**
+* A plugin's tables, shaped like `defineTable` and `defineAggregate` build
+* them, under their own names.
+*/
+const plugin = {
 	id: "batching",
+	schemaVersion: "1",
+	namespace: false,
 	schema: {
 		installs: {
 			kind: "table",
@@ -3019,31 +3640,32 @@ const snapshot = async (db) => {
 * 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 setupAggregateBatchingTestSuite = ({ name, createAdapter, oversizedRows }) => {
+	const tables = [...toolingTargetOf([plugin]).schema.tables, ...aggregateBatchingTables];
 	const cleanups = [];
 	const store = async () => {
 		const { adapter, cleanup } = await createAdapter();
 		if (cleanup) cleanups.push(cleanup);
-		await adapter.migrations?.apply(schema.tables);
+		await adapter.migrations?.apply(tables);
 		return adapter;
 	};
+	/** A server's engine on `adapter`, batching as `batching` says. */
 	const server = (adapter, batching) => {
-		const created = engine.createDatabaseEngine({
+		const engine = createEngine({
+			name,
 			adapter,
-			schema,
-			...batching === void 0 ? {} : { batching },
+			...batching === void 0 ? {} : { aggregateBatching: batching },
 			retry: { attempts: 64 }
-		});
+		}, { plugins: [plugin] });
 		return {
-			db: created.database(module),
-			flush: created.flush
+			db: engine.database(plugin),
+			flush: engine.flush
 		};
 	};
 	/** The reference: transactional writes on a memory adapter. */
 	const expected = async (steps) => {
 		const memory = createMemoryAdapter();
-		await memory.migrations?.apply(schema.tables);
+		await memory.migrations?.apply(tables);
 		const { db } = server(memory);
 		for (let step = 0; step < steps; step += 1) await open(db, step);
 		return snapshot(db);
@@ -3224,41 +3846,1056 @@ const mysqlRowsExamined = (query) => {
 //#endregion
 //#region src/createPluginTestHarness.ts
 /**
-* 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.
+* Runs one plugin on `createEngine`, the storage engine `createHotUpdater`
+* runs its plugins on, so tests can call its API and measure what each call
+* reads. Every adapter call is checked against the adapter contract
+* (`verifyAdapter`), and `ctx.core` is empty: core's reads need a server.
+* The engine gets the adapter without `prune`, as a store that expires rows
+* itself would give it, so no retention pass adds to what a call reads and
+* writes; rows stay past their retention.
 */
-const createPluginTestHarness = async (plugin, options) => {
+const createPluginTestHarness = async (plugin, options = {}) => {
 	const adapter = options.adapter ?? createMemoryAdapter();
-	const module = {
-		id: plugin.id,
-		schema: plugin.schema,
-		...plugin.namespace === false ? {} : { namespace: plugin.id }
-	};
-	const schema = options.engine.resolveSchema([module]);
-	await adapter.migrations?.apply(schema.tables);
-	const engine = options.engine.createDatabaseEngine({
-		adapter,
-		schema,
-		verify: true
-	});
+	const core = new Set(coreSchema.tables.map(({ name }) => name));
+	const tables = toolingTargetOf([plugin]).schema.tables.filter(({ name }) => !core.has(name));
+	await adapter.migrations?.apply(tables);
 	let clock = options.now ?? Date.now;
-	const db = engine.database(module);
+	const now = () => clock();
+	const database = meterReads({
+		name: "plugin test harness",
+		adapter: verifyAdapter(Object.assign(Object.create(adapter), { prune: void 0 }))
+	});
+	const db = createEngine(database, {
+		plugins: [plugin],
+		now
+	}).database(plugin);
 	const instance = plugin.init({
 		db,
 		core: {},
-		now: () => clock()
+		now
 	});
 	return {
 		api: instance.api,
 		instance,
-		/** The plugin's own database handle; cast it to its `HotUpdaterDatabase` type. */
+		/** The plugin's own database handle. */
 		db,
 		adapter,
-		tables: schema.tables,
-		/** Reads at both boundaries while `read` runs. */
-		measureReads: (read) => engine.measureReads(read),
-		setNow: (now) => {
-			clock = now;
+		/** The plugin's physical tables. */
+		tables,
+		/** Reads at the adapter and at the engine while `read` runs. */
+		measureReads: database.measureReads,
+		setNow: (next) => {
+			clock = next;
+		}
+	};
+};
+//#endregion
+//#region src/storeBundles.ts
+/**
+* Stores bundles and their patches with no release, as a database holds an
+* artifact that no release uses. `deploy` always adds a release, and
+* deleting a bundle's last release deletes the bundle, so tests store such
+* bundles through the engine. A patch's base comes before it in `bundles`.
+*/
+const storeBundles = async (database, bundles) => {
+	const engine = createEngine(database);
+	try {
+		await engine.core.transaction(async (tx) => {
+			for (const bundle of bundles) {
+				tx.create("bundles", bundleToRow(bundle));
+				for (const platformKey of [bundle.platform, "*"]) tx.aggregate("bundle_totals", { platform_key: platformKey }, { bundles: 1 });
+				for (const row of bundleToPatchRows(bundle)) tx.create("bundle_patches", row);
+			}
+		});
+	} finally {
+		await engine.dispose();
+	}
+};
+//#endregion
+//#region src/insights/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/insights/fixtures.ts
+const fixtureId = (suffix) => `00000000-0000-7000-8000-${suffix.padStart(12, "0")}`;
+/** An applied update from install `suffix`, received at `receivedAtMs`. */
+const createBundleEventRowFixture = (suffix, receivedAtMs) => ({
+	id: fixtureId(suffix),
+	type: "UPDATE_APPLIED",
+	install_id: `install-${suffix}`,
+	user_id: null,
+	metadata: {
+		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
+});
+//#endregion
+//#region src/insights/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]];
+			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 expect(model.findLatestEvents({ installId: unchanged.install_id })).resolves.toEqual([unchanged]);
+			await expectInsightsIndex(() => model.listEvents({
+				filter: { kind: "all" },
+				sinceMs: 100,
+				beforeReceivedAtMs: 200,
+				limit: 10
+			}), [
+				excluded[4],
+				recovered,
+				excluded[3],
+				excluded[2],
+				applied
+			]);
+			await expect(model.countEvents({
+				filter: {
+					platform: "ios",
+					channel: "production",
+					type: "UNCHANGED",
+					toBundleId: bundleB
+				},
+				sinceMs: 100,
+				beforeReceivedAtMs: 200
+			})).rejects.toThrow();
+			await expectInsightsIndex(() => model.countLatestEvents({
+				platform: "ios",
+				channel: "production",
+				sinceMs: 0,
+				bundle: [{
+					field: "to_bundle_id",
+					value: bundleA,
+					types: [
+						"UNCHANGED",
+						"UPDATE_APPLIED",
+						"RECOVERED"
+					]
+				}]
+			}), 1);
+			await expectInsightsIndex(() => model.countLatestEvents({
+				platform: "ios",
+				channel: "production",
+				sinceMs: 0
+			}), 5);
+			await expect(model.countLatestEvents({
+				platform: "ios",
+				channel: "production",
+				sinceMs: 100
+			})).rejects.toThrow();
+		});
+		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]);
+		});
+		it("lists an update failure where its target's list and installation history read it, and a failed check in no bundle list, moving no latest event", async () => {
+			const model = state.getDatabase();
+			const applied = createMovementEvent("721", 100, "UPDATE_APPLIED", "install-failing");
+			const failure = (suffix, receivedAtMs, failed) => ({
+				...applied,
+				id: createBundleEventRowFixture(suffix, 0).id,
+				type: "UPDATE_FAILED",
+				from_bundle_id: applied.to_bundle_id,
+				to_bundle_id: failed.stage === "check" ? applied.to_bundle_id : createBundleEventRowFixture("729", 0).to_bundle_id,
+				metadata: {
+					...applied.metadata,
+					failure: failed
+				},
+				received_at_ms: receivedAtMs
+			});
+			const download = failure("722", 200, {
+				stage: "download",
+				reason: "http",
+				http_status: 403,
+				origin_code: "AccessDenied"
+			});
+			const check = failure("723", 300, {
+				stage: "check",
+				reason: "http"
+			});
+			for (const event of [
+				applied,
+				download,
+				check
+			]) await record(model, event);
+			await expect(model.findLatestEvents({ installId: "install-failing" })).resolves.toEqual([applied]);
+			await expectInsightsIndex(() => model.listEvents({
+				filter: {
+					kind: "installationMovement",
+					installId: "install-failing"
+				},
+				beforeReceivedAtMs: 301,
+				limit: 10
+			}), [
+				check,
+				download,
+				applied
+			]);
+			await expectInsightsIndex(() => model.listEvents({
+				filter: { kind: "all" },
+				beforeReceivedAtMs: 301,
+				limit: 10
+			}), [
+				check,
+				download,
+				applied
+			]);
+			const scope = {
+				platform: "ios",
+				channel: "production"
+			};
+			for (const [toBundleId, listed] of [[download.to_bundle_id, [download]], [check.to_bundle_id, []]]) {
+				const filter = {
+					...scope,
+					type: "UPDATE_FAILED",
+					toBundleId
+				};
+				await expectInsightsIndex(() => model.listEvents({
+					filter: {
+						kind: "bundle",
+						...filter
+					},
+					beforeReceivedAtMs: 301,
+					limit: 10
+				}), listed);
+				await expect(model.countEvents({
+					filter,
+					sinceMs: 0,
+					beforeReceivedAtMs: 301
+				})).resolves.toBe(listed.length);
+			}
+		});
+	});
+};
+//#endregion
+//#region src/insights/setupInsightsHttpTestSuite.ts
+const jsonRequest$1 = (method, body) => ({
+	method,
+	headers: { "content-type": "application/json" },
+	body: JSON.stringify(body)
+});
+/**
+* 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,
+				sdkVersion: "2.0.0"
+			};
+			const reported = await client.client("/events", jsonRequest$1("POST", event));
+			expect(reported.status).toBe(204);
+			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("records an update failure in installation history and the failures read", async () => {
+			const client = options.getClient();
+			const installId = `install-${crypto.randomUUID()}`;
+			const channel = `insights-${crypto.randomUUID()}`;
+			const releaseId = "00000000-0000-7000-8000-0000000000b2";
+			const reported = await client.client("/events", jsonRequest$1("POST", {
+				appVersion: "1.0.0",
+				channel,
+				cohort: "default",
+				fingerprintHash: null,
+				fromBundleId: "00000000-0000-7000-8000-000000000001",
+				fromReleaseId: null,
+				installId,
+				platform: "ios",
+				toBundleId: "00000000-0000-7000-8000-000000000002",
+				toReleaseId: releaseId,
+				type: "UPDATE_FAILED",
+				updateStrategy: "appVersion",
+				metadata: { failure: {
+					stage: "download",
+					reason: "http",
+					httpStatus: 403
+				} }
+			}));
+			expect(reported.status).toBe(204);
+			await reported.text();
+			await expectInsightsIndex(async () => {
+				return (await (await client.admin(`/installations/${encodeURIComponent(installId)}/events?limit=10`)).json()).data.map(({ type, failure }) => ({
+					type,
+					failure
+				}));
+			}, [{
+				type: "UPDATE_FAILED",
+				failure: {
+					stage: "download",
+					reason: "http",
+					httpStatus: 403
+				}
+			}]);
+			const now = Date.now();
+			await expectInsightsIndex(async () => {
+				const body = await (await client.admin(`/failures?platform=ios&channel=${encodeURIComponent(channel)}&releaseId=${releaseId}&start=${now - 864e5}&end=${now + 36e5}`)).json();
+				return [body.failedUpdates, body.failedInstallations];
+			}, [1, 1]);
+		});
+		it("refuses a malformed event", async () => {
+			const response = await options.getClient().client("/events", jsonRequest$1("POST", { type: "UNCHANGED" }));
+			expect(response.status).toBe(400);
+			await response.text();
+		});
+	});
+};
+//#endregion
+//#region src/insights/setupInsightsModelTestSuite.ts
+/**
+* The Insights report contract on one database: pass the Insights plugin's
+* model over it, `createInsightsModel(createHotUpdater({ database, plugins:
+* [insights()], clientAccess: "public" }).api.insights)`, as `createDatabase`.
+*/
+const setupInsightsModelTestSuite = (lifecycle) => {
+	describe(lifecycle.name, () => {
+		let model;
+		const getDatabase = () => {
+			if (model === void 0) throw new Error("The model is unavailable outside the test lifecycle");
+			return model;
+		};
+		beforeAll(async () => {
+			await lifecycle.migrate();
+			model = await lifecycle.createDatabase();
+		});
+		beforeEach(async () => {
+			await lifecycle.reset(getDatabase());
+		});
+		afterAll(async () => {
+			await lifecycle.dispose(getDatabase());
+			model = void 0;
+		});
+		registerInsightsModelTests({ getDatabase });
+	});
+};
+//#endregion
+//#region src/insights/index.ts
+/**
+* The Insights plugin's tests, for `setupDatabaseTestSuite`'s `plugins`: its
+* HTTP routes on the provider's server, which must run `insights()`, and
+* with `createModel` its report contract on the provider's database, such as
+* `(database) => createInsightsModel(createHotUpdater({ database, plugins:
+* [insights()], clientAccess: "public" }).api.insights)`.
+*/
+const insightsTestSuite = (options = {}) => ({
+	name: "Insights plugin",
+	register: (context) => {
+		setupInsightsHttpTestSuite({ getClient: context.getClient });
+		const { createModel } = options;
+		if (createModel !== void 0) describe("Insights model", () => {
+			registerInsightsModelTests({ getDatabase: () => createModel(context.getDatabase()) });
+		});
+	}
+});
+//#endregion
+//#region src/kvTestStore.ts
+/**
+* An in-memory key-value store that behaves like DynamoDB where the adapter
+* can tell: a write checks every condition against the state before it,
+* refuses two ops on one item, and applies all ops or none.
+*/
+const createMemoryKeyValueStore = (options = {}) => {
+	let partitions = /* @__PURE__ */ new Map();
+	let expiries = /* @__PURE__ */ new Map();
+	const read = (key) => partitions.get(key.pk)?.get(key.sk) ?? null;
+	const holds = (key, condition) => {
+		if (condition === void 0) return true;
+		const item = read(key);
+		return "v" in condition ? item !== null && item[DATABASE_VERSION_COLUMN] === condition.v : item !== null === condition.exists;
+	};
+	return {
+		id: "memory-kv",
+		limits: options.limits ?? {
+			items: 100,
+			bytes: 4e6
+		},
+		items: () => [...partitions.values()].reduce((sum, items) => sum + items.size, 0),
+		expiries: () => expiries,
+		async get(keys) {
+			return keys.map((key) => structuredClone(read(key)));
+		},
+		async query({ pk, gte, lt, order, limit, after }) {
+			const direction = order === "asc" ? 1 : -1;
+			const matching = [...partitions.get(pk) ?? /* @__PURE__ */ new Map()].filter(([sk]) => (gte === void 0 || compareUtf8(sk, gte) >= 0) && (lt === void 0 || compareUtf8(sk, lt) < 0) && (after === void 0 || direction * compareUtf8(sk, after) > 0)).sort(([left], [right]) => direction * compareUtf8(left, right));
+			const size = Math.min(limit, options.nativePageSize ?? limit);
+			return {
+				items: matching.slice(0, size).map(([sk, value]) => ({
+					sk,
+					value: structuredClone(value)
+				})),
+				more: matching.length > size
+			};
+		},
+		async write(ops) {
+			if (new Set(ops.map(({ key }) => JSON.stringify(key))).size !== ops.length) throw new Error("A write may touch each item once.");
+			const failed = ops.findIndex((op) => !holds(op.key, op.condition));
+			if (failed !== -1) return {
+				ok: false,
+				failedOp: failed
+			};
+			const next = new Map(partitions);
+			const stamped = new Map(expiries);
+			for (const op of ops) {
+				if (op.type === "check") continue;
+				const items = new Map(next.get(op.key.pk));
+				next.set(op.key.pk, items);
+				const id = JSON.stringify([op.key.pk, op.key.sk]);
+				if (op.type === "delete") {
+					items.delete(op.key.sk);
+					stamped.delete(id);
+				} else if (op.type === "put") {
+					items.set(op.key.sk, structuredClone(op.value));
+					if (op.expiresAt === void 0) stamped.delete(id);
+					else stamped.set(id, op.expiresAt);
+				} else {
+					if (!items.has(op.key.sk) && op.expiresAt !== void 0) stamped.set(id, op.expiresAt);
+					const item = structuredClone(items.get(op.key.sk) ?? op.init ?? {});
+					for (const [name, delta] of Object.entries(op.by)) item[name] = Number(item[name] ?? 0) + delta;
+					items.set(op.key.sk, item);
+				}
+			}
+			partitions = next;
+			expiries = stamped;
+			return { ok: true };
+		},
+		async deleteConsumed(keys) {
+			const next = new Map(partitions);
+			for (const { pk, sk } of keys) {
+				const items = new Map(next.get(pk));
+				items.delete(sk);
+				next.set(pk, items);
+				expiries.delete(JSON.stringify([pk, sk]));
+			}
+			partitions = next;
+		},
+		async dispose() {
+			partitions = /* @__PURE__ */ new Map();
+			expiries = /* @__PURE__ */ new Map();
 		}
 	};
 };
@@ -3332,4 +4969,4 @@ async function startHttpTestServer(handlers) {
 	};
 }
 //#endregion
-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 };
+export { RELEASE_CATALOG_DOWNLOAD_HASH, RELEASE_CATALOG_MANIFEST_URIS, RELEASE_CATALOG_STORAGE_FIXTURES, conformanceCounters, conformanceExpiring, conformanceItems, createAdminApiTestClient, createBundleEventRowFixture, createBundleFixture, createBundlePatchRowFixture, createBundleRowFixture, createChannelRowFixture, createHandlerHttpTestClient, createHttpTestClient, createMeasuredDatabase, createMemoryKeyValueStore, createPluginTestHarness, createReleaseCatalogTestStorage, createReleaseRowFixture, expectInsightsIndex, insightsTestSuite, jsonRequest, mysqlRowsExamined, postgresRowsExamined, releaseCatalogArtifact, releaseCatalogDownloadUrl, runContentionHarness, setupAggregateBatchingTestSuite, setupBundleMethodsTestSuite, setupCoreAdminTestSuite, setupDatabaseAdapterConformanceSuite, setupDatabaseTestSuite, setupInsightsHttpTestSuite, setupInsightsModelTestSuite, setupReadBudgetTestSuite, setupReleaseCatalogTestSuite, setupSemverSatisfiesTestSuite, setupStorageAdapterTestSuite, startHttpTestServer, storeBundles, toDeployBundle, withAdapterLatency };