@hot-updater/plugin-core 0.36.7 → 1.0.0-rc.0

package/dist/releaseCatalogCompiler.mjs

@@ -0,0 +1,386 @@
+import { isUUIDv7 as isUUIDv7$1 } from "./uuidv7.mjs";
+import { coerce, compare, normalize, parseRange, satisfies } from "./node_modules/.pnpm/verkit@0.3.2/node_modules/verkit/dist/index.mjs";
+import { MAX_COMPILED_CATALOG_BYTES, MAX_DISTINCT_TARGET_COHORTS_PER_SCOPE, MAX_TARGET_COHORTS_PER_RELEASE, NUMERIC_COHORT_SIZE, RELEASE_CATALOG_FALLBACK_POLICY, RELEASE_CATALOG_SCHEMA_VERSION, getNumericCohortValue, getRolledOutNumericCohorts, isCustomCohort, normalizeCohortValue, normalizeRolloutCohortCount } from "@hot-updater/core";
+//#region src/releaseCatalogCompiler.ts
+var ReleaseCatalogCompilationError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "ReleaseCatalogCompilationError";
+		this.code = code;
+	}
+};
+function compareBounds(left, right) {
+	return compare(left, right);
+}
+function strongerLower(current, candidate) {
+	if (current === null) return candidate;
+	const compared = compareBounds(candidate.version, current.version);
+	if (compared > 0) return candidate;
+	if (compared < 0) return current;
+	return {
+		version: current.version,
+		inclusive: current.inclusive && candidate.inclusive
+	};
+}
+function strongerUpper(current, candidate) {
+	if (current === null) return candidate;
+	const compared = compareBounds(candidate.version, current.version);
+	if (compared < 0) return candidate;
+	if (compared > 0) return current;
+	return {
+		version: current.version,
+		inclusive: current.inclusive && candidate.inclusive
+	};
+}
+function comparatorVersion(comparator) {
+	const version = comparator.version && normalize(comparator.version);
+	if (version === null) throw new ReleaseCatalogCompilationError("INVALID_TARGET_RANGE", `Invalid comparator: ${comparator.value}`);
+	return version;
+}
+function comparatorSetToInterval(comparators) {
+	let lower = null;
+	let upper = null;
+	for (const comparator of comparators) {
+		if (comparator.version === null) continue;
+		const version = comparatorVersion(comparator);
+		if (comparator.operator === "") {
+			lower = strongerLower(lower, {
+				inclusive: true,
+				version
+			});
+			upper = strongerUpper(upper, {
+				inclusive: true,
+				version
+			});
+		} else if (comparator.operator === ">") lower = strongerLower(lower, {
+			inclusive: false,
+			version
+		});
+		else if (comparator.operator === ">=") lower = strongerLower(lower, {
+			inclusive: true,
+			version
+		});
+		else if (comparator.operator === "<") upper = strongerUpper(upper, {
+			inclusive: false,
+			version
+		});
+		else if (comparator.operator === "<=") upper = strongerUpper(upper, {
+			inclusive: true,
+			version
+		});
+	}
+	if (lower !== null && upper !== null) {
+		const compared = compareBounds(lower.version, upper.version);
+		if (compared > 0 || compared === 0 && (!lower.inclusive || !upper.inclusive)) return null;
+	}
+	return {
+		lower,
+		upper
+	};
+}
+function rangeToIntervals(range) {
+	try {
+		return parseRange(range).sets.flatMap((comparators) => {
+			const interval = comparatorSetToInterval(comparators);
+			return interval === null ? [] : [interval];
+		});
+	} catch {
+		throw new ReleaseCatalogCompilationError("INVALID_TARGET_RANGE", `Invalid target app-version range: ${range}`);
+	}
+}
+function releaseDescriptor(release) {
+	return {
+		releaseId: release.id,
+		kind: release.kind,
+		bundleId: release.bundleId,
+		rolloutCohortCount: release.rolloutCohortCount,
+		targetCohorts: [...new Set(release.targetCohorts)].sort(),
+		shouldForceUpdate: release.shouldForceUpdate,
+		message: release.message
+	};
+}
+function validateReleases(releases, strategy) {
+	const enabled = releases.filter((release) => release.enabled).sort((left, right) => right.id.localeCompare(left.id));
+	const seenIds = /* @__PURE__ */ new Set();
+	for (const release of enabled) {
+		if (!isUUIDv7$1(release.id)) throw new ReleaseCatalogCompilationError("INVALID_RELEASE", `Release ${release.id} must use a canonical lowercase UUIDv7 ID`);
+		if (seenIds.has(release.id)) throw new ReleaseCatalogCompilationError("INVALID_RELEASE", `Duplicate Release ID: ${release.id}`);
+		seenIds.add(release.id);
+		if (release.strategy !== strategy) throw new ReleaseCatalogCompilationError("INVALID_RELEASE", `Release ${release.id} has the wrong strategy`);
+		if (release.kind === "BUNDLE" && release.bundleId === null || release.kind === "EMBEDDED" && release.bundleId !== null) throw new ReleaseCatalogCompilationError("INVALID_RELEASE", `Release ${release.id} has an invalid kind/Bundle combination`);
+		if (release.targetCohorts.length > MAX_TARGET_COHORTS_PER_RELEASE) throw new ReleaseCatalogCompilationError("TARGET_COHORT_LIMIT", `Release ${release.id} exceeds ${MAX_TARGET_COHORTS_PER_RELEASE} target cohorts`);
+		if (strategy === "APP_VERSION" && (release.targetAppVersion === null || release.fingerprintHash !== null)) throw new ReleaseCatalogCompilationError("INVALID_RELEASE", `Release ${release.id} has an invalid app-version target`);
+		if (strategy === "FINGERPRINT" && (release.fingerprintHash === null || release.targetAppVersion !== null)) throw new ReleaseCatalogCompilationError("INVALID_RELEASE", `Release ${release.id} has an invalid fingerprint target`);
+	}
+	return enabled.filter((release) => release.kind === "BUNDLE");
+}
+function collectFrontierReleaseIds(releases) {
+	if (releases.every((release) => normalizeRolloutCohortCount(release.rolloutCohortCount) >= NUMERIC_COHORT_SIZE)) {
+		const retained = /* @__PURE__ */ new Set();
+		const bundleIds = /* @__PURE__ */ new Set();
+		let embedded = false;
+		for (const release of releases) {
+			if (release.kind === "EMBEDDED") {
+				if (!embedded) {
+					embedded = true;
+					retained.add(release.id);
+				}
+			} else if (release.bundleId !== null && bundleIds.size < 11 && !bundleIds.has(release.bundleId)) {
+				bundleIds.add(release.bundleId);
+				retained.add(release.id);
+			}
+			if (embedded && bundleIds.size >= 11) break;
+		}
+		return retained;
+	}
+	const explicitTargetCohorts = new Set(releases.flatMap((release) => release.targetCohorts));
+	const cohortStates = [
+		void 0,
+		...Array.from({ length: 1e3 }, (_, index) => String(index + 1)),
+		...[...explicitTargetCohorts].sort(),
+		"release-catalog-non-targeted-cohort"
+	].map((cohort) => {
+		const normalized = cohort === void 0 ? void 0 : normalizeCohortValue(cohort);
+		return {
+			isCustom: normalized !== void 0 && isCustomCohort(normalized),
+			normalized,
+			numeric: normalized === void 0 ? null : getNumericCohortValue(normalized),
+			bundleIds: /* @__PURE__ */ new Set(),
+			embedded: false,
+			complete: false
+		};
+	});
+	const stateIndexesByCohort = /* @__PURE__ */ new Map();
+	const fullRolloutStateIndexes = [];
+	for (const [index, state] of cohortStates.entries()) {
+		if (state.normalized !== void 0) {
+			const indexes = stateIndexesByCohort.get(state.normalized) ?? [];
+			indexes.push(index);
+			stateIndexesByCohort.set(state.normalized, indexes);
+		}
+		if (state.normalized === void 0 || state.numeric !== null || state.isCustom) fullRolloutStateIndexes.push(index);
+	}
+	const retained = /* @__PURE__ */ new Set();
+	let incompleteStateCount = cohortStates.length;
+	for (const release of releases) {
+		const rolloutCohortCount = normalizeRolloutCohortCount(release.rolloutCohortCount);
+		const eligibleStateIndexes = /* @__PURE__ */ new Set();
+		if (rolloutCohortCount >= NUMERIC_COHORT_SIZE) for (const index of fullRolloutStateIndexes) eligibleStateIndexes.add(index);
+		else if (rolloutCohortCount > 0) for (const numericCohort of getRolledOutNumericCohorts(release.id, rolloutCohortCount)) for (const index of stateIndexesByCohort.get(String(numericCohort)) ?? []) eligibleStateIndexes.add(index);
+		for (const targetCohort of new Set(release.targetCohorts.map(normalizeCohortValue))) for (const index of stateIndexesByCohort.get(targetCohort) ?? []) eligibleStateIndexes.add(index);
+		for (const index of eligibleStateIndexes) {
+			const state = cohortStates[index];
+			if (state.complete) continue;
+			if (release.kind === "EMBEDDED") {
+				if (!state.embedded) {
+					state.embedded = true;
+					retained.add(release.id);
+				}
+			} else if (release.bundleId !== null && state.bundleIds.size < 11 && !state.bundleIds.has(release.bundleId)) {
+				state.bundleIds.add(release.bundleId);
+				retained.add(release.id);
+			}
+			if (state.embedded && state.bundleIds.size >= 11) {
+				state.complete = true;
+				incompleteStateCount -= 1;
+			}
+		}
+		if (incompleteStateCount === 0) break;
+	}
+	return retained;
+}
+function intervalContainsSegment(interval, segment) {
+	if (interval.lower !== null) {
+		if (segment.lower === null) return false;
+		const compared = compareBounds(segment.lower.version, interval.lower.version);
+		if (compared < 0 || compared === 0 && segment.lower.inclusive && !interval.lower.inclusive) return false;
+	}
+	if (interval.upper !== null) {
+		if (segment.upper === null) return false;
+		const compared = compareBounds(segment.upper.version, interval.upper.version);
+		if (compared > 0 || compared === 0 && segment.upper.inclusive && !interval.upper.inclusive) return false;
+	}
+	return true;
+}
+function atomicVersionSegments(intervals) {
+	const endpoints = [...new Set(intervals.flatMap((interval) => [interval.lower?.version, interval.upper?.version].filter((version) => version !== void 0)))].sort(compareBounds);
+	if (endpoints.length === 0) return [{
+		lower: null,
+		upper: null
+	}];
+	const segments = [{
+		lower: null,
+		upper: {
+			inclusive: false,
+			version: endpoints[0]
+		}
+	}];
+	for (let index = 0; index < endpoints.length; index += 1) {
+		const endpoint = endpoints[index];
+		segments.push({
+			lower: {
+				inclusive: true,
+				version: endpoint
+			},
+			upper: {
+				inclusive: true,
+				version: endpoint
+			}
+		});
+		const next = endpoints[index + 1];
+		if (next !== void 0) segments.push({
+			lower: {
+				inclusive: false,
+				version: endpoint
+			},
+			upper: {
+				inclusive: false,
+				version: next
+			}
+		});
+	}
+	segments.push({
+		lower: {
+			inclusive: false,
+			version: endpoints.at(-1)
+		},
+		upper: null
+	});
+	return segments;
+}
+function sameIndexes(left, right) {
+	return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function mergeSegments(segments) {
+	const merged = [];
+	for (const segment of segments) {
+		const previous = merged.at(-1);
+		if (previous && sameIndexes(previous.releaseIndexes, segment.releaseIndexes) && sameIndexes(previous.rollbackReleaseIndexes, segment.rollbackReleaseIndexes)) merged[merged.length - 1] = {
+			...previous,
+			upper: segment.upper
+		};
+		else merged.push(segment);
+	}
+	return merged;
+}
+function compileAppVersion(releases) {
+	const ranges = /* @__PURE__ */ new Map();
+	for (const release of releases) ranges.set(release.id, rangeToIntervals(release.targetAppVersion));
+	const segmentReleases = atomicVersionSegments([...ranges.values()].flat()).map((segment) => {
+		const applicable = releases.filter((release) => ranges.get(release.id).some((range) => intervalContainsSegment(range, segment)));
+		return {
+			rollbackIds: new Set(applicable.map(({ id }) => id)),
+			segment,
+			retainedIds: collectFrontierReleaseIds(applicable)
+		};
+	});
+	const retainedIds = new Set(segmentReleases.flatMap(({ retainedIds, rollbackIds }) => [...retainedIds, ...rollbackIds]));
+	const retainedReleases = releases.filter((release) => retainedIds.has(release.id));
+	const descriptorIndex = new Map(retainedReleases.map((release, index) => [release.id, index]));
+	return {
+		envelope: {
+			fallbackPolicy: RELEASE_CATALOG_FALLBACK_POLICY,
+			schemaVersion: RELEASE_CATALOG_SCHEMA_VERSION,
+			segments: mergeSegments(segmentReleases.map(({ segment, retainedIds, rollbackIds }) => ({
+				...segment,
+				releaseIndexes: releases.filter((release) => retainedIds.has(release.id)).map((release) => descriptorIndex.get(release.id)).filter((index) => index !== void 0),
+				rollbackReleaseIndexes: releases.filter((release) => rollbackIds.has(release.id)).map((release) => descriptorIndex.get(release.id)).filter((index) => index !== void 0)
+			})).filter((segment) => segment.releaseIndexes.length > 0 || segment.rollbackReleaseIndexes.length > 0)),
+			strategy: "APP_VERSION"
+		},
+		retainedReleases
+	};
+}
+function compileFingerprint(releases) {
+	const retainedIds = collectFrontierReleaseIds(releases);
+	const retainedReleases = releases;
+	return {
+		envelope: {
+			fallbackPolicy: RELEASE_CATALOG_FALLBACK_POLICY,
+			releaseIndexes: retainedReleases.map((release, index) => retainedIds.has(release.id) ? index : -1).filter((index) => index >= 0),
+			rollbackReleaseIndexes: retainedReleases.map((_, index) => index),
+			schemaVersion: RELEASE_CATALOG_SCHEMA_VERSION,
+			strategy: "FINGERPRINT"
+		},
+		retainedReleases
+	};
+}
+async function sha256(value) {
+	const digest = await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(value));
+	return `sha256:${[...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+}
+function canonicalStringify(value) {
+	if (value === null || typeof value !== "object") return JSON.stringify(value);
+	if (Array.isArray(value)) return `[${value.map(canonicalStringify).join(",")}]`;
+	const record = value;
+	return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalStringify(record[key])}`).join(",")}}`;
+}
+async function compileReleaseCatalog(input) {
+	const releases = validateReleases(input.releases, input.strategy);
+	const targetCohorts = new Set(releases.flatMap((release) => release.targetCohorts));
+	if (targetCohorts.size > MAX_DISTINCT_TARGET_COHORTS_PER_SCOPE) throw new ReleaseCatalogCompilationError("DISTINCT_TARGET_COHORT_LIMIT", `Scope exceeds ${MAX_DISTINCT_TARGET_COHORTS_PER_SCOPE} distinct target cohorts`);
+	const { envelope, retainedReleases } = input.strategy === "APP_VERSION" ? compileAppVersion(releases) : compileFingerprint(releases);
+	const payload = {
+		...envelope,
+		releaseDescriptors: retainedReleases.map(releaseDescriptor)
+	};
+	const canonicalPayload = canonicalStringify(payload);
+	const byteSize = new TextEncoder().encode(canonicalPayload).byteLength;
+	if (byteSize > MAX_COMPILED_CATALOG_BYTES) throw new ReleaseCatalogCompilationError("CATALOG_OVERSIZE", `Compiled Release catalog is ${byteSize} bytes; maximum is ${MAX_COMPILED_CATALOG_BYTES}`);
+	return {
+		byteSize,
+		canonicalPayload,
+		catalogHash: await sha256(canonicalPayload),
+		diagnostics: {
+			byteSize,
+			descriptorCount: payload.releaseDescriptors.length,
+			distinctTargetCohortCount: targetCohorts.size,
+			releaseCount: releases.length,
+			segmentCount: payload.strategy === "APP_VERSION" ? payload.segments.length : 1
+		},
+		payload
+	};
+}
+function versionInSegment(version, segment) {
+	if (segment.lower !== null) {
+		const compared = compareBounds(version, segment.lower.version);
+		if (compared < 0 || compared === 0 && !segment.lower.inclusive) return false;
+	}
+	if (segment.upper !== null) {
+		const compared = compareBounds(version, segment.upper.version);
+		if (compared > 0 || compared === 0 && !segment.upper.inclusive) return false;
+	}
+	return true;
+}
+function canonicalizeAppVersion(appVersion) {
+	return coerce(appVersion);
+}
+function projectCompiledCatalog(catalog, appVersion) {
+	let indexes;
+	if (catalog.strategy === "FINGERPRINT") indexes = catalog.releaseIndexes;
+	else {
+		const canonicalVersion = appVersion && canonicalizeAppVersion(appVersion);
+		if (!canonicalVersion) return [];
+		indexes = catalog.segments.find((segment) => versionInSegment(canonicalVersion, segment))?.releaseIndexes ?? [];
+	}
+	return indexes.map((index) => catalog.releaseDescriptors[index]);
+}
+function projectCompiledRollbackCatalog(catalog, appVersion) {
+	let indexes;
+	if (catalog.strategy === "FINGERPRINT") indexes = catalog.rollbackReleaseIndexes ?? catalog.releaseIndexes;
+	else {
+		const canonicalVersion = appVersion && canonicalizeAppVersion(appVersion);
+		if (!canonicalVersion) return [];
+		const segment = catalog.segments.find((candidate) => versionInSegment(canonicalVersion, candidate));
+		indexes = segment?.rollbackReleaseIndexes ?? segment?.releaseIndexes ?? [];
+	}
+	return indexes.map((index) => catalog.releaseDescriptors[index]);
+}
+function referenceCompatibleReleases(releases, appVersion) {
+	const canonicalVersion = canonicalizeAppVersion(appVersion);
+	if (!canonicalVersion) return [];
+	return releases.filter((release) => release.enabled && release.targetAppVersion !== null && satisfies(canonicalVersion, release.targetAppVersion));
+}
+//#endregion
+export { ReleaseCatalogCompilationError, canonicalizeAppVersion, compileReleaseCatalog, projectCompiledCatalog, projectCompiledRollbackCatalog, referenceCompatibleReleases };

package/dist/releaseCatalogMutation.cjs

@@ -0,0 +1,303 @@
+require("./_virtual/_rolldown/runtime.cjs");
+const require_uuidv7 = require("./uuidv7.cjs");
+const require_databaseRows = require("./databaseRows.cjs");
+const require_releaseCatalogCompiler = require("./releaseCatalogCompiler.cjs");
+let _hot_updater_core = require("@hot-updater/core");
+//#region src/releaseCatalogMutation.ts
+const RELEASE_PAGE_SIZE = 1e3;
+const DEFAULT_MAX_ATTEMPTS = 3;
+var ReleaseCatalogMutationError = class extends Error {
+	name = "ReleaseCatalogMutationError";
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+	}
+};
+const readScopeReleases = async (database, scopeKey) => {
+	const releases = [];
+	let afterReleaseId;
+	for (;;) {
+		const page = await database.models.releases.findManyByScope({
+			scopeKey,
+			...afterReleaseId === void 0 ? {} : { afterReleaseId },
+			limit: RELEASE_PAGE_SIZE,
+			consistency: "strong"
+		});
+		for (const row of page) {
+			if (row.scope_key !== scopeKey) throw new ReleaseCatalogMutationError("INVALID_SCOPE", `Release "${row.id}" was returned for the wrong catalog scope`);
+			if (releases.at(-1)?.id === row.id) throw new ReleaseCatalogMutationError("INVALID_SCOPE", `Release "${row.id}" was returned more than once`);
+			releases.push(row);
+		}
+		if (page.length < RELEASE_PAGE_SIZE) return releases;
+		const next = page.at(-1)?.id;
+		if (next === void 0 || next === afterReleaseId) throw new ReleaseCatalogMutationError("INVALID_SCOPE", "Release scope paging did not advance");
+		afterReleaseId = next;
+	}
+};
+const validateScope = (scope) => {
+	const channelKey = (0, _hot_updater_core.encodeChannelKey)(scope.channelName);
+	if (scope.strategy === "FINGERPRINT" !== (scope.fingerprintHash !== null)) throw new ReleaseCatalogMutationError("INVALID_SCOPE", "Release catalog strategy and fingerprint are inconsistent");
+	const expectedScopeKey = scope.strategy === "APP_VERSION" ? (0, _hot_updater_core.createReleaseCatalogScopeKey)({
+		channelKey,
+		platform: scope.platform,
+		strategy: "APP_VERSION"
+	}) : (0, _hot_updater_core.createReleaseCatalogScopeKey)({
+		channelKey,
+		fingerprintHash: scope.fingerprintHash ?? "",
+		platform: scope.platform,
+		strategy: "FINGERPRINT"
+	});
+	if (scope.scopeKey !== expectedScopeKey) throw new ReleaseCatalogMutationError("INVALID_SCOPE", "Release catalog scope metadata is inconsistent");
+};
+const applyMutation = (rows, scope, mutation) => {
+	const currentIndex = mutation.operation === "insert" ? -1 : rows.findIndex(({ id }) => id === mutation.id);
+	const current = currentIndex < 0 ? void 0 : rows[currentIndex];
+	if (mutation.operation === "insert") {
+		const latestId = rows.at(-1)?.id;
+		if (mutation.row.scope_key !== scope.scopeKey || mutation.row.channel_id !== scope.channelId || mutation.row.platform !== scope.platform || mutation.row.strategy !== scope.strategy || mutation.row.fingerprint_hash !== scope.fingerprintHash || mutation.row.revision !== 1) throw new ReleaseCatalogMutationError("INVALID_SCOPE", "Inserted Release does not match its catalog scope");
+		if (latestId !== void 0 && mutation.row.id <= latestId) throw new ReleaseCatalogMutationError("NON_MONOTONIC_RELEASE_ID", `Release "${mutation.row.id}" must sort after "${latestId}"`);
+		return {
+			change: {
+				model: "releases",
+				operation: "insert",
+				row: mutation.row
+			},
+			expectedRevision: null,
+			nextRows: [...rows, mutation.row],
+			release: mutation.row
+		};
+	}
+	if (current === void 0) throw new ReleaseCatalogMutationError("RELEASE_NOT_FOUND", `Release "${mutation.id}" was not found in scope "${scope.scopeKey}"`);
+	if (mutation.operation === "delete") return {
+		change: {
+			model: "releases",
+			operation: "delete",
+			where: { id: mutation.id }
+		},
+		expectedRevision: current.revision,
+		nextRows: rows.filter(({ id }) => id !== mutation.id),
+		release: null
+	};
+	const release = {
+		...current,
+		...mutation.update,
+		revision: current.revision + 1
+	};
+	return {
+		change: {
+			model: "releases",
+			operation: "update",
+			where: { id: mutation.id },
+			update: {
+				...mutation.update,
+				revision: release.revision
+			}
+		},
+		expectedRevision: current.revision,
+		nextRows: rows.map((row) => row.id === release.id ? release : row),
+		release
+	};
+};
+const catalogIdentity = (current, rows) => {
+	if (current !== null) return current.catalog_id;
+	if (rows.length > 0) throw new ReleaseCatalogMutationError("CATALOG_IDENTITY_MISSING", "Catalog history is missing. Restore its catalog row from backup before rebuilding or deploying.");
+	return require_uuidv7.createUUIDv7();
+};
+const readCatalogScope = async (database, scopeKey) => {
+	let currentCatalog = await database.models.releaseCatalogs.findByScopeKey(scopeKey);
+	let rows = await readScopeReleases(database, scopeKey);
+	if (currentCatalog === null && rows.length > 0) {
+		currentCatalog = await database.models.releaseCatalogs.findByScopeKey(scopeKey);
+		if (currentCatalog !== null) rows = await readScopeReleases(database, scopeKey);
+	}
+	return {
+		currentCatalog,
+		rows
+	};
+};
+const prepareReleaseCatalogMutation = async (database, mutationInput) => {
+	const { rows, currentCatalog } = await readCatalogScope(database, mutationInput.scope.scopeKey);
+	const applied = applyMutation(rows, mutationInput.scope, mutationInput.mutation);
+	const compilation = await require_releaseCatalogCompiler.compileReleaseCatalog({
+		strategy: mutationInput.scope.strategy,
+		releases: applied.nextRows.map(require_databaseRows.releaseRowToRelease)
+	});
+	const generation = (currentCatalog?.generation ?? 0) + 1;
+	if (!Number.isSafeInteger(generation)) throw new ReleaseCatalogMutationError("CATALOG_GENERATION_EXHAUSTED", `Catalog "${mutationInput.scope.scopeKey}" exhausted its generation counter`);
+	return {
+		applied,
+		catalog: {
+			scope_key: mutationInput.scope.scopeKey,
+			catalog_id: catalogIdentity(currentCatalog, rows),
+			strategy: mutationInput.scope.strategy,
+			channel_id: mutationInput.scope.channelId,
+			channel_key: (0, _hot_updater_core.encodeChannelKey)(mutationInput.scope.channelName),
+			platform: mutationInput.scope.platform,
+			fingerprint_hash: mutationInput.scope.fingerprintHash,
+			generation,
+			payload: compilation.canonicalPayload,
+			catalog_hash: compilation.catalogHash,
+			byte_size: compilation.byteSize,
+			is_tombstone: compilation.payload.releaseDescriptors.length === 0,
+			updated_at_ms: mutationInput.updatedAtMs ?? Date.now()
+		},
+		compilation,
+		currentCatalog,
+		mutationInput
+	};
+};
+async function preflightReleaseCatalogMutation(input) {
+	validateScope(input.scope);
+	const prepared = await prepareReleaseCatalogMutation(input.database, input);
+	return {
+		catalog: prepared.catalog,
+		currentCatalog: prepared.currentCatalog,
+		diagnostics: prepared.compilation.diagnostics,
+		expectedReleaseRevision: prepared.applied.expectedRevision,
+		release: prepared.applied.release
+	};
+}
+async function commitReleaseCatalogMutations(input) {
+	if (input.mutations.length === 0) return [];
+	const scopeKeys = /* @__PURE__ */ new Set();
+	for (const mutation of input.mutations) {
+		validateScope(mutation.scope);
+		if (scopeKeys.has(mutation.scope.scopeKey)) throw new ReleaseCatalogMutationError("INVALID_SCOPE", `A batch cannot mutate catalog scope "${mutation.scope.scopeKey}" more than once`);
+		scopeKeys.add(mutation.scope.scopeKey);
+	}
+	const maxAttempts = input.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+	if (!Number.isSafeInteger(maxAttempts) || maxAttempts <= 0) throw new RangeError("maxAttempts must be a positive safe integer");
+	for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+		const prepared = await Promise.all(input.mutations.map((mutationInput) => prepareReleaseCatalogMutation(input.database, mutationInput)));
+		const result = await input.database.commit({
+			expectations: prepared.flatMap(({ applied, currentCatalog, mutationInput }) => [{
+				model: "releases",
+				id: mutationInput.mutation.operation === "insert" ? mutationInput.mutation.row.id : mutationInput.mutation.id,
+				revision: applied.expectedRevision
+			}, {
+				model: "releaseCatalogs",
+				scopeKey: mutationInput.scope.scopeKey,
+				generation: currentCatalog?.generation ?? null
+			}]),
+			changes: prepared.flatMap(({ applied, catalog, mutationInput }) => [
+				...mutationInput.companionChanges ?? [],
+				applied.change,
+				{
+					model: "releaseCatalogs",
+					operation: "put",
+					row: catalog
+				},
+				...mutationInput.trailingChanges ?? []
+			])
+		});
+		if (result.committed) return prepared.map(({ applied, catalog }) => ({
+			attempts: attempt,
+			catalog,
+			release: applied.release
+		}));
+		if (result.conflict.reason !== "version_conflict") throw new ReleaseCatalogMutationError("INVALID_SCOPE", `Release mutation failed: ${result.conflict.reason}`);
+	}
+	throw new ReleaseCatalogMutationError("VERSION_CONFLICT", `Release catalog mutation batch conflicted ${maxAttempts} times`);
+}
+async function commitReleaseCatalogMutation(input) {
+	const [result] = await commitReleaseCatalogMutations({
+		database: input.database,
+		maxAttempts: input.maxAttempts,
+		mutations: [input]
+	});
+	return result;
+}
+const catalogProjectionMatches = (current, scope, compilation) => current.strategy === scope.strategy && current.channel_id === scope.channelId && current.channel_key === (0, _hot_updater_core.encodeChannelKey)(scope.channelName) && current.platform === scope.platform && current.fingerprint_hash === scope.fingerprintHash && current.payload === compilation.canonicalPayload && current.catalog_hash === compilation.catalogHash && current.byte_size === compilation.byteSize && current.is_tombstone === (compilation.payload.releaseDescriptors.length === 0);
+async function preflightReleaseCatalogRebuild(input) {
+	validateScope(input.scope);
+	const { rows, currentCatalog } = await readCatalogScope(input.database, input.scope.scopeKey);
+	const compilation = await require_releaseCatalogCompiler.compileReleaseCatalog({
+		releases: rows.map(require_databaseRows.releaseRowToRelease),
+		strategy: input.scope.strategy
+	});
+	const changed = currentCatalog === null || !catalogProjectionMatches(currentCatalog, input.scope, compilation);
+	const generation = changed ? (currentCatalog?.generation ?? 0) + 1 : currentCatalog.generation;
+	if (!Number.isSafeInteger(generation)) throw new ReleaseCatalogMutationError("CATALOG_GENERATION_EXHAUSTED", `Catalog "${input.scope.scopeKey}" exhausted its generation counter`);
+	return {
+		changed,
+		currentCatalog,
+		diagnostics: compilation.diagnostics,
+		projectedCatalog: {
+			catalog_id: catalogIdentity(currentCatalog, rows),
+			byte_size: compilation.byteSize,
+			catalog_hash: compilation.catalogHash,
+			channel_id: input.scope.channelId,
+			channel_key: (0, _hot_updater_core.encodeChannelKey)(input.scope.channelName),
+			fingerprint_hash: input.scope.fingerprintHash,
+			generation,
+			is_tombstone: compilation.payload.releaseDescriptors.length === 0,
+			payload: compilation.canonicalPayload,
+			platform: input.scope.platform,
+			scope_key: input.scope.scopeKey,
+			strategy: input.scope.strategy,
+			updated_at_ms: changed || currentCatalog === null ? input.updatedAtMs ?? Date.now() : currentCatalog.updated_at_ms
+		}
+	};
+}
+async function rebuildReleaseCatalog(input) {
+	validateScope(input.scope);
+	const maxAttempts = input.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+	if (!Number.isSafeInteger(maxAttempts) || maxAttempts <= 0) throw new RangeError("maxAttempts must be a positive safe integer");
+	for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+		const { rows, currentCatalog } = await readCatalogScope(input.database, input.scope.scopeKey);
+		const compilation = await require_releaseCatalogCompiler.compileReleaseCatalog({
+			releases: rows.map(require_databaseRows.releaseRowToRelease),
+			strategy: input.scope.strategy
+		});
+		if (currentCatalog !== null && catalogProjectionMatches(currentCatalog, input.scope, compilation)) return {
+			attempts: attempt,
+			catalog: currentCatalog,
+			changed: false,
+			diagnostics: compilation.diagnostics
+		};
+		const generation = (currentCatalog?.generation ?? 0) + 1;
+		if (!Number.isSafeInteger(generation)) throw new ReleaseCatalogMutationError("CATALOG_GENERATION_EXHAUSTED", `Catalog "${input.scope.scopeKey}" exhausted its generation counter`);
+		const catalog = {
+			catalog_id: catalogIdentity(currentCatalog, rows),
+			byte_size: compilation.byteSize,
+			catalog_hash: compilation.catalogHash,
+			channel_id: input.scope.channelId,
+			channel_key: (0, _hot_updater_core.encodeChannelKey)(input.scope.channelName),
+			fingerprint_hash: input.scope.fingerprintHash,
+			generation,
+			is_tombstone: compilation.payload.releaseDescriptors.length === 0,
+			payload: compilation.canonicalPayload,
+			platform: input.scope.platform,
+			scope_key: input.scope.scopeKey,
+			strategy: input.scope.strategy,
+			updated_at_ms: input.updatedAtMs ?? Date.now()
+		};
+		const result = await input.database.commit({
+			changes: [{
+				model: "releaseCatalogs",
+				operation: "put",
+				row: catalog
+			}],
+			expectations: [{
+				generation: currentCatalog?.generation ?? null,
+				model: "releaseCatalogs",
+				scopeKey: input.scope.scopeKey
+			}]
+		});
+		if (result.committed) return {
+			attempts: attempt,
+			catalog,
+			changed: true,
+			diagnostics: compilation.diagnostics
+		};
+		if (result.conflict.reason !== "version_conflict") throw new ReleaseCatalogMutationError("INVALID_SCOPE", `Release catalog rebuild failed: ${result.conflict.reason}`);
+	}
+	throw new ReleaseCatalogMutationError("VERSION_CONFLICT", `Release catalog rebuild conflicted ${maxAttempts} times`);
+}
+//#endregion
+exports.ReleaseCatalogMutationError = ReleaseCatalogMutationError;
+exports.commitReleaseCatalogMutation = commitReleaseCatalogMutation;
+exports.commitReleaseCatalogMutations = commitReleaseCatalogMutations;
+exports.preflightReleaseCatalogMutation = preflightReleaseCatalogMutation;
+exports.preflightReleaseCatalogRebuild = preflightReleaseCatalogRebuild;
+exports.rebuildReleaseCatalog = rebuildReleaseCatalog;