@hot-updater/firebase 0.36.7 → 1.0.0-rc.1

package/dist/index.mjs

@@ -1,345 +1,845 @@
-import { DEFAULT_ROLLOUT_COHORT_COUNT, NIL_UUID, getAssetBaseStorageUri, getBundlePatches, getManifestFileHash, getManifestStorageUri, getPatchBaseBundleId, getPatchBaseFileHash, getPatchFileHash, getPatchStorageUri, stripBundleArtifactMetadata } from "@hot-updater/core";
-import { calculatePagination, createDatabasePlugin, createStorageKeyBuilder, createUniversalStoragePlugin, filterCompatibleAppVersions, getContentType, parseStorageUri, resolveUpdateInfoFromBundles } from "@hot-updater/plugin-core";
+import { createDatabasePlugin, createStorageKeyBuilder, createStoragePlugin, createStorageUri, isDatabaseMetadataObject, parseStorageUri } from "@hot-updater/plugin-core";
+import { createDatabasePluginAdapter } from "@hot-updater/plugin-core/internal";
 import { getApp, getApps, initializeApp } from "firebase-admin/app";
 import { getFirestore } from "firebase-admin/firestore";
-import fs from "fs/promises";
-import path from "path";
 import { getStorage } from "firebase-admin/storage";
