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

package/dist/iac/index.cjs

@@ -27,6 +27,7 @@ fs = __toESM(fs);
 let path = require("path");
 path = __toESM(path);
 let _hot_updater_cli_tools = require("@hot-updater/cli-tools");
+let _hot_updater_server = require("@hot-updater/server");
 let node_url = require("node:url");
 let node_child_process = require("node:child_process");
 let node_string_decoder = require("node:string_decoder");
@@ -46,6 +47,12 @@ let node_fs = require("node:fs");
 let node_stream_promises = require("node:stream/promises");
 let node_stream = require("node:stream");
 let node_buffer = require("node:buffer");
+let firebase_admin_app = require("firebase-admin/app");
+let _hot_updater_plugin_core = require("@hot-updater/plugin-core");
+let _hot_updater_plugin_core_internal = require("@hot-updater/plugin-core/internal");
+let firebase_admin_firestore = require("firebase-admin/firestore");
+let fs_promises = require("fs/promises");
+fs_promises = __toESM(fs_promises);
 let node_fs_promises = require("node:fs/promises");
 node_fs_promises = __toESM(node_fs_promises);
 //#region ../../node_modules/.pnpm/es-toolkit@1.47.0/node_modules/es-toolkit/dist/_internal/compareValues.mjs
@@ -1323,7 +1330,7 @@ const handleCommand = (filePath, rawArguments, rawOptions) => {
 var require_windows = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = isexe;
 	isexe.sync = sync;
-	var fs$5 = require("fs");
+	var fs$6 = require("fs");
 	function checkPathExt(path, options) {
 		var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
 		if (!pathext) return true;
@@ -1340,12 +1347,12 @@ var require_windows = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		return checkPathExt(path, options);
 	}
 	function isexe(path, options, cb) {
-		fs$5.stat(path, function(er, stat) {
+		fs$6.stat(path, function(er, stat) {
 			cb(er, er ? false : checkStat(stat, path, options));
 		});
 	}
 	function sync(path, options) {
-		return checkStat(fs$5.statSync(path), path, options);
+		return checkStat(fs$6.statSync(path), path, options);
 	}
 }));
 //#endregion
@@ -1353,14 +1360,14 @@ var require_windows = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 var require_mode = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = isexe;
 	isexe.sync = sync;
