@hot-updater/server 1.0.0-rc.1 → 1.0.0-rc.16

package/dist/core/api.d.mts

@@ -0,0 +1,65 @@
+import { ReleaseCatalogRequest } from "../db/releaseCatalog.mjs";
+import { CoreDatabase, CoreStorage } from "./reads.mjs";
+import { HotUpdaterCoreApi } from "@hot-updater/plugin-core";
+import { DatabaseAdapter } from "@hot-updater/plugin-core/internal";
+//#region src/core/api.d.ts
+interface CoreApiOptions {
+  readonly now?: () => number;
+  /** The database's CDN purge, called after a write that changes a Release Catalog. */
+  readonly onCachedRoutesChange?: () => Promise<void>;
+}
+/** Core's reads and typed writes over one database handle. */
+declare const createCoreApi: (db: CoreDatabase, storage: CoreStorage, options?: CoreApiOptions) => {
+  /** One read, which checks the schema settings first. */
+  ready: () => Promise<void>;
+  deploy: (deployments: readonly import("@hot-updater/plugin-core").Deployment[]) => Promise<import("@hot-updater/plugin-core").ReleaseCatalogMutationResult[]>;
+  updateReleasePolicy: (input: import("@hot-updater/plugin-core").ReleaseTarget & {
+    readonly patch: import("@hot-updater/plugin-core").ReleasePolicyPatch;
+  }) => Promise<import("@hot-updater/plugin-core").ReleaseCatalogMutationResult>;
+  preflightReleasePolicy: (input: import("@hot-updater/plugin-core").ReleaseTarget & {
+    readonly patch: import("@hot-updater/plugin-core").ReleasePolicyPatch;
+  }) => Promise<import("@hot-updater/plugin-core").ReleaseCatalogMutationPreflight>;
+  deleteRelease: (input: import("@hot-updater/plugin-core").ReleaseTarget) => Promise<import("@hot-updater/plugin-core").ReleaseCatalogMutationResult>;
+  promoteRelease: (input: import("@hot-updater/plugin-core").ReleaseTarget & {
+    readonly targetChannel: string;
+    readonly action?: "copy" | "move";
+  }) => Promise<import("@hot-updater/plugin-core").PromoteReleaseResult>;
+  rebuildReleaseCatalog: (scopeKey: string) => Promise<import("@hot-updater/plugin-core").ReleaseCatalogRebuildResult>;
+  preflightReleaseCatalogRebuild: (scopeKey: string) => Promise<import("@hot-updater/plugin-core").ReleaseCatalogRebuildPreflight>;
+  ensureChannel: (name: string) => Promise<import("@hot-updater/plugin-core").ChannelRow>;
+  deleteChannel: (id: string) => Promise<import("@hot-updater/plugin-core").ChannelDeleteResult>;
+  updateBundle: (id: string, update: Partial<Omit<import("@hot-updater/core").Bundle, "id" | "patches">> & {
+    readonly patches?: import("@hot-updater/core").Bundle["patches"];
+  }) => Promise<void>;
+  deleteBundles: (ids: readonly string[]) => Promise<void>;
+  getReleaseCatalog(input: ReleaseCatalogRequest): Promise<import("@hot-updater/core").ReleaseCatalog | null>;
+  getArtifactInfo(targetBundleId: string, currentBundleId: string, artifactProtocolVersion: 1): Promise<import("@hot-updater/core").ArtifactInfo | null>;
+  getBundle(id: string): Promise<import("@hot-updater/plugin-core").BundleDetail | null>;
+  countBundleChildren(baseBundleIds: readonly string[]): Promise<Record<string, number>>;
+  listPatchesFromBase(baseBundleId: string, input: import("@hot-updater/plugin-core").KeysetInput): Promise<import("@hot-updater/plugin-core").BundlePatchRow[]>;
+  listBundles(input: import("@hot-updater/plugin-core").KeysetInput & {
+    readonly platform?: "ios" | "android";
+  }): Promise<import("@hot-updater/plugin-core").BundleDetail[]>;
+  countBundles(platform?: "ios" | "android"): Promise<number>;
+  findBaseBundleIds(candidateKey: string, bundleId: string, limit: number): Promise<string[]>;
+  getRelease(id: string): Promise<import("@hot-updater/plugin-core").ReleaseRow | null>;
+  listReleases(input: import("@hot-updater/plugin-core").KeysetInput & {
+    readonly filter: import("@hot-updater/plugin-core").ReleaseFilter;
+  }): Promise<import("@hot-updater/plugin-core").ReleaseRow[]>;
+  latestReleaseId(scopeKey: string): Promise<string | null>;
+  getReleaseCatalogRow(scopeKey: string): Promise<import("@hot-updater/plugin-core").ReleaseCatalogRow | null>;
+  listReleaseCatalogs(input: import("@hot-updater/plugin-core").KeysetInput): Promise<import("@hot-updater/plugin-core").ReleaseCatalogRow[]>;
+  listChannels(): Promise<import("@hot-updater/plugin-core").ChannelRow[]>;
+  findChannelByName(name: string): Promise<import("@hot-updater/plugin-core").ChannelRow | null>;
+};
+type CoreApi = ReturnType<typeof createCoreApi>;
+/**
+ * Core's API for a configured database, as the CLI uses it: a self-hosted
+ * server's admin API when the database is `standaloneRepository`, or the
+ * database's own storage adapter, in process.
+ */
+declare const createDatabaseCoreApi: (database: unknown, options?: {
+  readonly now?: () => number;
+}) => HotUpdaterCoreApi;
+//#endregion
+export { CoreApi, CoreApiOptions, createCoreApi, createDatabaseCoreApi };