-//#region src/firebaseDatabase.ts
-const bundleMatchesQueryWhere = (bundle, where) => {
-	if (!where) return true;
-	if (where.channel !== void 0 && bundle.channel !== where.channel) return false;
-	if (where.platform !== void 0 && bundle.platform !== where.platform) return false;
-	if (where.enabled !== void 0 && bundle.enabled !== where.enabled) return false;
-	if (where.id?.eq !== void 0 && bundle.id !== where.id.eq) return false;
-	if (where.id?.gt !== void 0 && bundle.id.localeCompare(where.id.gt) <= 0) return false;
-	if (where.id?.gte !== void 0 && bundle.id.localeCompare(where.id.gte) < 0) return false;
-	if (where.id?.lt !== void 0 && bundle.id.localeCompare(where.id.lt) >= 0) return false;
-	if (where.id?.lte !== void 0 && bundle.id.localeCompare(where.id.lte) > 0) return false;
-	if (where.id?.in && !where.id.in.includes(bundle.id)) return false;
-	if (where.targetAppVersionNotNull && bundle.targetAppVersion === null) return false;
-	if (where.targetAppVersion !== void 0 && bundle.targetAppVersion !== where.targetAppVersion) return false;
-	if (where.targetAppVersionIn && !where.targetAppVersionIn.includes(bundle.targetAppVersion ?? "")) return false;
-	if (where.fingerprintHash !== void 0 && bundle.fingerprintHash !== where.fingerprintHash) return false;
-	return true;
-};
-const sortBundles = (bundles, orderBy) => {
-	const direction = orderBy?.direction ?? "desc";
-	return bundles.slice().sort((a, b) => {
-		const result = a.id.localeCompare(b.id);
-		return direction === "asc" ? result : -result;
-	});
+//#region src/firebaseDatabaseParserShared.ts
+var FirebaseDatabaseDataError = class extends Error {
+	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 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 applyFirestoreQueryableFilters = (query, where) => {
-	let nextQuery = query;
-	if (where?.channel) nextQuery = nextQuery.where("channel", "==", where.channel);
-	if (where?.platform) nextQuery = nextQuery.where("platform", "==", where.platform);
-	if (where?.enabled !== void 0) nextQuery = nextQuery.where("enabled", "==", where.enabled);
-	if (where?.fingerprintHash !== void 0 && where.fingerprintHash !== null) nextQuery = nextQuery.where("fingerprint_hash", "==", where.fingerprintHash);
-	if (where?.targetAppVersion !== void 0 && where.targetAppVersion !== null) nextQuery = nextQuery.where("target_app_version", "==", where.targetAppVersion);
-	if (where?.id?.eq) nextQuery = nextQuery.where("id", "==", where.id.eq);
-	if (where?.id?.gt) nextQuery = nextQuery.where("id", ">", where.id.gt);
-	if (where?.id?.gte) nextQuery = nextQuery.where("id", ">=", where.id.gte);
-	if (where?.id?.lt) nextQuery = nextQuery.where("id", "<", where.id.lt);
-	if (where?.id?.lte) nextQuery = nextQuery.where("id", "<=", where.id.lte);
-	return nextQuery;
-};
-const requiresInMemoryFiltering = (where) => {
-	return Boolean(where?.id?.in || where?.targetAppVersionIn || where?.targetAppVersionNotNull || where?.targetAppVersion === null || where?.fingerprintHash === null);
-};
-const chunkValues = (values, size) => {
-	const chunks = [];
-	for (let index = 0; index < values.length; index += size) chunks.push(values.slice(index, index + size));
-	return chunks;
-};
-const convertToBundle = (firestoreData) => {
-	const rawMetadata = firestoreData.metadata;
-	const storedPatches = firestoreData.patches;
-	const patches = storedPatches && Array.isArray(storedPatches) ? storedPatches : getBundlePatches({
-		metadata: rawMetadata,
-		patchBaseBundleId: firestoreData.patch_base_bundle_id ?? null,
-		patchBaseFileHash: firestoreData.patch_base_file_hash ?? null,
-		patchFileHash: firestoreData.patch_file_hash ?? null,
-		patchStorageUri: firestoreData.patch_storage_uri ?? null
+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 comparison = normalizeStringComparison(actual, expected, "mode" in condition ? condition.mode : void 0);
+			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 comparison = normalizeStringComparison(actual, expected, "mode" in condition ? condition.mode : void 0);
+			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 comparison = normalizeStringComparison(actual, expected, "mode" in condition ? condition.mode : void 0);
+			return comparison?.[0].includes(comparison[1]) ?? false;
+		}
+		case "starts_with": {
+			if (typeof expected !== "string") return false;
+			const comparison = normalizeStringComparison(actual, expected, "mode" in condition ? condition.mode : void 0);
+			return comparison?.[0].startsWith(comparison[1]) ?? false;
+		}
+		case "ends_with": {
+			if (typeof expected !== "string") return false;
+			const comparison = normalizeStringComparison(actual, expected, "mode" in condition ? condition.mode : void 0);
+			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 primaryPatch = patches[0] ?? null;
+	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 {
+	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),
+	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 "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 === "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);
+		}
+	},
+	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;
+		}
+	},
+	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 "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
+//#region src/firebaseInfrastructureNames.ts
+const FIREBASE_V1_COLLECTION_NAMES = {
+	apiKeys: "hot_updater_v1_api_keys",
+	bundleEvents: "hot_updater_v1_bundle_events",
+	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"
+};
+//#endregion
+//#region src/firebaseDatabasePersistence.ts
+var FirebaseDatabaseAdapterVersionError = class extends Error {
+	name = "FirebaseDatabaseAdapterVersionError";
+	constructor(version) {
+		super(`Unsupported Firebase database adapter version: ${String(version)}`);
+		this.version = version;
+	}
+};
+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),
+	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)
+});
+const firebaseChannelDocumentId = (name) => `name_${Buffer.from(name, "utf8").toString("base64url")}`;
+const firebaseChannelIdDocumentId = (id) => `channel_id_${Buffer.from(id, "utf8").toString("base64url")}`;
+const requireFirebaseDocumentKey = (model, documentId, row) => {
+	if (documentId !== ("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 = "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 eventMap = (snapshot) => documentMap("bundle_events", snapshot.docs.map((document) => ({
+	document,
+	row: parseFirebaseBundleEventRow(document.data(), `bundle_events/${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) => {
 	return {
-		channel: firestoreData.channel,
-		enabled: Boolean(firestoreData.enabled),
-		shouldForceUpdate: Boolean(firestoreData.should_force_update),
-		fileHash: firestoreData.file_hash,
-		gitCommitHash: firestoreData.git_commit_hash,
-		id: firestoreData.id,
-		message: firestoreData.message,
-		platform: firestoreData.platform,
-		targetAppVersion: firestoreData.target_app_version,
-		storageUri: firestoreData.storage_uri,
-		fingerprintHash: firestoreData.fingerprint_hash,
-		metadata: stripBundleArtifactMetadata(rawMetadata),
-		manifestStorageUri: firestoreData.manifest_storage_uri ?? null,
-		manifestFileHash: firestoreData.manifest_file_hash ?? null,
-		assetBaseStorageUri: firestoreData.asset_base_storage_uri ?? null,
-		patches,
-		patchBaseBundleId: primaryPatch?.baseBundleId ?? firestoreData.patch_base_bundle_id ?? null,
-		patchBaseFileHash: primaryPatch?.baseFileHash ?? firestoreData.patch_base_file_hash ?? null,
-		patchFileHash: primaryPatch?.patchFileHash ?? firestoreData.patch_file_hash ?? null,
-		patchStorageUri: primaryPatch?.patchStorageUri ?? firestoreData.patch_storage_uri ?? null,
-		rolloutCohortCount: firestoreData.rollout_cohort_count ?? DEFAULT_ROLLOUT_COHORT_COUNT,
-		targetCohorts: firestoreData.target_cohorts ?? null
+		bundles: bundleMap(documents[0]),
+		bundlePatches: patchMap(documents[1]),
+		bundleEvents: eventMap(documents[2]),
+		channels: channelMap(documents[3]),
+		apiKeys: apiKeyMap(documents[4]),
+		releases: releaseMap(documents[5]),
+		releaseCatalogs: releaseCatalogMap(documents[6])
 	};
 };
-const firebaseDatabase = createDatabasePlugin({
-	name: "firebaseDatabase",
-	factory: (config) => {
+const loadFirebaseDatabaseSnapshot = async (collections) => {
+	const [bundles, patches, events, channels, apiKeys, releases, releaseCatalogs] = await Promise.all([
+		collections.bundles.get(),
+		collections.bundlePatches.get(),
+		collections.bundleEvents.get(),
+		collections.channels.get(),
+		collections.apiKeys.get(),
+		collections.releases.get(),
+		collections.releaseCatalogs.get()
+	]);
+	return toSnapshot([
+		bundles,
+		patches,
+		events,
+		channels,
+		apiKeys,
+		releases,
+		releaseCatalogs
+	]);
+};
+const loadFirebaseTransactionSnapshot = async (transaction, collections) => {
+	const [bundles, patches, events, channels, apiKeys, releases, releaseCatalogs] = await Promise.all([
+		transaction.get(collections.bundles),
+		transaction.get(collections.bundlePatches),
+		transaction.get(collections.bundleEvents),
+		transaction.get(collections.channels),
+		transaction.get(collections.apiKeys),
+		transaction.get(collections.releases),
+		transaction.get(collections.releaseCatalogs)
+	]);
+	return toSnapshot([
+		bundles,
+		patches,
+		events,
+		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.bundleEvents,
+		before: before.bundleEvents,
+		after: after.bundleEvents,
+		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 (_db, 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()
+	])).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 firebaseDatabase = (config) => {
+	const adapter = createDatabasePluginAdapter("firebaseDatabase", (() => {
 		const db = getFirestore(getApps().length ? getApp() : initializeApp(config));
-		const bundlesCollection = db.collection("bundles");
-		const targetAppVersionsCollection = db.collection("target_app_versions");
+		const collections = createFirebaseDatabaseCollections(db);
+		let migration;
+		const ensureMigrated = () => {
+			migration ??= migrateFirebaseDatabase(db, 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();
+			return operation(createFirebaseDatabaseState(await loadFirebaseDatabaseSnapshot(collections)));
+		};
 		return {
-			async getUpdateInfo(args, context) {
-				const channel = args.channel ?? "production";
-				const minBundleId = args.minBundleId ?? NIL_UUID;
-				if (args._updateStrategy === "appVersion") {
-					const querySnapshot = await targetAppVersionsCollection.where("platform", "==", args.platform).where("channel", "==", channel).select("target_app_version").get();
-					const compatibleAppVersions = filterCompatibleAppVersions(Array.from(new Set(querySnapshot.docs.map((doc) => doc.data().target_app_version).filter((version) => Boolean(version)))), args.appVersion);
-					const bundles = (compatibleAppVersions.length > 0 ? await Promise.all(chunkValues(compatibleAppVersions, 10).map((versions) => bundlesCollection.where("platform", "==", args.platform).where("channel", "==", channel).where("enabled", "==", true).where("id", ">=", minBundleId).where("target_app_version", "in", versions).get())) : []).flatMap((snapshot) => snapshot.docs.map((doc) => convertToBundle(doc.data())));
-					return resolveUpdateInfoFromBundles({
-						args: {
-							...args,
-							channel,
-							minBundleId
-						},
-						bundles,
-						context
-					});
+			create: (input) => mutate((database) => database.create(input)),
+			update: (input) => mutate((database) => database.update(input)),
+			delete: (input) => mutate((database) => database.delete(input)),
+			count: (input) => read((database) => database.count(input)),
+			findOne: async (input) => {
+				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 bundles = (await bundlesCollection.where("platform", "==", args.platform).where("channel", "==", channel).where("enabled", "==", true).where("id", ">=", minBundleId).where("fingerprint_hash", "==", args.fingerprintHash).get()).docs.map((doc) => convertToBundle(doc.data()));
-				return resolveUpdateInfoFromBundles({
-					args: {
-						...args,
-						channel,
-						minBundleId
-					},
-					bundles,
-					context
-				});
 			},
-			async getBundleById(bundleId) {
-				const bundleSnap = await bundlesCollection.doc(bundleId).get();
-				if (!bundleSnap.exists) return null;
-				return convertToBundle(bundleSnap.data());
+			findMany: async (input) => {
+				if (input.model !== "channels") return read((database) => database.findMany(input));
+				await ensureMigrated();
+				return queryFirebaseDatabaseRows(await loadFirebaseChannels(collections), input);
 			},
-			async getBundles(options) {
-				const { where, limit, orderBy } = options;
-				const offset = ("offset" in options ? options.offset : void 0) ?? 0;
-				let query = applyFirestoreQueryableFilters(bundlesCollection, where);
-				query = query.orderBy("id", orderBy?.direction === "asc" ? "asc" : "desc");
-				if (requiresInMemoryFiltering(where)) {
-					const filteredBundles = sortBundles((await query.get()).docs.map((doc) => convertToBundle(doc.data())).filter((bundle) => bundleMatchesQueryWhere(bundle, where)), orderBy);
-					const total = filteredBundles.length;
+			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 {
-						data: filteredBundles.slice(offset, offset + limit),
-						pagination: calculatePagination(total, {
-							limit,
-							offset
-						})
+						row: input.row,
+						inserted: true
 					};
-				}
-				const total = (await query.get()).size;
-				if (offset > 0) query = query.offset(offset);
-				if (limit) query = query.limit(limit);
-				return {
-					data: sortBundles((await query.get()).docs.map((doc) => convertToBundle(doc.data())), orderBy),
-					pagination: calculatePagination(total, {
-						limit,
-						offset
-					})
-				};
-			},
-			async getChannels() {
-				const querySnapshot = await db.collection("channels").get();
-				if (querySnapshot.empty) return [];
-				const channels = /* @__PURE__ */ new Set();
-				for (const doc of querySnapshot.docs) {
-					const data = doc.data();
-					if (data.name) channels.add(data.name);
-				}
-				return Array.from(channels);
+				});
 			},
-			async commitBundle({ changedSets }) {
-				if (changedSets.length === 0) return;
-				let isTargetAppVersionChanged = false;
-				await db.runTransaction(async (transaction) => {
-					const bundlesSnapshot = await transaction.get(bundlesCollection);
-					const targetVersionsSnapshot = await transaction.get(db.collection("target_app_versions"));
-					const channelsSnapshot = await transaction.get(db.collection("channels"));
-					const bundlesMap = {};
-					for (const doc of bundlesSnapshot.docs) bundlesMap[doc.id] = doc.data();
-					for (const { operation, data } of changedSets) {
-						if (data.targetAppVersion) isTargetAppVersionChanged = true;
-						if (operation === "insert" || operation === "update") {
-							bundlesMap[data.id] = {
-								id: data.id,
-								channel: data.channel,
-								enabled: data.enabled,
-								should_force_update: data.shouldForceUpdate,
-								file_hash: data.fileHash,
-								git_commit_hash: data.gitCommitHash || null,
-								message: data.message || null,
-								platform: data.platform,
-								target_app_version: data.targetAppVersion,
-								storage_uri: data.storageUri,
-								fingerprint_hash: data.fingerprintHash,
-								metadata: stripBundleArtifactMetadata(data.metadata) ?? {},
-								manifest_storage_uri: getManifestStorageUri(data),
-								manifest_file_hash: getManifestFileHash(data),
-								asset_base_storage_uri: getAssetBaseStorageUri(data),
-								patches: data.patches ?? null,
-								patch_base_bundle_id: getPatchBaseBundleId(data),
-								patch_base_file_hash: getPatchBaseFileHash(data),
-								patch_file_hash: getPatchFileHash(data),
-								patch_storage_uri: getPatchStorageUri(data),
-								rollout_cohort_count: data.rolloutCohortCount ?? DEFAULT_ROLLOUT_COHORT_COUNT,
-								target_cohorts: data.targetCohorts ?? null
-							};
-							const channelRef = db.collection("channels").doc(data.channel);
-							transaction.set(channelRef, { name: data.channel }, { merge: true });
-						} else if (operation === "delete") {
-							if (!bundlesMap[data.id]) throw new Error(`Bundle with id ${data.id} not found`);
-							delete bundlesMap[data.id];
-							isTargetAppVersionChanged = true;
-						}
-					}
-					const requiredTargetVersionKeys = /* @__PURE__ */ new Set();
-					const requiredChannels = /* @__PURE__ */ new Set();
-					for (const bundle of Object.values(bundlesMap)) {
-						if (bundle.target_app_version) {
-							const key = `${bundle.platform}_${bundle.channel}_${bundle.target_app_version}`;
-							requiredTargetVersionKeys.add(key);
-						}
-						requiredChannels.add(bundle.channel);
-					}
-					for (const { operation, data } of changedSets) {
-						const bundleRef = bundlesCollection.doc(data.id);
-						if (operation === "insert" || operation === "update") {
-							transaction.set(bundleRef, {
-								id: data.id,
-								channel: data.channel,
-								enabled: data.enabled,
-								should_force_update: data.shouldForceUpdate,
-								file_hash: data.fileHash,
-								git_commit_hash: data.gitCommitHash || null,
-								message: data.message || null,
-								platform: data.platform,
-								target_app_version: data.targetAppVersion || null,
-								storage_uri: data.storageUri,
-								fingerprint_hash: data.fingerprintHash,
-								metadata: stripBundleArtifactMetadata(data.metadata) ?? {},
-								manifest_storage_uri: getManifestStorageUri(data),
-								manifest_file_hash: getManifestFileHash(data),
-								asset_base_storage_uri: getAssetBaseStorageUri(data),
-								patches: data.patches ?? null,
-								patch_base_bundle_id: getPatchBaseBundleId(data),
-								patch_base_file_hash: getPatchBaseFileHash(data),
-								patch_file_hash: getPatchFileHash(data),
-								patch_storage_uri: getPatchStorageUri(data),
-								rollout_cohort_count: data.rolloutCohortCount ?? DEFAULT_ROLLOUT_COHORT_COUNT,
-								target_cohorts: data.targetCohorts ?? null
-							}, { merge: true });
-							if (data.targetAppVersion) {
-								const versionDocId = `${data.platform}_${data.channel}_${data.targetAppVersion}`;
-								const targetAppVersionsRef = db.collection("target_app_versions").doc(versionDocId);
-								transaction.set(targetAppVersionsRef, {
-									channel: data.channel,
-									platform: data.platform,
-									target_app_version: data.targetAppVersion
-								}, { merge: true });
-							}
-						} else if (operation === "delete") transaction.delete(bundleRef);
-					}
-					if (isTargetAppVersionChanged) {
-						for (const targetDoc of targetVersionsSnapshot.docs) if (!requiredTargetVersionKeys.has(targetDoc.id)) transaction.delete(targetDoc.ref);
-					}
-					for (const channelDoc of channelsSnapshot.docs) if (!requiredChannels.has(channelDoc.id)) transaction.delete(channelDoc.ref);
+			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)
 		};
-	}
-});
+	})());
+	return createDatabasePlugin({
+		name: "firebaseDatabase",
+		models: adapter.models,
+		commit: adapter.commit
+	});
+};
 //#endregion
 //#region src/firebaseStorage.ts
-const firebaseStorage = createUniversalStoragePlugin({
-	name: "firebaseStorage",
-	supportedProtocol: "gs",
-	factory: (config) => {
-		const bucket = getStorage(getApps().length ? getApp() : initializeApp(config)).bucket(config.storageBucket);
-		const getStorageKey = createStorageKeyBuilder(config.basePath);
-		return {
-			node: {
-				async delete(storageUri) {
-					const { bucket: bucketName, key } = parseStorageUri(storageUri, "gs");
-					if (bucketName !== config.storageBucket) throw new Error(`Bucket name mismatch: expected "${config.storageBucket}", but found "${bucketName}".`);
-					try {
-						const [files] = await bucket.getFiles({ prefix: key });
-						await Promise.all(files.map((file) => file.delete()));
-					} catch (e) {
-						console.error("Error listing or deleting files:", e);
-						throw new Error("Bundle Not Found");
-					}
-				},
-				async upload(key, filePath) {
-					try {
-						const fileContent = await fs.readFile(filePath);
-						const contentType = getContentType(filePath);
-						const storageKey = getStorageKey(key, path.basename(filePath));
-						await bucket.file(storageKey).save(fileContent, { metadata: {
-							contentType,
-							cacheControl: "public, max-age=31536000, immutable"
-						} });
-						return { storageUri: `gs://${config.storageBucket}/${storageKey}` };
-					} catch (error) {
-						console.error("Error uploading bundle:", error);
-						if (error instanceof Error) throw new Error(`Failed to upload bundle: ${error.message}`);
-						throw error;
-					}
-				},
-				async exists(storageUri) {
-					const { bucket: bucketName, key } = parseStorageUri(storageUri, "gs");
-					if (bucketName !== config.storageBucket) throw new Error(`Bucket name mismatch: expected "${config.storageBucket}", but found "${bucketName}".`);
-					const [exists] = await bucket.file(key).exists();
-					return exists;
-				},
-				async downloadFile(storageUri, filePath) {
-					const { bucket: bucketName, key } = parseStorageUri(storageUri, "gs");
-					if (bucketName !== config.storageBucket) throw new Error(`Bucket name mismatch: expected "${config.storageBucket}", but found "${bucketName}".`);
-					await fs.mkdir(path.dirname(filePath), { recursive: true });
-					await bucket.file(key).download({ destination: filePath });
-				}
-			},
-			runtime: {
-				async readText(storageUri) {
-					const { bucket: bucketName, key } = parseStorageUri(storageUri, "gs");
-					if (bucketName !== config.storageBucket) throw new Error(`Bucket name mismatch: expected "${config.storageBucket}", but found "${bucketName}".`);
-					try {
-						const [contents] = await bucket.file(key).download();
-						return contents.toString("utf8");
-					} catch (error) {
-						if (typeof error === "object" && error !== null && "code" in error && error.code === 404) return null;
-						throw error;
-					}
-				},
-				async getDownloadUrl(storageUri) {
-					const { key } = parseStorageUri(storageUri, "gs");
-					if (!key) throw new Error("Invalid Firebase storage URI: missing key");
-					const [signedUrl] = await bucket.file(key).getSignedUrl({
-						action: "read",
-						expires: Date.now() + 3600 * 1e3
-					});
-					if (!signedUrl) throw new Error("Failed to generate download URL");
-					return { fileUrl: signedUrl };
-				}
+const firebaseStorage = (config) => {
+	const bucket = getStorage(getApps().length ? getApp() : initializeApp(config)).bucket(config.storageBucket);
+	const getStorageKey = createStorageKeyBuilder(config.basePath);
+	const parseAndValidate = (storageUri) => {
+		const parsed = parseStorageUri(storageUri, "gs");
+		if (parsed.bucket !== config.storageBucket) throw new Error(`Bucket name mismatch: expected "${config.storageBucket}", but found "${parsed.bucket}".`);
+		return parsed;
+	};
+	return createStoragePlugin({
+		name: "firebaseStorage",
+		protocol: "gs",
+		async put({ key, body, contentType }) {
+			const storageKey = getStorageKey(key);
+			const bytes = new Uint8Array(await new Response(body).arrayBuffer());
+			await bucket.file(storageKey).save(bytes, { metadata: {
+				contentType,
+				cacheControl: "public, max-age=31536000, immutable"
+			} });
+			return { storageUri: createStorageUri({
+				bucket: config.storageBucket,
+				key: storageKey,
+				protocol: "gs"
+			}) };
+		},
+		async get({ storageUri }) {
+			const { key } = parseAndValidate(storageUri);
+			try {
+				const file = bucket.file(key);
+				const [[body], [metadata]] = await Promise.all([file.download(), file.getMetadata()]);
+				const headers = new Headers();
+				if (metadata.contentType) headers.set("content-type", metadata.contentType);
+				headers.set("content-length", String(metadata.size ?? body.byteLength));
+				return { response: new Response(body, { headers }) };
+			} catch (error) {
+				if (typeof error === "object" && error !== null && "code" in error && error.code === 404) return { response: null };
+				throw error;
 			}
-		};
-	}
-});
+		},
+		async getDownloadUrl({ storageUri }) {
+			const { key } = parseAndValidate(storageUri);
+			if (config.cdnUrl) {
+				const storageUrl = new URL(storageUri);
+				const downloadUrl = new URL(config.cdnUrl);
+				downloadUrl.pathname = `${downloadUrl.pathname.replace(/\/+$/, "")}${storageUrl.pathname}`;
+				downloadUrl.search = "";
+				downloadUrl.hash = "";
+				return { url: downloadUrl.toString() };
+			}
+			const [url] = await bucket.file(key).getSignedUrl({
+				action: "read",
+				expires: Date.now() + (config.signedUrlExpiresIn ?? 3600) * 1e3
+			});
+			if (!url) throw new Error("Failed to generate Firebase download URL");
+			return { url };
+		},
+		async exists({ storageUri }) {
+			const { key } = parseAndValidate(storageUri);
+			const [exists] = await bucket.file(key).exists();
+			return { exists };
+		},
+		async delete({ storageUri }) {
+			const { key } = parseAndValidate(storageUri);
+			await bucket.file(key).delete({ ignoreNotFound: true });
+			return { deleted: true };
+		}
+	});
+};
 //#endregion
 export { firebaseDatabase, firebaseStorage };