@hot-updater/firebase 1.0.0-rc.2 → 1.0.0-rc.21

package/dist/index.mjs

@@ -1,917 +1,195 @@
-import { compareInsightsText, createDatabasePlugin, createStorageKeyBuilder, createStoragePlugin, createStorageUri, isDatabaseMetadataObject, parseStorageUri } from "@hot-updater/plugin-core";
-import { createDatabasePluginAdapter } from "@hot-updater/plugin-core/internal";
+import { createEngineDatabase, createKvAdapter, createStorageAdapter, createStorageKeyBuilder, createStorageUri, migrateCoreSchema, parseStorageUri } from "@hot-updater/plugin-core";
 import { getApp, getApps, initializeApp } from "firebase-admin/app";
-import { getFirestore } from "firebase-admin/firestore";
+import { FieldPath, FieldValue, Timestamp, getFirestore } from "firebase-admin/firestore";
+import { createHash } from "node:crypto";
 import { getStorage } from "firebase-admin/storage";
-//#region src/firebaseDatabaseParserShared.ts
-var FirebaseDatabaseDataError = class extends Error {
-	source;
-	name = "FirebaseDatabaseDataError";
-	constructor(source) {
-		super(`Invalid Firebase database data at "${source}".`);
-		this.source = source;
-	}
-};
-const record = (value, source) => {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new FirebaseDatabaseDataError(source);
-	return value;
-};
-const property = (value, key) => Reflect.get(value, key);
-const string = (value, source) => {
-	if (typeof value !== "string") throw new FirebaseDatabaseDataError(source);
-	return value;
-};
-const nullableString = (value, source) => {
-	if (value === null || value === void 0) return null;
-	return string(value, source);
-};
-const boolean = (value, source) => {
-	if (typeof value !== "boolean") throw new FirebaseDatabaseDataError(source);
-	return value;
-};
-const number = (value, source) => {
-	if (typeof value !== "number" || !Number.isFinite(value)) throw new FirebaseDatabaseDataError(source);
-	return value;
-};
-const byteSize = (value, source) => {
-	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) throw new FirebaseDatabaseDataError(source);
-	return value;
-};
-const stringArray = (value, source) => {
-	if (value === null || value === void 0) return null;
-	if (!Array.isArray(value)) throw new FirebaseDatabaseDataError(source);
-	return value.map((item) => string(item, source));
-};
-const platform = (value, source) => {
-	if (value === "android" || value === "ios") return value;
-	throw new FirebaseDatabaseDataError(source);
-};
-//#endregion
-//#region src/firebaseDatabaseParser.ts
-const metadata = (value, source) => {
-	if (!isDatabaseMetadataObject(value)) throw new FirebaseDatabaseDataError(source);
-	return value;
-};
-const requiredNullableString = (input, key, source) => {
-	if (!Object.hasOwn(input, key)) throw new FirebaseDatabaseDataError(source);
-	return nullableString(property(input, key), source);
-};
-const parseFirebaseBundleRow = (value, source) => {
-	const input = record(value, source);
-	return {
-		id: string(property(input, "id"), source),
-		platform: platform(property(input, "platform"), source),
-		file_hash: string(property(input, "file_hash"), source),
-		git_commit_hash: nullableString(property(input, "git_commit_hash"), source),
-		storage_uri: string(property(input, "storage_uri"), source),
-		archive_byte_size: byteSize(property(input, "archive_byte_size"), source),
-		metadata: metadata(property(input, "metadata"), source),
-		manifest_storage_uri: nullableString(property(input, "manifest_storage_uri"), source),
-		manifest_file_hash: nullableString(property(input, "manifest_file_hash"), source),
-		asset_base_storage_uri: nullableString(property(input, "asset_base_storage_uri"), source)
-	};
-};
-const parseFirebaseChannelRow = (value, source) => {
-	const input = record(value, source);
-	return {
-		id: string(property(input, "id"), source),
-		name: string(property(input, "name"), source)
-	};
-};
-const parseFirebasePatchRow = (value, source) => {
-	const input = record(value, source);
-	return {
-		id: string(property(input, "id"), source),
-		bundle_id: string(property(input, "bundle_id"), source),
-		base_bundle_id: string(property(input, "base_bundle_id"), source),
-		base_file_hash: string(property(input, "base_file_hash"), source),
-		patch_file_hash: string(property(input, "patch_file_hash"), source),
-		patch_storage_uri: string(property(input, "patch_storage_uri"), source),
-		byte_size: byteSize(property(input, "byte_size"), source),
-		order_index: number(property(input, "order_index"), source)
-	};
-};
-const parseFirebaseBundleEventRow = (value, source) => {
-	const input = record(value, source);
-	const type = string(property(input, "type"), source);
-	const fromBundleId = requiredNullableString(input, "from_bundle_id", source);
-	const updateStrategy = requiredNullableString(input, "update_strategy", source);
-	if (!((type === "UPDATE_APPLIED" || type === "RECOVERED" || type === "RELEASE_ADOPTED") && typeof fromBundleId === "string" && (updateStrategy === "fingerprint" || updateStrategy === "appVersion") || type === "UNCHANGED" && fromBundleId === null && updateStrategy === null)) throw new FirebaseDatabaseDataError(source);
-	return {
-		id: string(property(input, "id"), source),
-		type,
-		install_id: string(property(input, "install_id"), source),
-		user_id: nullableString(property(input, "user_id"), source),
-		username: nullableString(property(input, "username"), source),
-		from_release_id: requiredNullableString(input, "from_release_id", source),
-		from_bundle_id: fromBundleId,
-		to_release_id: requiredNullableString(input, "to_release_id", source),
-		to_bundle_id: string(property(input, "to_bundle_id"), source),
-		platform: platform(property(input, "platform"), source),
-		app_version: string(property(input, "app_version"), source),
-		channel: string(property(input, "channel"), source),
-		cohort: string(property(input, "cohort"), source),
-		update_strategy: updateStrategy,
-		fingerprint_hash: nullableString(property(input, "fingerprint_hash"), source),
-		sdk_version: nullableString(property(input, "sdk_version"), source),
-		received_at_ms: number(property(input, "received_at_ms"), source)
-	};
-};
-const parseFirebaseInsightsInstallationRow = (value, source) => {
-	const input = record(value, source);
-	const type = string(property(input, "type"), source);
-	if (type !== "UPDATE_APPLIED" && type !== "RECOVERED" && type !== "RELEASE_ADOPTED" && type !== "UNCHANGED") throw new FirebaseDatabaseDataError(source);
-	return {
-		id: string(property(input, "id"), source),
-		type,
-		install_id: string(property(input, "install_id"), source),
-		user_id: nullableString(property(input, "user_id"), source),
-		username: nullableString(property(input, "username"), source),
-		to_bundle_id: string(property(input, "to_bundle_id"), source),
-		platform: platform(property(input, "platform"), source),
-		app_version: string(property(input, "app_version"), source),
-		channel: string(property(input, "channel"), source),
-		cohort: string(property(input, "cohort"), source),
-		received_at_ms: number(property(input, "received_at_ms"), source)
-	};
-};
-const parseFirebaseApiKeyRow = (value, source) => {
-	const input = record(value, source);
-	const role = string(property(input, "role"), source);
-	if (role !== "client") throw new FirebaseDatabaseDataError(source);
-	const revokedAt = property(input, "revoked_at_ms");
-	return {
-		id: string(property(input, "id"), source),
-		hash: string(property(input, "hash"), source),
-		name: string(property(input, "name"), source),
-		prefix: string(property(input, "prefix"), source),
-		role,
-		created_at_ms: number(property(input, "created_at_ms"), source),
-		revoked_at_ms: revokedAt === null ? null : number(revokedAt, source)
-	};
-};
-const parseFirebaseReleaseRow = (value, source) => {
-	const input = record(value, source);
-	const kind = string(property(input, "kind"), source);
-	const strategy = string(property(input, "strategy"), source);
-	const operation = string(property(input, "operation"), source);
-	const targetCohorts = stringArray(property(input, "target_cohorts"), source);
-	if (kind !== "BUNDLE" && kind !== "EMBEDDED" || strategy !== "APP_VERSION" && strategy !== "FINGERPRINT" || operation !== "DEPLOY" && operation !== "PROMOTE" && operation !== "ROLLBACK" || targetCohorts === null) throw new FirebaseDatabaseDataError(source);
-	return {
-		id: string(property(input, "id"), source),
-		revision: number(property(input, "revision"), source),
-		scope_key: string(property(input, "scope_key"), source),
-		channel_id: string(property(input, "channel_id"), source),
-		platform: platform(property(input, "platform"), source),
-		kind,
-		bundle_id: nullableString(property(input, "bundle_id"), source),
-		strategy,
-		target_app_version: nullableString(property(input, "target_app_version"), source),
-		fingerprint_hash: nullableString(property(input, "fingerprint_hash"), source),
-		enabled: boolean(property(input, "enabled"), source),
-		should_force_update: boolean(property(input, "should_force_update"), source),
-		message: nullableString(property(input, "message"), source),
-		rollout_cohort_count: number(property(input, "rollout_cohort_count"), source),
-		target_cohorts: targetCohorts,
-		operation,
-		source_release_id: nullableString(property(input, "source_release_id"), source),
-		created_at_ms: number(property(input, "created_at_ms"), source),
-		updated_at_ms: number(property(input, "updated_at_ms"), source)
-	};
-};
-const parseFirebaseReleaseCatalogRow = (value, source) => {
-	const input = record(value, source);
-	const strategy = string(property(input, "strategy"), source);
-	if (strategy !== "APP_VERSION" && strategy !== "FINGERPRINT") throw new FirebaseDatabaseDataError(source);
-	return {
-		scope_key: string(property(input, "scope_key"), source),
-		catalog_id: string(property(input, "catalog_id"), source),
-		strategy,
-		channel_id: string(property(input, "channel_id"), source),
-		channel_key: string(property(input, "channel_key"), source),
-		platform: platform(property(input, "platform"), source),
-		fingerprint_hash: nullableString(property(input, "fingerprint_hash"), source),
-		generation: number(property(input, "generation"), source),
-		payload: string(property(input, "payload"), source),
-		catalog_hash: string(property(input, "catalog_hash"), source),
-		byte_size: number(property(input, "byte_size"), source),
-		is_tombstone: boolean(property(input, "is_tombstone"), source),
-		updated_at_ms: number(property(input, "updated_at_ms"), source)
-	};
-};
-//#endregion
-//#region src/firebaseDatabaseQuery.ts
-const compare = (left, right) => {
-	if (typeof left === "number" && typeof right === "number") return left - right;
-	return String(left).localeCompare(String(right));
-};
-const normalizeStringComparison = (actual, expected, mode) => {
-	if (typeof actual !== "string") return null;
-	return mode === "insensitive" ? [actual.toLocaleLowerCase(), expected.toLocaleLowerCase()] : [actual, expected];
-};
-const matchesCondition = (row, condition) => {
-	const actual = Reflect.get(row, condition.field);
-	const expected = condition.value;
-	switch (condition.operator ?? "eq") {
-		case "eq": {
-			if (typeof expected !== "string") return actual === expected;
-			const mode = "mode" in condition ? condition.mode : void 0;
-			const comparison = normalizeStringComparison(actual, expected, mode);
-			return comparison !== null && comparison[0] === comparison[1];
-		}
-		case "ne": {
-			if (actual === null || actual === void 0) return false;
-			if (typeof expected !== "string") return actual !== expected;
-			const mode = "mode" in condition ? condition.mode : void 0;
-			const comparison = normalizeStringComparison(actual, expected, mode);
-			return comparison === null || comparison[0] !== comparison[1];
-		}
-		case "gt":
-			if (actual === null || actual === void 0) return false;
-			return compare(actual, expected) > 0;
-		case "gte":
-			if (actual === null || actual === void 0) return false;
-			return compare(actual, expected) >= 0;
-		case "lt":
-			if (actual === null || actual === void 0) return false;
-			return compare(actual, expected) < 0;
-		case "lte":
-			if (actual === null || actual === void 0) return false;
-			return compare(actual, expected) <= 0;
-		case "in":
-			if (!Array.isArray(expected)) return false;
-			return expected.some((candidate) => candidate === actual);
-		case "not_in": {
-			if (!Array.isArray(expected)) return false;
-			const values = expected;
-			return values.length === 0 || actual !== null && actual !== void 0 && values.every((candidate) => candidate !== actual);
-		}
-		case "contains": {
-			if (typeof expected !== "string") return false;
-			const mode = "mode" in condition ? condition.mode : void 0;
-			const comparison = normalizeStringComparison(actual, expected, mode);
-			return comparison?.[0].includes(comparison[1]) ?? false;
-		}
-		case "starts_with": {
-			if (typeof expected !== "string") return false;
-			const mode = "mode" in condition ? condition.mode : void 0;
-			const comparison = normalizeStringComparison(actual, expected, mode);
-			return comparison?.[0].startsWith(comparison[1]) ?? false;
-		}
-		case "ends_with": {
-			if (typeof expected !== "string") return false;
-			const mode = "mode" in condition ? condition.mode : void 0;
-			const comparison = normalizeStringComparison(actual, expected, mode);
-			return comparison?.[0].endsWith(comparison[1]) ?? false;
-		}
-	}
-};
-const matchesFirebaseDatabaseWhere = (row, where) => {
-	const first = where?.[0];
-	if (!first) return true;
-	let result = matchesCondition(row, first);
-	for (const condition of where.slice(1)) {
-		const current = matchesCondition(row, condition);
-		result = condition.connector === "OR" ? result || current : result && current;
-	}
-	return result;
-};
-const queryFirebaseDatabaseRows = (rows, input) => {
-	const filtered = rows.filter((row) => matchesFirebaseDatabaseWhere(row, input.where));
-	const orderBy = input.orderBy;
-	if (orderBy !== void 0) filtered.sort((left, right) => {
-		for (const clause of orderBy) {
-			const leftValue = Reflect.get(left, clause.field);
-			const rightValue = Reflect.get(right, clause.field);
-			if (leftValue === rightValue) continue;
-			if (clause.nulls !== void 0 && (leftValue === null || rightValue === null)) {
-				const nullComparison = leftValue === null ? -1 : 1;
-				return clause.nulls === "first" ? nullComparison : -nullComparison;
-			}
-			const comparison = compare(leftValue, rightValue);
-			if (comparison !== 0) return clause.direction === "asc" ? comparison : -comparison;
-		}
-		return 0;
-	});
-	const distinctOn = input.distinctOn;
-	if (distinctOn === void 0) return filtered.slice(input.offset, input.offset + input.limit);
-	const seen = /* @__PURE__ */ new Set();
-	return filtered.filter((row) => {
-		const key = JSON.stringify(distinctOn.fields.map((field) => Reflect.get(row, field)));
-		if (seen.has(key)) return false;
-		seen.add(key);
-		return true;
-	}).slice(input.offset, input.offset + input.limit);
-};
-//#endregion
-//#region src/firebaseDatabaseState.ts
-var FirebaseDatabaseConstraintError = class extends Error {
-	constraint;
-	name = "FirebaseDatabaseConstraintError";
-	constructor(constraint) {
-		super(`Firebase database constraint failed: ${constraint}`);
-		this.constraint = constraint;
-	}
-};
-const cloneFirebaseDatabaseSnapshot = (snapshot) => ({
-	bundles: new Map(snapshot.bundles),
-	bundlePatches: new Map(snapshot.bundlePatches),
-	bundleEvents: new Map(snapshot.bundleEvents),
-	bundleInstallations: new Map(snapshot.bundleInstallations),
-	channels: new Map(snapshot.channels),
-	apiKeys: new Map(snapshot.apiKeys),
-	releaseCatalogs: new Map(snapshot.releaseCatalogs),
-	releases: new Map(snapshot.releases)
-});
-const requireUnique = (rows, id, model) => {
-	if (rows.has(id)) throw new FirebaseDatabaseConstraintError(`${model}.id.unique`);
-};
-const distinctCount = (rows, fields) => {
-	if (fields === void 0) return rows.length;
-	return new Set(rows.map((row) => JSON.stringify(fields.map((field) => Reflect.get(row, field))))).size;
-};
-const createFirebaseDatabaseState = (snapshot) => ({
-	async create(input) {
-		switch (input.model) {
-			case "bundles":
-				requireUnique(snapshot.bundles, input.data.id, input.model);
-				snapshot.bundles.set(input.data.id, input.data);
-				return input.data;
-			case "bundle_patches":
-				requireUnique(snapshot.bundlePatches, input.data.id, input.model);
-				if (!snapshot.bundles.has(input.data.bundle_id)) throw new FirebaseDatabaseConstraintError("bundle_patches.bundle_id.foreign-key");
-				if (!snapshot.bundles.has(input.data.base_bundle_id)) throw new FirebaseDatabaseConstraintError("bundle_patches.base_bundle_id.foreign-key");
-				snapshot.bundlePatches.set(input.data.id, input.data);
-				return input.data;
-			case "bundle_events":
-				requireUnique(snapshot.bundleEvents, input.data.id, input.model);
-				snapshot.bundleEvents.set(input.data.id, input.data);
-				return input.data;
-			case "bundle_installations": {
-				const current = snapshot.bundleInstallations.get(input.data.install_id);
-				if (current && input.onConflict === "ignore") return current;
-				if (current) throw new FirebaseDatabaseConstraintError("bundle_installations.install_id.unique");
-				snapshot.bundleInstallations.set(input.data.install_id, input.data);
-				return input.data;
-			}
-			case "releases":
-				requireUnique(snapshot.releases, input.data.id, input.model);
-				if (!snapshot.channels.has(input.data.channel_id)) throw new FirebaseDatabaseConstraintError("releases.channel_id.foreign-key");
-				if (input.data.bundle_id !== null && !snapshot.bundles.has(input.data.bundle_id)) throw new FirebaseDatabaseConstraintError("releases.bundle_id.foreign-key");
-				snapshot.releases.set(input.data.id, input.data);
-				return input.data;
-			case "release_catalogs":
-				if (snapshot.releaseCatalogs.has(input.data.scope_key)) throw new FirebaseDatabaseConstraintError("release_catalogs.scope_key.unique");
-				snapshot.releaseCatalogs.set(input.data.scope_key, input.data);
-				return input.data;
-			case "channels": {
-				const existing = [...snapshot.channels.values()].find(({ name }) => name === input.data.name);
-				if (existing && input.onConflict === "ignore") return existing;
-				requireUnique(snapshot.channels, input.data.id, input.model);
-				if (existing) throw new FirebaseDatabaseConstraintError("channels.name.unique");
-				snapshot.channels.set(input.data.id, input.data);
-				return input.data;
-			}
-			case "api_keys": {
-				const existing = [...snapshot.apiKeys.values()].find(({ hash }) => hash === input.data.hash);
-				if (existing && input.onConflict === "ignore") return existing;
-				requireUnique(snapshot.apiKeys, input.data.id, input.model);
-				if (existing) throw new FirebaseDatabaseConstraintError("api_keys.hash.unique");
-				snapshot.apiKeys.set(input.data.id, input.data);
-				return input.data;
-			}
-		}
-	},
-	async update(input) {
-		if (input.model === "bundle_installations") {
-			const current = [...snapshot.bundleInstallations.values()].find((row) => matchesFirebaseDatabaseWhere(row, input.where));
-			if (!current) return null;
-			const updated = {
-				...current,
-				...input.update
-			};
-			snapshot.bundleInstallations.set(current.install_id, updated);
-			return updated;
-		}
-		if (input.model === "api_keys") {
-			const current = [...snapshot.apiKeys.values()].find((row) => matchesFirebaseDatabaseWhere(row, input.where));
-			if (!current) return null;
-			const updated = {
-				...current,
-				...input.update
-			};
-			snapshot.apiKeys.set(current.id, updated);
-			return updated;
-		}
-		if (input.model === "releases") {
-			const current = [...snapshot.releases.values()].find((row) => matchesFirebaseDatabaseWhere(row, input.where));
-			if (!current) return null;
-			const updated = {
-				...current,
-				...input.update
-			};
-			snapshot.releases.set(current.id, updated);
-			return updated;
-		}
-		if (input.model === "release_catalogs") {
-			const current = [...snapshot.releaseCatalogs.values()].find((row) => matchesFirebaseDatabaseWhere(row, input.where));
-			if (!current) return null;
-			const updated = {
-				...current,
-				...input.update
-			};
-			snapshot.releaseCatalogs.set(current.scope_key, updated);
-			return updated;
-		}
-		const current = [...snapshot.bundles.values()].find((row) => matchesFirebaseDatabaseWhere(row, input.where));
-		if (!current) return null;
-		const updated = {
-			...current,
-			...input.update
-		};
-		snapshot.bundles.set(current.id, updated);
-		return updated;
-	},
-	async delete(input) {
-		if (input.model === "channels") {
-			for (const row of snapshot.channels.values()) if (matchesFirebaseDatabaseWhere(row, input.where)) snapshot.channels.delete(row.id);
-			return;
-		}
-		if (input.model === "bundle_patches") {
-			for (const row of snapshot.bundlePatches.values()) if (matchesFirebaseDatabaseWhere(row, input.where)) snapshot.bundlePatches.delete(row.id);
-			return;
-		}
-		if (input.model === "releases") {
-			for (const row of snapshot.releases.values()) if (matchesFirebaseDatabaseWhere(row, input.where)) snapshot.releases.delete(row.id);
-			return;
-		}
-		const removedIds = new Set([...snapshot.bundles.values()].filter((row) => matchesFirebaseDatabaseWhere(row, input.where)).map(({ id }) => id));
-		for (const id of removedIds) snapshot.bundles.delete(id);
-		for (const patch of snapshot.bundlePatches.values()) if (removedIds.has(patch.bundle_id) || removedIds.has(patch.base_bundle_id)) snapshot.bundlePatches.delete(patch.id);
-	},
-	async count(input) {
-		switch (input.model) {
-			case "bundles": return distinctCount([...snapshot.bundles.values()].filter((row) => matchesFirebaseDatabaseWhere(row, input.where)), input.distinct);
-			case "bundle_patches": return distinctCount([...snapshot.bundlePatches.values()].filter((row) => matchesFirebaseDatabaseWhere(row, input.where)), input.distinct);
-			case "releases": return distinctCount([...snapshot.releases.values()].filter((row) => matchesFirebaseDatabaseWhere(row, input.where)), input.distinct);
-			case "bundle_installations": return distinctCount([...snapshot.bundleInstallations.values()].filter((row) => matchesFirebaseDatabaseWhere(row, input.where)), input.distinct);
-			case "bundle_events": return distinctCount([...snapshot.bundleEvents.values()].filter((row) => matchesFirebaseDatabaseWhere(row, input.where)), input.distinct);
-		}
-	},
-	async findOne(input) {
-		switch (input.model) {
-			case "bundles": return [...snapshot.bundles.values()].find((row) => matchesFirebaseDatabaseWhere(row, input.where)) ?? null;
-			case "api_keys": return [...snapshot.apiKeys.values()].find((row) => matchesFirebaseDatabaseWhere(row, input.where)) ?? null;
-			case "channels": return [...snapshot.channels.values()].find((row) => matchesFirebaseDatabaseWhere(row, input.where)) ?? null;
-			case "bundle_patches": return [...snapshot.bundlePatches.values()].find((row) => matchesFirebaseDatabaseWhere(row, input.where)) ?? null;
-			case "releases": return [...snapshot.releases.values()].find((row) => matchesFirebaseDatabaseWhere(row, input.where)) ?? null;
-			case "release_catalogs": return [...snapshot.releaseCatalogs.values()].find((row) => matchesFirebaseDatabaseWhere(row, input.where)) ?? null;
-			case "bundle_installations": return [...snapshot.bundleInstallations.values()].find((row) => matchesFirebaseDatabaseWhere(row, input.where)) ?? null;
-		}
-	},
-	async findMany(input) {
-		switch (input.model) {
-			case "bundles": return queryFirebaseDatabaseRows([...snapshot.bundles.values()], input);
-			case "bundle_patches": return queryFirebaseDatabaseRows([...snapshot.bundlePatches.values()], input);
-			case "bundle_events": return queryFirebaseDatabaseRows([...snapshot.bundleEvents.values()], input);
-			case "bundle_installations": return queryFirebaseDatabaseRows([...snapshot.bundleInstallations.values()], input);
-			case "channels": return queryFirebaseDatabaseRows([...snapshot.channels.values()], input);
-			case "api_keys": return queryFirebaseDatabaseRows([...snapshot.apiKeys.values()], input);
-			case "releases": return queryFirebaseDatabaseRows([...snapshot.releases.values()], input);
-			case "release_catalogs": return queryFirebaseDatabaseRows([...snapshot.releaseCatalogs.values()], input);
-		}
-	}
-});
-//#endregion
+import { apiKeys } from "@hot-updater/server/plugins/api-keys";
+import { insights } from "@hot-updater/server/plugins/insights";
 //#region src/firebaseInfrastructureNames.ts