package/dist/core/api.mjs

@@ -0,0 +1,87 @@
+import { resolveSchema } from "../database/resolveSchema.mjs";
+import { createDatabaseEngine } from "../database/database.mjs";
+import { createCoreReads } from "./reads.mjs";
+import { createCoreOperations } from "./operations.mjs";
+import { coreModule } from "./schema.mjs";
+//#region src/core/api.ts
+/**
+* The update check answers from one Release Catalog row, so a transaction
+* changes what the cacheable client routes answer only when it writes one.
+* The purge runs once, after the attempt that commits.
+*/
+const purgingCachedRoutes = (db, onCachedRoutesChange) => {
+	if (onCachedRoutesChange === void 0) return db;
+	return {
+		...db,
+		async transaction(fn) {
+			let changed = false;
+			const result = await db.transaction((tx) => {
+				changed = false;
+				return fn({
+					...tx,
+					create: (model, row) => {
+						changed ||= model === "release_catalogs";
+						tx.create(model, row);
+					},
+					update: (model, row, set) => {
+						changed ||= model === "release_catalogs";
+						tx.update(model, row, set);
+					},
+					delete: (model, row) => {
+						changed ||= model === "release_catalogs";
+						return tx.delete(model, row);
+					}
+				});
+			});
+			if (changed) await onCachedRoutesChange();
+			return result;
+		}
+	};
+};
+/** Core's reads and typed writes over one database handle. */
+const createCoreApi = (db, storage, options = {}) => {
+	const reads = createCoreReads(db, storage);
+	return {
+		...reads,
+		...createCoreOperations(purgingCachedRoutes(db, options.onCachedRoutesChange), options),
+		/** One read, which checks the schema settings first. */
+		ready: async () => {
+			await reads.listReleaseCatalogs({ limit: 1 });
+		}
+	};
+};
+/**
+* Core's API in process, on a database's storage adapter: how the CLI reads
+* and writes a database that runs on the storage engine.
+*/
+const createInProcessCoreApi = (adapter, options = {}) => createCoreApi(createDatabaseEngine({
+	adapter,
+	schema: resolveSchema([coreModule])
+}).database(coreModule), { resolveFileUrl: async () => null }, options);
+const isRecord = (value) => typeof value === "object" && value !== null;
+const isAdapter = (value) => isRecord(value) && [
+	"fits",
+	"get",
+	"query",
+	"write"
+].every((method) => typeof value[method] === "function");
+/** The storage adapter a configured database runs on, if it is on the engine. */
+const engineAdapterOf = (database) => isRecord(database) && isAdapter(database.adapter) ? database.adapter : isAdapter(database) ? database : void 0;
+const OFF_ENGINE_DATABASE = "This database does not run on Hot Updater's storage engine. Upgrade its provider package to 1.0.";
+/**
+* Core's API for a configured database, as the CLI uses it: a self-hosted
+* server's admin API when the database is `standaloneRepository`, or the
+* database's own storage adapter, in process.
+*/
+const createDatabaseCoreApi = (database, options = {}) => {
+	if (isRecord(database) && isRecord(database.core)) return database.core;
+	const adapter = engineAdapterOf(database);
+	if (adapter === void 0) throw new Error(OFF_ENGINE_DATABASE);
+	const engineDatabase = database;
+	return createInProcessCoreApi(adapter, {
+		...options,
+		...typeof engineDatabase.onCachedRoutesChange === "function" ? { onCachedRoutesChange: () => engineDatabase.onCachedRoutesChange() } : {}
+	});
+};
+//#endregion
+export { OFF_ENGINE_DATABASE, createCoreApi, createDatabaseCoreApi, createInProcessCoreApi, engineAdapterOf };