-	var fs$4 = require("fs");
+	var fs$5 = require("fs");
 	function isexe(path, options, cb) {
-		fs$4.stat(path, function(er, stat) {
+		fs$5.stat(path, function(er, stat) {
 			cb(er, er ? false : checkStat(stat, options));
 		});
 	}
 	function sync(path, options) {
-		return checkStat(fs$4.statSync(path), options);
+		return checkStat(fs$5.statSync(path), options);
 	}
 	function checkStat(stat, options) {
 		return stat.isFile() && checkMode(stat, options);
@@ -1575,16 +1582,16 @@ var require_shebang_command = /* @__PURE__ */ __commonJSMin(((exports, module) =
 //#endregion
 //#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/readShebang.js
 var require_readShebang = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const fs$3 = require("fs");
+	const fs$4 = require("fs");
 	const shebangCommand = require_shebang_command();
 	function readShebang(command) {
 		const size = 150;
 		const buffer = Buffer.alloc(size);
 		let fd;
 		try {
-			fd = fs$3.openSync(command, "r");
-			fs$3.readSync(fd, buffer, 0, size, 0);
-			fs$3.closeSync(fd);
+			fd = fs$4.openSync(command, "r");
+			fs$4.readSync(fd, buffer, 0, size, 0);
+			fs$4.closeSync(fd);
 		} catch (e) {}
 		return shebangCommand(buffer.toString());
 	}
@@ -6712,6 +6719,777 @@ createExeca(mapNode);
 createExeca(mapScriptAsync, {}, deepScriptOptions, setScriptSync);
 const { sendMessage, getOneMessage, getEachMessage, getCancelSignal } = getIpcExport();
 //#endregion
+//#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 (!(0, _hot_updater_plugin_core.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 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 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_FUNCTION_NAME = "hot-updater-v1";
+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 {
+		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 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 = (0, _hot_updater_plugin_core_internal.createDatabasePluginAdapter)("firebaseDatabase", (() => {
+		const db = (0, firebase_admin_firestore.getFirestore)((0, firebase_admin_app.getApps)().length ? (0, firebase_admin_app.getApp)() : (0, firebase_admin_app.initializeApp)(config));
+		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 {
+			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));
+				}
+			},
+			findMany: async (input) => {
+				if (input.model !== "channels") return read((database) => database.findMany(input));
+				await ensureMigrated();
+				return queryFirebaseDatabaseRows(await loadFirebaseChannels(collections), 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)
+		};
+	})());
+	return (0, _hot_updater_plugin_core.createDatabasePlugin)({
+		name: "firebaseDatabase",
+		models: adapter.models,
+		commit: adapter.commit
+	});
+};
+//#endregion
 //#region iac/init/index.ts
 const isFirebaseRegion = (value) => value !== void 0 && /^[a-z]+(?:-[a-z]+)+[0-9]+$/.test(value);
 const isFirebaseProjectId = (value) => value !== void 0 && /^[a-z][a-z0-9-]{4,28}[a-z0-9]$/.test(value);
@@ -6765,6 +7543,53 @@ const inputFirebaseApplicationCredentials = async ({ applicationCredentials, non
 	return credentialsPath || void 0;
 };
 //#endregion
+//#region iac/firebaseInfrastructureState.ts
+const resolveFirebaseInfrastructureState = ({ adapterVersion, hasData }) => {
+	if (adapterVersion === 4) return "v1";
+	if (adapterVersion !== void 0 || hasData) return "incompatible";
+	return "fresh";
+};
+const assertFirebaseInfrastructureCanInitialize = async ({ applicationCredentials, projectId }) => {
+	const app = (0, firebase_admin_app.initializeApp)({
+		credential: applicationCredentials ? (0, firebase_admin_app.cert)(JSON.parse(await fs_promises.default.readFile(applicationCredentials, "utf8"))) : (0, firebase_admin_app.applicationDefault)(),
+		projectId
+	}, `hot-updater-init-${projectId}-${Date.now()}`);
+	try {
+		const db = (0, firebase_admin_firestore.getFirestore)(app);
+		const version = await db.collection(FIREBASE_V1_COLLECTION_NAMES.settings).doc("database_adapter_version").get();
+		const collections = await Promise.all([
+			FIREBASE_V1_COLLECTION_NAMES.bundles,
+			FIREBASE_V1_COLLECTION_NAMES.bundlePatches,
+			FIREBASE_V1_COLLECTION_NAMES.channels,
+			FIREBASE_V1_COLLECTION_NAMES.releaseCatalogs
+		].map((name) => db.collection(name).limit(1).get()));
+		if (resolveFirebaseInfrastructureState({
+			adapterVersion: version.exists ? version.data()?.version : void 0,
+			hasData: collections.some((snapshot) => !snapshot.empty)
+		}) === "incompatible") throw new _hot_updater_cli_tools.InitError(`Firebase v1 infrastructure in project ${projectId} is incomplete or uses an unsupported database version.`);
+	} catch (error) {
+		if (error instanceof _hot_updater_cli_tools.InitError) throw error;
+		const code = typeof error === "object" && error !== null ? Reflect.get(error, "code") : void 0;
+		if (code === 5 || code === "not-found") return;
+		throw error;
+	} finally {
+		await (0, firebase_admin_app.deleteApp)(app);
+	}
+};
+const assertFirebaseFunctionCanInitialize = async ({ fetchImpl, functions }) => {
+	const existingFunctions = functions.filter(({ id }) => id === FIREBASE_V1_FUNCTION_NAME);
+	for (const existingFunction of existingFunctions) {
+		if (!existingFunction.uri) throw new _hot_updater_cli_tools.InitError(`Could not verify the Firebase infrastructure generation at Function ${FIREBASE_V1_FUNCTION_NAME}: endpoint URL was not reported.`);
+		const versionUrl = new URL("version", `${existingFunction.uri.replace(/\/$/u, "")}/`).toString();
+		await (0, _hot_updater_cli_tools.assertInfrastructureGenerationAtUrl)({
+			fetchImpl,
+			provider: "Firebase",
+			resource: `Function ${FIREBASE_V1_FUNCTION_NAME}`,
+			versionUrl
+		});
+	}
+};
+//#endregion
 //#region iac/firebaseInitInputs.ts
 const resolveFirebaseCredentialsPath = (credentialsPath, { cwd = process.cwd(), homeDir = node_os.default.homedir(), pathApi = node_path.default }) => {
 	const homeRelativePath = credentialsPath === "~" ? "" : credentialsPath.startsWith("~/") || credentialsPath.startsWith("~\\") ? credentialsPath.slice(2) : void 0;
@@ -6894,7 +7719,7 @@ const resolveFirebaseRegion = async ({ cwd, discoverExistingProject = true, nonI
 		if (functionsList.exitCode === 0) {
 			const parsed = JSON.parse(functionsList.stdout);
 			if (typeof parsed === "object" && parsed !== null && "result" in parsed && Array.isArray(parsed.result)) {
-				for (const entry of parsed.result) if (typeof entry === "object" && entry !== null && "id" in entry && entry.id === "hot-updater" && "region" in entry && typeof entry.region === "string") {
+				for (const entry of parsed.result) if (typeof entry === "object" && entry !== null && "id" in entry && entry.id === "hot-updater-v1" && "region" in entry && typeof entry.region === "string") {
 					discoveredRegion = entry.region;
 					break;
 				}
@@ -7216,10 +8041,16 @@ function App() {
   return null; // Replace with your app root
 }
 
-export default HotUpdater.wrap({
+HotUpdater.init({
   baseURL: "%%source%%",
-  updateStrategy: "appVersion", // or "fingerprint"
-})(App);`;
+  requestHeaders: {
+    "x-api-key": %%apiKey%%,
+  },
+});
+
+// Call HotUpdater.checkForUpdate({ updateStrategy: "appVersion" })
+// when your app is ready to check.
+export default App;`;
 const getFirebaseRuntimePackageInfo = () => {
 	const firebasePackageRoot = path.default.dirname(require.resolve("@hot-updater/firebase/package.json"));
 	return {
@@ -7240,6 +8071,71 @@ const syncFunctionsPackageJson = async (functionsDir) => {
 	await fs.default.promises.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`);
 	return runtimePackageInfo;
 };
+const commandErrorMessage = (error) => {
+	if (error instanceof ExecaError) {
+		const output = error.stderr || error.stdout;
+		if (output !== void 0 && output !== null) {
+			const text = String(output).trim();
+			if (!text) return error.message;
+			try {
+				const parsed = JSON.parse(text);
+				if (typeof parsed === "object" && parsed !== null) {
+					const message = Reflect.get(parsed, "error");
+					if (typeof message === "string") return message;
+				}
+			} catch {
+				return text;
+			}
+			return text;
+		}
+	}
+	return error instanceof Error ? error.message : String(error);
+};
+const ensureCloudFunctionsApiEnabled = async (projectId, cliEnv) => {
+	await _hot_updater_cli_tools.p.tasks([{
+		title: "Checking Cloud Functions API",
+		task: async () => {
+			try {
+				await execa("gcloud", [
+					"services",
+					"enable",
+					"cloudfunctions.googleapis.com",
+					`--project=${projectId}`,
+					"--quiet"
+				], { env: cliEnv });
+			} catch (error) {
+				throw new _hot_updater_cli_tools.InitError(`Could not enable the Cloud Functions API for Firebase project ${projectId}: ${commandErrorMessage(error)}`);
+			}
+			return "Cloud Functions API is enabled";
+		}
+	}]);
+};
+const listFirebaseFunctions = async (cwd, projectId, nonInteractive, cliEnv) => {
+	let functionsList;
+	try {
+		functionsList = await execa("npx", [
+			"firebase",
+			"functions:list",
+			"--json",
+			"--project",
+			projectId,
+			...nonInteractive ? ["--non-interactive"] : []
+		], {
+			cwd,
+			env: cliEnv
+		});
+	} catch (error) {
+		throw new _hot_updater_cli_tools.InitError(`Could not list Firebase Functions for project ${projectId}: ${commandErrorMessage(error)}. Run npx firebase functions:list --project ${projectId} --debug for details.`);
+	}
+	let body;
+	try {
+		body = JSON.parse(functionsList.stdout);
+	} catch {
+		throw new _hot_updater_cli_tools.InitError("Firebase functions list response was invalid.");
+	}
+	if (typeof body !== "object" || body === null || !Array.isArray(Reflect.get(body, "result"))) throw new _hot_updater_cli_tools.InitError("Firebase functions list response was invalid.");
+	return Reflect.get(body, "result");
+};
 function normalizeIndex(index) {
 	return {
 		collectionGroup: index.collectionGroup,
@@ -7304,7 +8200,7 @@ const deployFunctions = async (cwd, nonInteractive = false, cliEnv) => {
 			"firebase",
 			"deploy",
 			"--only",
-			"functions",
+			`functions:${FIREBASE_V1_FUNCTION_NAME}`,
 			...nonInteractive ? ["--non-interactive"] : []
 		], {
 			cwd,
@@ -7317,21 +8213,26 @@ const deployFunctions = async (cwd, nonInteractive = false, cliEnv) => {
 		process.exit(1);
 	}
 };
-const printTemplate = async (projectId, region, cliEnv) => {
+const printTemplate = async (apiKey, projectId, region, cliEnv) => {
 	try {
-		const { stdout } = await execa("gcloud", [
+		const describedFunction = await execa("gcloud", [
 			"functions",
 			"describe",
-			"hot-updater",
+			FIREBASE_V1_FUNCTION_NAME,
 			"--project",
 			projectId,
 			"--region",
 			region,
 			"--format=json"
 		], { env: cliEnv });
-		const parsedData = JSON.parse(stdout);
-		const functionUrl = `${parsedData?.serviceConfig?.uri ?? parsedData.url}/api/check-update`;
-		_hot_updater_cli_tools.p.note((0, _hot_updater_cli_tools.transformTemplate)(SOURCE_TEMPLATE, { source: functionUrl }));
+		const functionUrl = JSON.parse(describedFunction.stdout).serviceConfig?.uri;
+		if (!functionUrl) throw new _hot_updater_cli_tools.InitError(`Firebase Function ${FIREBASE_V1_FUNCTION_NAME} did not report an endpoint URL.`);
+		_hot_updater_cli_tools.p.note((0, _hot_updater_cli_tools.transformTemplate)(SOURCE_TEMPLATE, {
+			apiKey: JSON.stringify(apiKey),
+			source: functionUrl
+		}));
+		_hot_updater_cli_tools.p.note((0, _hot_updater_cli_tools.formatApiKeyNote)(apiKey), "API Key");
+		_hot_updater_cli_tools.p.log.message("Store this API key separately in a secure place.");
 	} catch (error) {
 		if (error instanceof ExecaError) _hot_updater_cli_tools.p.log.error(error.stderr || error.stdout || error.message);
 		else if (error instanceof Error) _hot_updater_cli_tools.p.log.error(error.message);
@@ -7350,7 +8251,8 @@ const runInit = async ({ build, envFile }) => {
 	const nonInteractive = envFile !== void 0;
 	const initEnvSources = await (0, _hot_updater_cli_tools.readHotUpdaterInitEnv)(process.cwd(), envFile);
 	const { managedEnv } = initEnvSources;
-	const savedInputs = resolveFirebaseInitInputs((0, _hot_updater_cli_tools.getHotUpdaterInitInputEnv)(initEnvSources, nonInteractive));
+	const initInputEnv = (0, _hot_updater_cli_tools.getHotUpdaterInitInputEnv)(initEnvSources, nonInteractive);
+	const savedInputs = resolveFirebaseInitInputs(initInputEnv);
 	assertFirebaseNonInteractiveInputs(savedInputs, nonInteractive);
 	let applicationCredentials = savedInputs.applicationCredentials;
 	const cliEnv = nonInteractive ? getFirebaseCliEnv(applicationCredentials) : void 0;
@@ -7371,6 +8273,14 @@ const runInit = async ({ build, envFile }) => {
 		});
 		return cliEnv;
 	});
+	if (initializeVariable.status === "ready") {
+		await assertFirebaseInfrastructureCanInitialize({
+			applicationCredentials,
+			projectId: initializeVariable.projectId
+		});
+		await ensureCloudFunctionsApiEnabled(initializeVariable.projectId, cliEnv);
+		await assertFirebaseFunctionCanInitialize({ functions: await listFirebaseFunctions(tmpDir, initializeVariable.projectId, nonInteractive, cliEnv) });
+	}
 	const currentRegion = await resolveFirebaseRegion({
 		cwd: tmpDir,
 		discoverExistingProject: initializeVariable.status === "ready",
@@ -7427,22 +8337,31 @@ const runInit = async ({ build, envFile }) => {
 		}
 	}]);
 	await deployFirestore(tmpDir, nonInteractive, cliEnv);
+	const credential = applicationCredentials ? (0, firebase_admin_app.cert)(JSON.parse(await fs.default.promises.readFile(applicationCredentials, "utf-8"))) : (0, firebase_admin_app.applicationDefault)();
+	const existingApps = new Set((0, firebase_admin_app.getApps)());
+	const databasePlugin = firebaseDatabase({
+		credential,
+		projectId: initializeVariable.projectId
+	});
+	let apiKey;
+	try {
+		apiKey = (await (0, _hot_updater_server.provisionApiKey)({
+			apiKeys: databasePlugin.models.apiKeys,
+			existingApiKey: initInputEnv.HOT_UPDATER_API_KEY,
+			name: "Firebase init"
+		})).apiKey;
+		await (0, _hot_updater_cli_tools.makeEnv)({ HOT_UPDATER_API_KEY: apiKey });
+	} finally {
+		await databasePlugin.dispose?.();
+		await Promise.all((0, firebase_admin_app.getApps)().filter((app) => !existingApps.has(app)).map((app) => (0, firebase_admin_app.deleteApp)(app)));
+	}
 	await deployFunctions(tmpDir, nonInteractive, cliEnv);
 	await _hot_updater_cli_tools.p.tasks([{
 		title: "Check IAM policy",
 		async task(message) {
-			const functionsList = await execa("npx", [
-				"firebase",
-				"functions:list",
-				"--json",
-				...nonInteractive ? ["--non-interactive"] : []
-			], {
-				cwd: tmpDir,
-				env: cliEnv
-			});
-			const account = (JSON.parse(functionsList.stdout).result || []).find((fn) => fn.id === "hot-updater")?.serviceAccount;
+			const account = (await listFirebaseFunctions(tmpDir, initializeVariable.projectId, nonInteractive, cliEnv)).find((fn) => fn.id === FIREBASE_V1_FUNCTION_NAME)?.serviceAccount;
 			if (!account) {
-				_hot_updater_cli_tools.p.log.error("hot-updater function not found");
+				_hot_updater_cli_tools.p.log.error(`${FIREBASE_V1_FUNCTION_NAME} function not found`);
 				await removeTmpDir();
 				process.exit(1);
 			}
@@ -7479,7 +8398,7 @@ const runInit = async ({ build, envFile }) => {
 		await removeTmpDir();
 		process.exit(1);
 	}
-	await printTemplate(initializeVariable.projectId, currentRegion, cliEnv);
+	await printTemplate(apiKey, initializeVariable.projectId, currentRegion, cliEnv);
 	await removeTmpDir();
 	_hot_updater_cli_tools.p.log.message(`Next step: ${(0, _hot_updater_cli_tools.link)("https://hot-updater.dev/docs/managed/firebase#step-3-generated-configurations")}`);
 	if (!applicationCredentials) _hot_updater_cli_tools.p.log.message("Next step: Change GOOGLE_APPLICATION_CREDENTIALS=your-credentials.json in .env.hotupdater");