-const FIREBASE_V1_COLLECTION_NAMES = {
-	apiKeys: "hot_updater_v1_api_keys",
-	bundleEvents: "hot_updater_v1_bundle_events",
-	bundleInstallations: "hot_updater_v1_bundle_installations",
-	bundlePatches: "hot_updater_v1_bundle_patches",
-	bundles: "hot_updater_v1_bundles",
-	channels: "hot_updater_v1_channels",
-	releaseCatalogs: "hot_updater_v1_release_catalogs",
-	releases: "hot_updater_v1_releases",
-	settings: "hot_updater_v1_private_settings"
-};
+/**
+* The one collection the storage engine keeps every item in. It namespaces
+* the data, so item partitions are table names with no prefix.
+*/
+const FIREBASE_V1_COLLECTION = "hot_updater_v1";
 //#endregion
-//#region src/firebaseDatabasePersistence.ts
-var FirebaseDatabaseAdapterVersionError = class extends Error {
-	version;
-	name = "FirebaseDatabaseAdapterVersionError";
-	constructor(version) {
-		super(`Unsupported Firebase database adapter version: ${String(version)}`);
-		this.version = version;
+//#region src/firestoreStore.ts
+/**
+* Firestore's limits: 10 MiB a request and 1 MiB a document; 500 writes a
+* transaction stays a conservative bound. Indexed values over 1,500 bytes are
+* truncated, so longer keys are refused rather than read inconsistently.
+*/
+const FIRESTORE_LIMITS = {
+	items: 500,
+	bytes: 1e7,
+	itemBytes: 1e6,
+	keyBytes: {
+		pk: 1500,
+		sk: 1500
 	}
 };
-const createFirebaseDatabaseCollections = (db) => ({
-	bundles: db.collection(FIREBASE_V1_COLLECTION_NAMES.bundles),
-	bundlePatches: db.collection(FIREBASE_V1_COLLECTION_NAMES.bundlePatches),
-	bundleEvents: db.collection(FIREBASE_V1_COLLECTION_NAMES.bundleEvents),
-	bundleInstallations: db.collection(FIREBASE_V1_COLLECTION_NAMES.bundleInstallations),
-	channels: db.collection(FIREBASE_V1_COLLECTION_NAMES.channels),
-	apiKeys: db.collection(FIREBASE_V1_COLLECTION_NAMES.apiKeys),
-	releaseCatalogs: db.collection(FIREBASE_V1_COLLECTION_NAMES.releaseCatalogs),
-	releases: db.collection(FIREBASE_V1_COLLECTION_NAMES.releases),
-	settings: db.collection(FIREBASE_V1_COLLECTION_NAMES.settings)
+/** `getAll` reads at most this many documents a call. */
+const GET_BATCH = 300;
+/** A document's id: a hash of its key, since keys may hold `/` and outgrow Firestore's 1,500 bytes. */
+const firestoreDocumentId = ({ pk, sk }) => createHash("sha256").update(JSON.stringify([pk, sk])).digest("hex");
+/**
+* A document is `{ pk, sk, row }`. Row values that are maps or arrays become
+* JSON text inside a map, since Firestore has no nested arrays and does not
+* keep map key order; `row` is exempt from single-field indexing.
+*/
+const encode = (value) => value !== null && typeof value === "object" ? { json: JSON.stringify(value) } : value;
+const decode = (value) => value !== null && typeof value === "object" && "json" in value ? JSON.parse(String(value.json)) : value;
+/**
+* The collection's TTL field: a timestamp beside `pk` and `sk` on every item
+* of a row that expires, which Firestore's TTL policy deletes.
+*/
+const FIRESTORE_TTL_FIELD = "expireAt";
+const toDocument = (key, row, expiresAt) => ({
+	pk: key.pk,
+	sk: key.sk,
+	row: Object.fromEntries(Object.entries(row).map(([name, value]) => [name, encode(value)])),
+	...expiresAt === void 0 ? {} : { [FIRESTORE_TTL_FIELD]: Timestamp.fromMillis(expiresAt) }
 });
-const firebaseChannelDocumentId = (name) => `name_${Buffer.from(name, "utf8").toString("base64url")}`;
-const firebaseChannelIdDocumentId = (id) => `channel_id_${Buffer.from(id, "utf8").toString("base64url")}`;
-const firebaseInstallationDocumentId = (id) => `install_${Buffer.from(id, "utf8").toString("base64url")}`;
-const requireFirebaseDocumentKey = (model, documentId, row) => {
-	if (documentId !== (model === "bundle_installations" ? firebaseInstallationDocumentId(row.install_id) : "id" in row ? row.id : row.scope_key)) throw new FirebaseDatabaseConstraintError(`${model}.id.document-key`);
-	return row;
-};
-const documentMap = (model, documents) => {
-	const rows = /* @__PURE__ */ new Map();
-	for (const { row } of documents) {
-		const key = model === "bundle_installations" ? row.install_id : "id" in row ? row.id : row.scope_key;
-		if (rows.has(key)) throw new FirebaseDatabaseConstraintError(`${model}.id.unique`);
-		rows.set(key, row);
-	}
-	for (const { document, row } of documents) requireFirebaseDocumentKey(model, document.id, row);
-	return rows;
-};
-const bundleMap = (snapshot) => documentMap("bundles", snapshot.docs.map((document) => ({
-	document,
-	row: parseFirebaseBundleRow(document.data(), `bundles/${document.id}`)
-})));
-const patchMap = (snapshot) => documentMap("bundle_patches", snapshot.docs.map((document) => ({
-	document,
-	row: parseFirebasePatchRow(document.data(), `bundle_patches/${document.id}`)
-})));
-const channelMap = (snapshot) => {
-	const rows = /* @__PURE__ */ new Map();
-	const names = /* @__PURE__ */ new Set();
-	for (const document of snapshot.docs) {
-		const row = parseFirebaseChannelRow(document.data(), `channels/${document.id}`);
-		if (document.id !== firebaseChannelDocumentId(row.name)) throw new FirebaseDatabaseConstraintError("channels.name.document-key");
-		if (rows.has(row.id)) throw new FirebaseDatabaseConstraintError("channels.id.unique");
-		if (names.has(row.name)) throw new FirebaseDatabaseConstraintError("channels.name.unique");
-		rows.set(row.id, row);
-		names.add(row.name);
-	}
-	return rows;
-};
-const loadFirebaseChannels = async (collections) => [...channelMap(await collections.channels.get()).values()];
-const apiKeyMap = (snapshot) => documentMap("api_keys", snapshot.docs.map((document) => ({
-	document,
-	row: parseFirebaseApiKeyRow(document.data(), `api_keys/${document.id}`)
-})));
-const releaseMap = (snapshot) => documentMap("releases", snapshot.docs.map((document) => ({
-	document,
-	row: parseFirebaseReleaseRow(document.data(), `releases/${document.id}`)
-})));
-const releaseCatalogMap = (snapshot) => documentMap("release_catalogs", snapshot.docs.map((document) => ({
-	document,
-	row: parseFirebaseReleaseCatalogRow(document.data(), `release_catalogs/${document.id}`)
-})));
-const toSnapshot = (documents) => {
+const toRow = (data) => Object.fromEntries(Object.entries(data.row ?? {}).map(([name, value]) => [name, decode(value)]));
+const holds = (snapshot, condition) => {
+	if (condition === void 0) return true;
+	const data = snapshot?.exists ? snapshot.data() : void 0;
+	return "v" in condition ? data !== void 0 && data.row?._v === condition.v : data !== void 0 === condition.exists;
+};
+/** gRPC codes a rerun of the whole write can clear: DEADLINE_EXCEEDED, RESOURCE_EXHAUSTED, ABORTED, INTERNAL, UNAVAILABLE. */
+const TRANSIENT = /* @__PURE__ */ new Set([
+	4,
+	8,
+	10,
+	13,
+	14
+]);
+const codeOf = (error) => error.code;
+/** Firestore reports a missing database as NOT_FOUND; it reads as a missing schema, like SQL's 42P01. */
+const missingDatabase = (error) => {
+	throw codeOf(error) === 5 ? Object.assign(new Error(error.message, { cause: error }), { code: "42P01" }) : error;
+};
+/**
+* The key-value store over one Firestore collection of `{ pk, sk, row }`
+* documents, queried through the composite indexes on (pk, sk) in both
+* directions. A write is one transaction that reads only the documents its
+* ops guard.
+*/
+const createFirestoreStore = ({ firestore, collection, nativePageSize }) => {
+	const items = firestore.collection(collection);
+	const reference = (key) => items.doc(firestoreDocumentId(key));
 	return {
-		bundles: bundleMap(documents[0]),
-		bundlePatches: patchMap(documents[1]),
-		bundleEvents: /* @__PURE__ */ new Map(),
-		bundleInstallations: /* @__PURE__ */ new Map(),
-		channels: channelMap(documents[2]),
-		apiKeys: apiKeyMap(documents[3]),
-		releases: releaseMap(documents[4]),
-		releaseCatalogs: releaseCatalogMap(documents[5])
-	};
-};
-const loadFirebaseDatabaseSnapshot = async (collections) => {
-	const [bundles, patches, channels, apiKeys, releases, releaseCatalogs] = await Promise.all([
-		collections.bundles.get(),
-		collections.bundlePatches.get(),
-		collections.channels.get(),
-		collections.apiKeys.get(),
-		collections.releases.get(),
-		collections.releaseCatalogs.get()
-	]);
-	return toSnapshot([
-		bundles,
-		patches,
-		channels,
-		apiKeys,
-		releases,
-		releaseCatalogs
-	]);
-};
-const loadFirebaseTransactionSnapshot = async (transaction, collections) => {
-	const [bundles, patches, channels, apiKeys, releases, releaseCatalogs] = await Promise.all([
-		transaction.get(collections.bundles),
-		transaction.get(collections.bundlePatches),
-		transaction.get(collections.channels),
-		transaction.get(collections.apiKeys),
-		transaction.get(collections.releases),
-		transaction.get(collections.releaseCatalogs)
-	]);
-	return toSnapshot([
-		bundles,
-		patches,
-		channels,
-		apiKeys,
-		releases,
-		releaseCatalogs
-	]);
-};
-const persistCollection = ({ transaction, collection, before, after, documentId }) => {
-	for (const [id, row] of before) if (!after.has(id)) transaction.delete(collection.doc(documentId(row)));
-	for (const [id, row] of after) if (JSON.stringify(before.get(id)) !== JSON.stringify(row)) transaction.set(collection.doc(documentId(row)), row, { merge: true });
-};
-const persistFirebaseDatabaseSnapshot = ({ transaction, collections, before, after }) => {
-	persistCollection({
-		transaction,
-		collection: collections.bundles,
-		before: before.bundles,
-		after: after.bundles,
-		documentId: (row) => row.id
-	});
-	persistCollection({
-		transaction,
-		collection: collections.bundlePatches,
-		before: before.bundlePatches,
-		after: after.bundlePatches,
-		documentId: (row) => row.id
-	});
-	persistCollection({
-		transaction,
-		collection: collections.channels,
-		before: before.channels,
-		after: after.channels,
-		documentId: (row) => firebaseChannelDocumentId(row.name)
-	});
-	for (const [id] of before.channels) if (!after.channels.has(id)) transaction.delete(collections.settings.doc(firebaseChannelIdDocumentId(id)));
-	for (const [id, row] of after.channels) if (JSON.stringify(before.channels.get(id)) !== JSON.stringify(row)) transaction.set(collections.settings.doc(firebaseChannelIdDocumentId(id)), row);
-	persistCollection({
-		transaction,
-		collection: collections.apiKeys,
-		before: before.apiKeys,
-		after: after.apiKeys,
-		documentId: (row) => row.id
-	});
-	persistCollection({
-		transaction,
-		collection: collections.releases,
-		before: before.releases,
-		after: after.releases,
-		documentId: (row) => row.id
-	});
-	persistCollection({
-		transaction,
-		collection: collections.releaseCatalogs,
-		before: before.releaseCatalogs,
-		after: after.releaseCatalogs,
-		documentId: (row) => row.scope_key
-	});
-};
-const migrateFirebaseDatabase = async (collections) => {
-	const versionDocument = collections.settings.doc("database_adapter_version");
-	const version = await versionDocument.get();
-	const adapterVersion = version.data()?.version;
-	if (adapterVersion === 4) return;
-	if (version.exists) throw new FirebaseDatabaseAdapterVersionError(adapterVersion);
-	if ((await Promise.all([
-		collections.bundles.limit(1).get(),
-		collections.bundlePatches.limit(1).get(),
-		collections.channels.limit(1).get(),
-		collections.releases.limit(1).get(),
-		collections.releaseCatalogs.limit(1).get(),
-		collections.bundleInstallations.limit(1).get(),
-		collections.bundleEvents.limit(1).get()
-	])).some((snapshot) => !snapshot.empty)) throw new FirebaseDatabaseAdapterVersionError("v0");
-	try {
-		await versionDocument.create({ version: 4 });
-	} catch (error) {
-		if ((await versionDocument.get()).data()?.version !== 4) throw error;
-	}
-};
-//#endregion
-//#region src/firebaseDatabase.ts
-const exactId = (input) => {
-	if (input.where?.length !== 1) return void 0;
-	const [condition] = input.where;
-	return condition.field === "id" && (condition.operator === void 0 || condition.operator === "eq") && typeof condition.value === "string" ? condition.value : void 0;
-};
-const exactInstallId = (input) => {
-	const condition = input.where?.find(({ field, operator }) => field === "install_id" && (operator === void 0 || operator === "eq"));
-	return typeof condition?.value === "string" ? condition.value : void 0;
-};
-const firestoreOperator = (operator) => {
-	switch (operator ?? "eq") {
-		case "eq": return "==";
-		case "ne": return "!=";
-		case "gt": return ">";
-		case "gte": return ">=";
-		case "lt": return "<";
-		case "lte": return "<=";
-		case "in": return "in";
-		case "not_in": return "not-in";
-		default: return;
-	}
-};
-const applyFirebaseWhere = (initial, where) => {
-	let query = initial;
-	for (const condition of where) {
-		const operator = firestoreOperator(condition.operator);
-		if (condition.connector === "OR" || operator === void 0) throw new FirebaseDatabaseConstraintError("query.unsupported");
-		query = query.where(condition.field, operator, condition.value);
-	}
-	return query;
-};
-const firebaseDatabase = (config) => {
-	const implementation = (() => {
-		const app = getApps().length ? getApp() : initializeApp(config);
-		const db = getFirestore(app);
-		const collections = createFirebaseDatabaseCollections(db);
-		let migration;
-		const ensureMigrated = () => {
-			migration ??= migrateFirebaseDatabase(collections).catch((error) => {
-				migration = void 0;
-				throw error;
-			});
-			return migration;
-		};
-		const mutate = async (operation) => {
-			await ensureMigrated();
-			return db.runTransaction(async (transaction) => {
-				const before = await loadFirebaseTransactionSnapshot(transaction, collections);
-				const after = cloneFirebaseDatabaseSnapshot(before);
-				const result = await operation(createFirebaseDatabaseState(after));
-				persistFirebaseDatabaseSnapshot({
-					transaction,
-					collections,
-					before,
-					after
-				});
-				return result;
-			});
-		};
-		const read = async (operation) => {
-			await ensureMigrated();
-			const snapshot = await loadFirebaseDatabaseSnapshot(collections);
-			return operation(createFirebaseDatabaseState(snapshot));
-		};
-		return {
-			recordInsights: async ({ event, installation }) => {
-				await ensureMigrated();
-				await db.runTransaction(async (transaction) => {
-					const eventReference = collections.bundleEvents.doc(event.id);
-					const installationReference = collections.bundleInstallations.doc(firebaseInstallationDocumentId(installation.install_id));
-					const [storedEvent, storedInstallation] = await transaction.getAll(eventReference, installationReference);
-					if (storedEvent.exists) return;
-					const current = storedInstallation.exists ? requireFirebaseDocumentKey("bundle_installations", storedInstallation.id, parseFirebaseInsightsInstallationRow(storedInstallation.data(), `bundle_installations/${storedInstallation.id}`)) : null;
-					transaction.create(eventReference, event);
-					if (current === null || installation.received_at_ms > current.received_at_ms || installation.received_at_ms === current.received_at_ms && compareInsightsText(installation.id, current.id) > 0) transaction.set(installationReference, installation);
-				});
-			},
-			create: async (input) => {
-				if (input.model !== "bundle_events" && input.model !== "bundle_installations") return mutate((database) => database.create(input));
-				await ensureMigrated();
-				return db.runTransaction(async (transaction) => {
-					const collection = input.model === "bundle_events" ? collections.bundleEvents : collections.bundleInstallations;
-					const documentId = input.model === "bundle_events" ? input.data.id : firebaseInstallationDocumentId(input.data.install_id);
-					const reference = collection.doc(documentId);
-					const document = await transaction.get(reference);
-					if (document.exists) {
-						const row = input.model === "bundle_events" ? requireFirebaseDocumentKey("bundle_events", document.id, parseFirebaseBundleEventRow(document.data(), `bundle_events/${document.id}`)) : requireFirebaseDocumentKey("bundle_installations", document.id, parseFirebaseInsightsInstallationRow(document.data(), `bundle_installations/${document.id}`));
-						if (input.onConflict === "ignore") return row;
-						throw new FirebaseDatabaseConstraintError(`${input.model}.id.unique`);
-					}
-					transaction.create(reference, input.data);
-					return input.data;
-				});
-			},
-			update: async (input) => {
-				if (input.model !== "bundle_installations") return mutate((database) => database.update(input));
-				const installId = exactInstallId(input);
-				if (installId === void 0) return mutate((database) => database.update(input));
-				await ensureMigrated();
-				return db.runTransaction(async (transaction) => {
-					const reference = collections.bundleInstallations.doc(firebaseInstallationDocumentId(installId));
-					const document = await transaction.get(reference);
-					if (!document.exists) return null;
-					const current = requireFirebaseDocumentKey("bundle_installations", document.id, parseFirebaseInsightsInstallationRow(document.data(), `bundle_installations/${document.id}`));
-					if (!matchesFirebaseDatabaseWhere(current, input.where)) return null;
-					const updated = {
-						...current,
-						...input.update
-					};
-					transaction.set(reference, updated, { merge: true });
-					return updated;
-				});
-			},
-			delete: (input) => mutate((database) => database.delete(input)),
-			count: async (input) => {
-				if (input.model !== "bundle_installations" && input.model !== "bundle_events") return read((database) => database.count(input));
-				await ensureMigrated();
-				let query = applyFirebaseWhere(input.model === "bundle_events" ? collections.bundleEvents : collections.bundleInstallations, input.where ?? []);
-				if (input.model === "bundle_events") query = query.orderBy("received_at_ms", "desc").orderBy("id", "desc");
-				return (await query.count().get()).data().count;
-			},
-			findOne: async (input) => {
-				if (input.model === "bundle_installations") {
-					const installId = exactInstallId(input);
-					if (installId === void 0) return read((database) => database.findOne(input));
-					await ensureMigrated();
-					const document = await collections.bundleInstallations.doc(firebaseInstallationDocumentId(installId)).get();
-					return document.exists ? requireFirebaseDocumentKey("bundle_installations", document.id, parseFirebaseInsightsInstallationRow(document.data(), `bundle_installations/${document.id}`)) : null;
+		id: "firestore",
+		limits: FIRESTORE_LIMITS,
+		async get(keys) {
+			const found = /* @__PURE__ */ new Map();
+			const ids = [...new Set(keys.map(firestoreDocumentId))];
+			for (let at = 0; at < ids.length; at += GET_BATCH) {
+				const snapshots = await firestore.getAll(...ids.slice(at, at + GET_BATCH).map((id) => items.doc(id))).catch(missingDatabase);
+				for (const snapshot of snapshots) if (snapshot.exists) found.set(snapshot.id, toRow(snapshot.data()));
+			}
+			return keys.map((key) => found.get(firestoreDocumentId(key)) ?? null);
+		},
+		async query({ pk, gte, lt, order, limit, after }) {
+			let query = items.where("pk", "==", pk);
+			if (gte !== void 0) query = query.where("sk", ">=", gte);
+			if (lt !== void 0) query = query.where("sk", "<", lt);
+			query = query.orderBy("sk", order);
+			if (after !== void 0) query = query.startAfter(after);
+			const size = Math.min(limit, nativePageSize ?? limit);
+			const { docs } = await query.limit(size).get().catch(missingDatabase);
+			return {
+				items: docs.map((document) => ({
+					sk: document.get("sk"),
+					value: toRow(document.data())
+				})),
+				more: docs.length === size
+			};
+		},
+		async write(ops) {
+			const blind = ops.map((op) => op.type === "add" && (op.condition === void 0 || "exists" in op.condition && op.condition.exists));
+			const attempt = (reading) => firestore.runTransaction(async (transaction) => {
+				const read = ops.flatMap((op, position) => (op.condition !== void 0 || op.type === "add") && (reading || !blind[position]) ? [position] : []);
+				const snapshots = /* @__PURE__ */ new Map();
+				if (read.length > 0) {
+					const found = await transaction.getAll(...read.map((position) => reference(ops[position].key)));
+					read.forEach((position, at) => snapshots.set(position, found[at]));
 				}
-				const id = exactId(input);
-				if (id === void 0) return read((database) => database.findOne(input));
-				await ensureMigrated();
-				switch (input.model) {
-					case "bundles": {
-						const document = await collections.bundles.doc(id).get();
-						return document.exists ? requireFirebaseDocumentKey("bundles", document.id, parseFirebaseBundleRow(document.data(), `bundles/${document.id}`)) : null;
-					}
-					case "bundle_patches": {
-						const document = await collections.bundlePatches.doc(id).get();
-						return document.exists ? requireFirebaseDocumentKey("bundle_patches", document.id, parseFirebasePatchRow(document.data(), `bundle_patches/${document.id}`)) : null;
-					}
-					case "api_keys": {
-						const document = await collections.apiKeys.doc(id).get();
-						return document.exists ? requireFirebaseDocumentKey("api_keys", document.id, parseFirebaseApiKeyRow(document.data(), `api_keys/${document.id}`)) : null;
-					}
-					default: return read((database) => database.findOne(input));
+				const failed = read.find((position) => !holds(snapshots.get(position), ops[position].condition));
+				if (failed !== void 0) {
+					if (!reading && blind.slice(0, failed).includes(true)) return null;
+					return {
+						ok: false,
+						failedOp: failed
+					};
 				}
-			},
-			findMany: async (input) => {
-				if (input.model === "bundle_events" || input.model === "bundle_installations") {
-					await ensureMigrated();
-					const collection = input.model === "bundle_events" ? collections.bundleEvents : collections.bundleInstallations;
-					let query = applyFirebaseWhere(collection, input.where ?? []);
-					for (const order of input.orderBy ?? []) {
-						if (order.nulls !== void 0) throw new FirebaseDatabaseConstraintError("query.unsupported");
-						query = query.orderBy(order.field, order.direction);
+				for (const [position, op] of ops.entries()) {
+					const document = reference(op.key);
+					if (op.type === "put") transaction.set(document, toDocument(op.key, op.value, op.expiresAt));
+					else if (op.type === "delete") transaction.delete(document);
+					else if (op.type === "add") {
+						if (snapshots.get(position)?.exists === false) {
+							const created = { ...op.init };
+							for (const [name, delta] of Object.entries(op.by)) created[name] = Number(created[name] ?? 0) + delta;
+							transaction.set(document, toDocument(op.key, created, op.expiresAt));
+						} else {
+							const [[name, delta], ...more] = Object.entries(op.by);
+							const ttl = op.expiresAt === void 0 ? [] : [FIRESTORE_TTL_FIELD, Timestamp.fromMillis(op.expiresAt)];
+							transaction.update(document, new FieldPath("row", name), FieldValue.increment(delta), ...more.flatMap(([other, by]) => [new FieldPath("row", other), FieldValue.increment(by)]), ...ttl);
+						}
 					}
-					return (await query.offset(input.offset).limit(input.limit).get()).docs.map((document) => input.model === "bundle_events" ? requireFirebaseDocumentKey("bundle_events", document.id, parseFirebaseBundleEventRow(document.data(), `bundle_events/${document.id}`)) : requireFirebaseDocumentKey("bundle_installations", document.id, parseFirebaseInsightsInstallationRow(document.data(), `bundle_installations/${document.id}`)));
 				}
-				if (input.model === "channels") {
-					await ensureMigrated();
-					return queryFirebaseDatabaseRows(await loadFirebaseChannels(collections), input);
+				return { ok: true };
+			}, { maxAttempts: 5 });
+			try {
+				try {
+					const result = await attempt(false);
+					if (result !== null) return result;
+				} catch (error) {
+					if (codeOf(error) !== 5 || !blind.includes(true)) throw error;
 				}
-				return read((database) => database.findMany(input));
-			},
-			insertChannel: async (input) => {
-				await ensureMigrated();
-				return db.runTransaction(async (transaction) => {
-					const reference = collections.channels.doc(firebaseChannelDocumentId(input.row.name));
-					const idReference = collections.settings.doc(firebaseChannelIdDocumentId(input.row.id));
-					const [document, idDocument] = await transaction.getAll(reference, idReference);
-					if (idDocument.exists) {
-						const row = parseFirebaseChannelRow(idDocument.data(), `${FIREBASE_V1_COLLECTION_NAMES.settings}/${idDocument.id}`);
-						if (row.id !== input.row.id || row.name !== input.row.name) throw new FirebaseDatabaseConstraintError("channels.id.registry");
-					}
-					if (idDocument.exists && !document.exists) throw new FirebaseDatabaseConstraintError("channels.id.unique");
-					if (document.exists) {
-						const row = parseFirebaseChannelRow(document.data(), `channels/${document.id}`);
-						if (document.id !== firebaseChannelDocumentId(row.name)) throw new FirebaseDatabaseConstraintError("channels.name.document-key");
-						return {
-							row,
-							inserted: false
-						};
-					}
-					transaction.create(reference, input.row);
-					transaction.create(idReference, input.row);
-					return {
-						row: input.row,
-						inserted: true
-					};
-				});
-			},
-			deleteChannel: async ({ id }) => {
-				await ensureMigrated();
-				return db.runTransaction(async (transaction) => {
-					const idReference = collections.settings.doc(firebaseChannelIdDocumentId(id));
-					const idDocument = await transaction.get(idReference);
-					if (!idDocument.exists) return {
-						deleted: false,
-						reason: "not_found"
-					};
-					const row = parseFirebaseChannelRow(idDocument.data(), `${FIREBASE_V1_COLLECTION_NAMES.settings}/${idDocument.id}`);
-					const reference = collections.channels.doc(firebaseChannelDocumentId(row.name));
-					if (!(await transaction.get(reference)).exists || row.id !== id) throw new FirebaseDatabaseConstraintError("channels.id.registry");
-					if (!(await transaction.get(collections.releases.where("channel_id", "==", id).limit(1))).empty) return {
-						deleted: false,
-						reason: "not_empty"
-					};
-					transaction.delete(reference);
-					transaction.delete(idReference);
-					return { deleted: true };
-				});
-			},
-			transaction: (callback) => mutate(callback)
-		};
-	})();
-	const adapter = createDatabasePluginAdapter("firebaseDatabase", implementation);
-	return createDatabasePlugin({
-		name: "firebaseDatabase",
-		models: adapter.models,
-		commit: adapter.commit
-	});
+				return await attempt(true);
+			} catch (error) {
+				if (TRANSIENT.has(codeOf(error))) return {
+					ok: false,
+					retry: true
+				};
+				return missingDatabase(error);
+			}
+		},
+		/** A plain batch, which reads nothing, 500 deletes at a time. */
+		async deleteConsumed(keys) {
+			for (let at = 0; at < keys.length; at += FIRESTORE_LIMITS.items) {
+				const batch = firestore.batch();
+				for (const key of keys.slice(at, at + FIRESTORE_LIMITS.items)) batch.delete(reference(key));
+				await batch.commit().catch(missingDatabase);
+			}
+		},
+		async dispose() {}
+	};
 };
 //#endregion
+//#region src/firebaseDatabase.ts
+const adapterOf = ({ collection = FIREBASE_V1_COLLECTION, aggregateBatching: _, ...appOptions }) => {
+	const app = getApps().length ? getApp() : initializeApp(appOptions);
+	return createKvAdapter({ store: createFirestoreStore({
+		firestore: getFirestore(app),
+		collection
+	}) });
+};
+/**
+* Writes the schema settings of core and `plugins`, the plugins the server
+* runs, which the database checks before its first read. Firestore needs no
+* other setup beyond `firestore.indexes.json`; `hot-updater init` runs it
+* after deploying the indexes.
+*/
+const migrateFirebaseDatabase = (config, plugins = []) => migrateCoreSchema(adapterOf(config), "firebaseDatabase", plugins);
+/** Hot Updater's database in one Firestore collection, through the storage engine. */
+const firebaseDatabase = (config) => createEngineDatabase({
+	name: "firebaseDatabase",
+	adapter: adapterOf(config),
+	aggregateBatching: config.aggregateBatching ?? {}
+});
+//#endregion
 //#region src/firebaseStorage.ts
 const firebaseStorage = (config) => {
 	const app = getApps().length ? getApp() : initializeApp(config);
@@ -922,7 +200,7 @@ const firebaseStorage = (config) => {
 		if (parsed.bucket !== config.storageBucket) throw new Error(`Bucket name mismatch: expected "${config.storageBucket}", but found "${parsed.bucket}".`);
 		return parsed;
 	};
-	return createStoragePlugin({
+	return createStorageAdapter({
 		name: "firebaseStorage",
 		protocol: "gs",
 		async put({ key, body, contentType }) {
@@ -982,4 +260,11 @@ const firebaseStorage = (config) => {
 	});
 };
 //#endregion
-export { firebaseDatabase, firebaseStorage };
+//#region src/plugins.ts
+/**
+* The plugins the managed Firebase server runs: Insights, and API keys on every
+* client route. Its Cloud Function imports this list.
+*/
+const plugins = [insights(), apiKeys()];
+//#endregion
+export { firebaseDatabase, firebaseStorage, migrateFirebaseDatabase, plugins };