package/dist/core/baseCandidates.cjs

@@ -0,0 +1,71 @@
+const require_releaseCatalog = require("../db/releaseCatalog.cjs");
+let _hot_updater_core = require("@hot-updater/core");
+let verkit = require("verkit");
+//#region src/core/baseCandidates.ts
+/**
+* A new bundle's base-candidate key: the Release Catalog scope its devices
+* update from, and for an app version its normalized range; null for a
+* target without a valid range.
+*/
+const targetBaseCandidateKey = (target) => {
+	const channelKey = (0, _hot_updater_core.encodeChannelKey)(target.channel);
+	if (target.fingerprintHash) return JSON.stringify([(0, _hot_updater_core.createReleaseCatalogScopeKey)({
+		channelKey,
+		fingerprintHash: target.fingerprintHash,
+		platform: target.platform,
+		strategy: "FINGERPRINT"
+	})]);
+	const range = target.appVersion === null ? null : (0, verkit.normalizeRange)(target.appVersion);
+	return range === null ? null : JSON.stringify([(0, _hot_updater_core.createReleaseCatalogScopeKey)({
+		channelKey,
+		platform: target.platform,
+		strategy: "APP_VERSION"
+	}), range]);
+};
+/** The scope and range a base-candidate key names; null for any other string. */
+const parseBaseCandidateKey = (key) => {
+	try {
+		const parsed = JSON.parse(key);
+		if (!Array.isArray(parsed) || typeof parsed[0] !== "string") return null;
+		const [scopeKey, text] = parsed;
+		const { strategy } = (0, _hot_updater_core.parseReleaseCatalogScopeKey)(scopeKey);
+		if (strategy === "FINGERPRINT") return parsed.length === 1 ? {
+			scopeKey,
+			range: null
+		} : null;
+		const range = parsed.length === 2 && typeof text === "string" ? (0, verkit.normalizeRange)(text) : null;
+		return range === null ? null : {
+			scopeKey,
+			range
+		};
+	} catch {
+		return null;
+	}
+};
+/** A compiled segment as a range: its version when it holds exactly one. */
+const segmentRange = ({ lower, upper }) => lower?.inclusive && upper?.inclusive && lower.version === upper.version ? lower.version : [lower === null ? "" : `${lower.inclusive ? ">=" : ">"}${lower.version}`, upper === null ? "" : `${upper.inclusive ? "<=" : "<"}${upper.version}`].join(" ").trim() || "*";
+/**
+* Auto-patch bases from a scope's compiled Release Catalog, which holds
+* every enabled bundle release of the scope: those whose range intersects
+* `range` (all of them in a fingerprint scope), newest release first, each
+* bundle once and older than `bundleId`, at most `limit`.
+*/
+const baseBundleIdsOf = (row, range, bundleId, limit) => {
+	const catalog = require_releaseCatalog.parseCompiledCatalog(row.payload, row.strategy);
+	const serving = new Set(catalog.strategy === "FINGERPRINT" ? catalog.rollbackReleaseIndexes : catalog.segments.flatMap((segment) => range !== null && (0, verkit.rangesIntersect)(range, segmentRange(segment)) ? segment.rollbackReleaseIndexes : []));
+	const newestFirst = catalog.releaseDescriptors.map((descriptor, index) => ({
+		descriptor,
+		index
+	})).sort((left, right) => left.descriptor.releaseId < right.descriptor.releaseId ? 1 : -1);
+	const ids = [];
+	for (const { descriptor, index } of newestFirst) {
+		if (ids.length >= limit) break;
+		const id = descriptor.bundleId;
+		if (serving.has(index) && descriptor.kind === "BUNDLE" && id !== null && id < bundleId && !ids.includes(id)) ids.push(id);
+	}
+	return ids;
+};
+//#endregion
+exports.baseBundleIdsOf = baseBundleIdsOf;
+exports.parseBaseCandidateKey = parseBaseCandidateKey;
+exports.targetBaseCandidateKey = targetBaseCandidateKey;

package/dist/core/baseCandidates.d.cts

@@ -0,0 +1,17 @@
+import { ReleaseCatalogRow } from "@hot-updater/plugin-core";
+//#region src/core/baseCandidates.d.ts
+/** A new bundle's auto-patch target: where it is released, and to whom. */
+interface BaseCandidateTarget {
+  readonly channel: string;
+  readonly platform: "ios" | "android";
+  readonly fingerprintHash: string | null;
+  readonly appVersion: string | null;
+}
+/**
+ * A new bundle's base-candidate key: the Release Catalog scope its devices
+ * update from, and for an app version its normalized range; null for a
+ * target without a valid range.
+ */
+declare const targetBaseCandidateKey: (target: BaseCandidateTarget) => string | null;
+//#endregion
+export { BaseCandidateTarget, targetBaseCandidateKey };

package/dist/core/baseCandidates.d.mts

@@ -0,0 +1,17 @@
+import { ReleaseCatalogRow } from "@hot-updater/plugin-core";
+//#region src/core/baseCandidates.d.ts
+/** A new bundle's auto-patch target: where it is released, and to whom. */
+interface BaseCandidateTarget {
+  readonly channel: string;
+  readonly platform: "ios" | "android";
+  readonly fingerprintHash: string | null;
+  readonly appVersion: string | null;
+}
+/**
+ * A new bundle's base-candidate key: the Release Catalog scope its devices
+ * update from, and for an app version its normalized range; null for a
+ * target without a valid range.
+ */
+declare const targetBaseCandidateKey: (target: BaseCandidateTarget) => string | null;
+//#endregion
+export { BaseCandidateTarget, targetBaseCandidateKey };

package/dist/core/baseCandidates.mjs

@@ -0,0 +1,69 @@
+import { parseCompiledCatalog } from "../db/releaseCatalog.mjs";
+import { createReleaseCatalogScopeKey, encodeChannelKey, parseReleaseCatalogScopeKey } from "@hot-updater/core";
+import { normalizeRange, rangesIntersect } from "verkit";
+//#region src/core/baseCandidates.ts
+/**
+* A new bundle's base-candidate key: the Release Catalog scope its devices
+* update from, and for an app version its normalized range; null for a
+* target without a valid range.
+*/
+const targetBaseCandidateKey = (target) => {
+	const channelKey = encodeChannelKey(target.channel);
+	if (target.fingerprintHash) return JSON.stringify([createReleaseCatalogScopeKey({
+		channelKey,
+		fingerprintHash: target.fingerprintHash,
+		platform: target.platform,
+		strategy: "FINGERPRINT"
+	})]);
+	const range = target.appVersion === null ? null : normalizeRange(target.appVersion);
+	return range === null ? null : JSON.stringify([createReleaseCatalogScopeKey({
+		channelKey,
+		platform: target.platform,
+		strategy: "APP_VERSION"
+	}), range]);
+};
+/** The scope and range a base-candidate key names; null for any other string. */
+const parseBaseCandidateKey = (key) => {
+	try {
+		const parsed = JSON.parse(key);
+		if (!Array.isArray(parsed) || typeof parsed[0] !== "string") return null;
+		const [scopeKey, text] = parsed;
+		const { strategy } = parseReleaseCatalogScopeKey(scopeKey);
+		if (strategy === "FINGERPRINT") return parsed.length === 1 ? {
+			scopeKey,
+			range: null
+		} : null;
+		const range = parsed.length === 2 && typeof text === "string" ? normalizeRange(text) : null;
+		return range === null ? null : {
+			scopeKey,
+			range
+		};
+	} catch {
+		return null;
+	}
+};
+/** A compiled segment as a range: its version when it holds exactly one. */
+const segmentRange = ({ lower, upper }) => lower?.inclusive && upper?.inclusive && lower.version === upper.version ? lower.version : [lower === null ? "" : `${lower.inclusive ? ">=" : ">"}${lower.version}`, upper === null ? "" : `${upper.inclusive ? "<=" : "<"}${upper.version}`].join(" ").trim() || "*";
+/**
+* Auto-patch bases from a scope's compiled Release Catalog, which holds
+* every enabled bundle release of the scope: those whose range intersects
+* `range` (all of them in a fingerprint scope), newest release first, each
+* bundle once and older than `bundleId`, at most `limit`.
+*/
+const baseBundleIdsOf = (row, range, bundleId, limit) => {
+	const catalog = parseCompiledCatalog(row.payload, row.strategy);
+	const serving = new Set(catalog.strategy === "FINGERPRINT" ? catalog.rollbackReleaseIndexes : catalog.segments.flatMap((segment) => range !== null && rangesIntersect(range, segmentRange(segment)) ? segment.rollbackReleaseIndexes : []));
+	const newestFirst = catalog.releaseDescriptors.map((descriptor, index) => ({
+		descriptor,
+		index
+	})).sort((left, right) => left.descriptor.releaseId < right.descriptor.releaseId ? 1 : -1);
+	const ids = [];
+	for (const { descriptor, index } of newestFirst) {
+		if (ids.length >= limit) break;
+		const id = descriptor.bundleId;
+		if (serving.has(index) && descriptor.kind === "BUNDLE" && id !== null && id < bundleId && !ids.includes(id)) ids.push(id);
+	}
+	return ids;
+};
+//#endregion
+export { baseBundleIdsOf, parseBaseCandidateKey, targetBaseCandidateKey };

package/dist/core/operations.cjs

@@ -0,0 +1,350 @@
+const require_errors = require("../database/errors.cjs");
+const require_reads = require("./reads.cjs");
+const require_writes = require("./writes.cjs");
+const require_releases = require("./releases.cjs");
+let _hot_updater_plugin_core = require("@hot-updater/plugin-core");
+let _hot_updater_plugin_core_internal = require("@hot-updater/plugin-core/internal");
+let _hot_updater_core = require("@hot-updater/core");
+//#region src/core/operations.ts
+/** Carries a preflight's result out of the transaction it stops, so nothing is written. */
+var Preflight = class extends Error {
+	result;
+	constructor(result) {
+		super("preflight");
+		this.result = result;
+	}
+};
+const dryRun = async (db, read) => {
+	try {
+		await db.transaction(async (tx) => {
+			throw new Preflight(await read(tx));
+		});
+	} catch (error) {
+		if (error instanceof Preflight) return error.result;
+		throw error;
+	}
+	throw new Error("A preflight transaction returned without its result.");
+};
+/** A channel's catalog scope for a platform, and a fingerprint when it has one. */
+const scopeOf = (channel, platform, fingerprintHash) => {
+	const channelKey = (0, _hot_updater_core.encodeChannelKey)(channel.name);
+	return fingerprintHash === null ? {
+		channelId: channel.id,
+		channelName: channel.name,
+		fingerprintHash,
+		platform,
+		scopeKey: (0, _hot_updater_core.createReleaseCatalogScopeKey)({
+			channelKey,
+			platform,
+			strategy: "APP_VERSION"
+		}),
+		strategy: "APP_VERSION"
+	} : {
+		channelId: channel.id,
+		channelName: channel.name,
+		fingerprintHash,
+		platform,
+		scopeKey: (0, _hot_updater_core.createReleaseCatalogScopeKey)({
+			channelKey,
+			fingerprintHash,
+			platform,
+			strategy: "FINGERPRINT"
+		}),
+		strategy: "FINGERPRINT"
+	};
+};
+/** A release and its scope, checked against the revision the caller saw. */
+const loadTarget = async (tx, { releaseId, expectedRevision }) => {
+	const row = await tx.findOne("releases", { id: releaseId });
+	if (row === null) throw new _hot_updater_plugin_core.ReleaseManagementError("RELEASE_NOT_FOUND", `Release "${releaseId}" was not found.`);
+	const release = require_reads.toReleaseRow(row);
+	if (expectedRevision !== void 0 && expectedRevision !== release.revision) throw new _hot_updater_plugin_core.ReleaseManagementError("VERSION_CONFLICT", `Release "${release.id}" is revision ${release.revision}; expected ${expectedRevision}.`);
+	const catalog = await tx.findOne("release_catalogs", { scope_key: release.scope_key });
+	if (catalog === null) throw new _hot_updater_plugin_core.ReleaseCatalogMutationError("INVALID_SCOPE", `Release "${release.id}" has no catalog projection.`);
+	return {
+		release,
+		scope: {
+			channelId: release.channel_id,
+			channelName: (0, _hot_updater_core.decodeChannelKey)(catalog.channel_key),
+			fingerprintHash: release.fingerprint_hash,
+			platform: release.platform,
+			scopeKey: release.scope_key,
+			strategy: release.strategy
+		}
+	};
+};
+const policyUpdate = (release, patch, updatedAtMs) => {
+	if (patch.fingerprintHash !== void 0 && patch.fingerprintHash !== release.fingerprint_hash) throw new _hot_updater_plugin_core.ReleaseManagementError("SCOPE_MOVE_UNSUPPORTED", "Changing a fingerprint target requires an atomic Release scope move.");
+	return {
+		...patch.enabled === void 0 ? {} : { enabled: patch.enabled },
+		...patch.message === void 0 ? {} : { message: patch.message },
+		...patch.rolloutCohortCount === void 0 ? {} : { rollout_cohort_count: patch.rolloutCohortCount },
+		...patch.shouldForceUpdate === void 0 ? {} : { should_force_update: patch.shouldForceUpdate },
+		...patch.targetAppVersion === void 0 ? {} : { target_app_version: patch.targetAppVersion },
+		...patch.targetCohorts === void 0 ? {} : { target_cohorts: [...patch.targetCohorts] },
+		updated_at_ms: updatedAtMs
+	};
+};
+const mutationResult = ({ catalog, release }) => ({
+	attempts: 1,
+	catalog,
+	release
+});
+/** The scope a catalog row names, for a rebuild. */
+const catalogScope = async (tx, scopeKey) => {
+	const row = await tx.findOne("release_catalogs", { scope_key: scopeKey });
+	if (row === null) throw new Error(`Release catalog "${scopeKey}" was not found.`);
+	return {
+		channelId: row.channel_id,
+		channelName: (0, _hot_updater_core.decodeChannelKey)(row.channel_key),
+		fingerprintHash: row.fingerprint_hash,
+		platform: row.platform,
+		scopeKey: row.scope_key,
+		strategy: row.strategy
+	};
+};
+/**
+* Core's typed writes: each runs in one engine transaction rooted at the
+* catalogs it changes, so a concurrent change reruns it instead of
+* publishing a stale catalog.
+*/
+const createCoreOperations = (db, { now = Date.now } = {}) => {
+	const ensureChannel = async (name) => (await require_writes.insertChannel(db, {
+		id: `channel:${(0, _hot_updater_core.encodeChannelKey)(name)}`,
+		name
+	})).row;
+	/**
+	* Runs a write that ensured its channels first. A channel deleted between
+	* that and the write refuses the write, so it runs again and ensures it anew.
+	*/
+	const withChannels = async (write) => {
+		for (let attempt = 1;; attempt += 1) try {
+			return await write();
+		} catch (error) {
+			if (attempt < 3 && error instanceof require_errors.DatabaseConstraintError && error.reason === "not_found" && error.model === "channels") continue;
+			throw error;
+		}
+	};
+	const deployOnce = async (deployments) => {
+		const channels = /* @__PURE__ */ new Map();
+		for (const { release } of deployments) if (!channels.has(release.channel)) channels.set(release.channel, await ensureChannel(release.channel));
+		const platforms = /* @__PURE__ */ new Map();
+		for (const deployment of deployments) {
+			if (!("bundleId" in deployment) || platforms.has(deployment.bundleId)) continue;
+			const row = await db.findOne("bundles", { id: deployment.bundleId });
+			if (row === null) throw new _hot_updater_plugin_core.DatabaseBundleNotFoundError(deployment.bundleId);
+			platforms.set(deployment.bundleId, require_reads.toBundleRow(row).platform);
+		}
+		const updatedAtMs = now();
+		return (await require_releases.changeReleases(db, deployments.map((deployment) => {
+			const { release: policy } = deployment;
+			const stored = "bundleId" in deployment;
+			const bundleId = stored ? deployment.bundleId : deployment.bundle.id;
+			const platform = stored ? platforms.get(deployment.bundleId) : deployment.bundle.platform;
+			const scope = scopeOf(channels.get(policy.channel), platform, policy.fingerprintHash);
+			return {
+				scope,
+				...stored ? {} : { bundle: {
+					row: (0, _hot_updater_plugin_core.bundleToRow)(deployment.bundle),
+					patches: (0, _hot_updater_plugin_core.bundleToPatchRows)(deployment.bundle)
+				} },
+				change: {
+					operation: "insert",
+					row: {
+						bundle_id: bundleId,
+						channel_id: scope.channelId,
+						created_at_ms: updatedAtMs,
+						enabled: policy.enabled,
+						fingerprint_hash: policy.fingerprintHash,
+						kind: "BUNDLE",
+						message: policy.message,
+						operation: "DEPLOY",
+						platform,
+						revision: 1,
+						rollout_cohort_count: policy.rolloutCohortCount ?? 1e3,
+						scope_key: scope.scopeKey,
+						should_force_update: policy.shouldForceUpdate,
+						source_release_id: null,
+						strategy: scope.strategy,
+						target_app_version: policy.targetAppVersion,
+						target_cohorts: policy.targetCohorts ?? [],
+						updated_at_ms: updatedAtMs
+					}
+				},
+				updatedAtMs
+			};
+		}))).map(mutationResult);
+	};
+	return {
+		deploy: (deployments) => withChannels(() => deployOnce(deployments)),
+		updateReleasePolicy: (input) => {
+			const updatedAtMs = now();
+			return db.transaction(async (tx) => {
+				const { release, scope } = await loadTarget(tx, input);
+				return mutationResult(await require_releases.changeRelease(tx, {
+					scope,
+					change: {
+						operation: "update",
+						id: release.id,
+						update: policyUpdate(release, input.patch, updatedAtMs)
+					},
+					updatedAtMs
+				}));
+			});
+		},
+		preflightReleasePolicy: (input) => {
+			const updatedAtMs = now();
+			return dryRun(db, async (tx) => {
+				const { release, scope } = await loadTarget(tx, input);
+				const stored = await require_releases.readCatalog(tx, scope.scopeKey);
+				const changed = await require_releases.changeRelease(tx, {
+					scope,
+					change: {
+						operation: "update",
+						id: release.id,
+						update: policyUpdate(release, input.patch, updatedAtMs)
+					},
+					updatedAtMs
+				});
+				return {
+					catalog: changed.catalog,
+					currentCatalog: stored.catalog,
+					diagnostics: changed.diagnostics,
+					expectedReleaseRevision: release.revision,
+					release: changed.release
+				};
+			});
+		},
+		deleteRelease: (input) => db.transaction(async (tx) => {
+			const { release, scope } = await loadTarget(tx, input);
+			if (release.enabled) throw new _hot_updater_plugin_core.ReleaseManagementError("ENABLED_RELEASE", `Disable Release "${release.id}" before hard deletion.`);
+			return mutationResult(await require_releases.changeRelease(tx, {
+				scope,
+				change: {
+					operation: "delete",
+					id: release.id
+				},
+				updatedAtMs: now()
+			}));
+		}),
+		promoteRelease: (input) => withChannels(async () => {
+			const checkSource = (source) => {
+				if (source.kind !== "BUNDLE" || source.bundle_id === null) throw new _hot_updater_plugin_core.ReleaseManagementError("TARGET_RELEASE_INVALID", "Only a Bundle Release can be promoted.");
+			};
+			checkSource((await db.transaction((tx) => loadTarget(tx, input))).release);
+			const targetChannel = input.targetChannel.trim();
+			if (targetChannel.length === 0) throw new _hot_updater_plugin_core.ReleaseManagementError("TARGET_RELEASE_INVALID", "Promotion requires a target channel.");
+			const channel = await ensureChannel(targetChannel);
+			const updatedAtMs = now();
+			return db.transaction(async (tx) => {
+				const { release: source, scope: sourceScope } = await loadTarget(tx, input);
+				checkSource(source);
+				const targetScope = scopeOf(channel, source.platform, source.fingerprint_hash);
+				if (targetScope.scopeKey === sourceScope.scopeKey) throw new _hot_updater_plugin_core.ReleaseManagementError("TARGET_RELEASE_INVALID", "Source and target Release scopes are the same.");
+				const { rows } = await tx.findMany("releases", {
+					index: "byScope",
+					where: { scope_key: targetScope.scopeKey },
+					order: "desc",
+					limit: 1
+				});
+				const floor = [
+					rows[0]?.id ?? null,
+					source.id,
+					source.bundle_id
+				].filter((id) => id !== null && (0, _hot_updater_plugin_core.isUUIDv7)(id)).sort().at(-1);
+				const moved = input.action === "move" ? await require_releases.changeRelease(tx, {
+					scope: sourceScope,
+					change: {
+						operation: "update",
+						id: source.id,
+						update: {
+							enabled: false,
+							updated_at_ms: updatedAtMs
+						}
+					},
+					updatedAtMs
+				}) : null;
+				const target = await require_releases.changeRelease(tx, {
+					scope: targetScope,
+					change: {
+						operation: "insert",
+						row: {
+							...source,
+							id: (0, _hot_updater_plugin_core.createUUIDv7After)(floor ?? null, updatedAtMs),
+							revision: 1,
+							scope_key: targetScope.scopeKey,
+							channel_id: targetScope.channelId,
+							enabled: true,
+							rollout_cohort_count: 1e3,
+							target_cohorts: [],
+							operation: "PROMOTE",
+							source_release_id: source.id,
+							created_at_ms: updatedAtMs,
+							updated_at_ms: updatedAtMs
+						}
+					},
+					updatedAtMs
+				});
+				return {
+					source: moved === null ? null : mutationResult(moved),
+					target: mutationResult(target)
+				};
+			});
+		}),
+		rebuildReleaseCatalog: (scopeKey) => {
+			const updatedAtMs = now();
+			return db.transaction(async (tx) => {
+				const { current: _current, ...rebuilt } = await require_releases.rebuildScope(tx, await catalogScope(tx, scopeKey), updatedAtMs);
+				return {
+					attempts: 1,
+					...rebuilt
+				};
+			});
+		},
+		preflightReleaseCatalogRebuild: (scopeKey) => {
+			const updatedAtMs = now();
+			return dryRun(db, async (tx) => {
+				const rebuilt = await require_releases.rebuildScope(tx, await catalogScope(tx, scopeKey), updatedAtMs);
+				return {
+					changed: rebuilt.changed,
+					currentCatalog: rebuilt.current,
+					diagnostics: rebuilt.diagnostics,
+					projectedCatalog: rebuilt.catalog
+				};
+			});
+		},
+		ensureChannel,
+		deleteChannel: (id) => require_writes.deleteChannel(db, id),
+		updateBundle: (id, update) => db.transaction(async (tx) => {
+			const current = await tx.findOne("bundles", { id });
+			if (current === null) throw new _hot_updater_plugin_core.DatabaseBundleNotFoundError(id);
+			const { patches, ...fields } = update;
+			const next = {
+				...(0, _hot_updater_plugin_core.rowToBundle)(require_reads.toBundleRow(current)),
+				...fields,
+				id
+			};
+			const { id: _id, ...set } = (0, _hot_updater_plugin_core.bundleToRow)(next);
+			require_writes.updateBundle(tx, current, set);
+			if (patches !== void 0) await require_writes.replaceBundlePatches(tx, current, (0, _hot_updater_plugin_core.bundleToPatchRows)({
+				...next,
+				patches
+			}));
+		}),
+		deleteBundles: async (ids) => {
+			try {
+				await db.transaction(async (tx) => {
+					for (const id of new Set(ids)) {
+						const current = await tx.findOne("bundles", { id });
+						if (current !== null) await require_writes.deleteBundle(tx, current);
+					}
+				});
+			} catch (error) {
+				if (error instanceof require_errors.DatabaseConstraintError && error.reason === "referenced") throw new _hot_updater_plugin_core_internal.DatabaseRowReferencedError();
+				throw error;
+			}
+		}
+	};
+};
+//#endregion
+exports.createCoreOperations = createCoreOperations;