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

package/.output/server/_ssr/api-rpc-BEX8ISai.mjs

@@ -0,0 +1,1468 @@
+import { c as createServerFn } from "./createServerFn-B2hcXoPM.mjs";
+import { t as createServerRpc } from "./createServerRpc-DB29C_5p.mjs";
+import { C as normalizeCohortValue, a as createReleaseCatalogScopeKey, b as isReleaseEligibleForCohort, i as RELEASE_CATALOG_FALLBACK_POLICY, n as MAX_COMPILED_CATALOG_BYTES, o as decodeChannelKey, p as getNumericCohortValue, r as NUMERIC_COHORT_SIZE, s as encodeChannelKey, v as getRolledOutNumericCohorts, w as normalizeRolloutCohortCount, x as isUUIDv7, y as isCustomCohort } from "./dist-BVSLTpoP.mjs";
+import { a as releaseRowToRelease, t as DatabasePluginInputError } from "./databaseRows-QlCYLi0H.mjs";
+import { n as createUUIDv7After, t as createUUIDv7 } from "./uuidv7-CaKuKXrV.mjs";
+import { a as parseSearchInstallationsInput, i as parseInstallationHistoryInput, n as parseBundleEventInsightsInput, r as parseBundleEventSummaryInput } from "./insights-input-9fEJF-ZG.mjs";
+//#region node_modules/.nitro/vite/services/ssr/assets/api-rpc-BEX8ISai.js
+var LETTER_DASH_NUMBER = "[a-zA-Z0-9-]";
+var NUMERIC_IDENTIFIER = String.raw`0|[1-9]\d*`;
+var NUMERIC_IDENTIFIER_LOOSE = String.raw`\d+`;
+var NON_NUMERIC_IDENTIFIER = String.raw`\d*[a-zA-Z-]${LETTER_DASH_NUMBER}*`;
+var MAIN_VERSION = String.raw`(${NUMERIC_IDENTIFIER})\.(${NUMERIC_IDENTIFIER})\.(${NUMERIC_IDENTIFIER})`;
+var MAIN_VERSION_LOOSE = String.raw`(${NUMERIC_IDENTIFIER_LOOSE})\.(${NUMERIC_IDENTIFIER_LOOSE})\.(${NUMERIC_IDENTIFIER_LOOSE})`;
+var PRERELEASE_IDENTIFIER = `(?:${NON_NUMERIC_IDENTIFIER}|${NUMERIC_IDENTIFIER})`;
+var PRERELEASE_IDENTIFIER_LOOSE = `(?:${NON_NUMERIC_IDENTIFIER}|${NUMERIC_IDENTIFIER_LOOSE})`;
+var PRERELEASE = String.raw`(?:-(${PRERELEASE_IDENTIFIER}(?:\.${PRERELEASE_IDENTIFIER})*))`;
+var PRERELEASE_LOOSE = String.raw`(?:-?(${PRERELEASE_IDENTIFIER_LOOSE}(?:\.${PRERELEASE_IDENTIFIER_LOOSE})*))`;
+var BUILD_IDENTIFIER = `${LETTER_DASH_NUMBER}+`;
+var BUILD = String.raw`(?:\+(${BUILD_IDENTIFIER}(?:\.${BUILD_IDENTIFIER})*))`;
+var FULL_PLAIN = `v?${MAIN_VERSION}${PRERELEASE}?${BUILD}?`;
+var LOOSE_PLAIN = String.raw`[v=\s]*${MAIN_VERSION_LOOSE}${PRERELEASE_LOOSE}?${BUILD}?`;
+var GREATER_LESS_THAN = "((?:<|>)?=?)";
+var XRANGE_IDENTIFIER = String.raw`${NUMERIC_IDENTIFIER}|x|X|\*`;
+var XRANGE_IDENTIFIER_LOOSE = String.raw`${NUMERIC_IDENTIFIER_LOOSE}|x|X|\*`;
+var XRANGE_PLAIN = String.raw`[v=\s]*(${XRANGE_IDENTIFIER})(?:\.(${XRANGE_IDENTIFIER})(?:\.(${XRANGE_IDENTIFIER})(?:${PRERELEASE})?${BUILD}?)?)?`;
+var XRANGE_PLAIN_LOOSE = String.raw`[v=\s]*(${XRANGE_IDENTIFIER_LOOSE})(?:\.(${XRANGE_IDENTIFIER_LOOSE})(?:\.(${XRANGE_IDENTIFIER_LOOSE})(?:${PRERELEASE_LOOSE})?${BUILD}?)?)?`;
+var LONE_TILDE = "(?:~>?)";
+var LONE_CARET = String.raw`(?:\^)`;
+var COERCE_PLAIN = String.raw`(^|[^\d])(\d{1,${16}})(?:\.(\d{1,${16}}))?(?:\.(\d{1,${16}}))?`;
+var COERCE = String.raw`${COERCE_PLAIN}(?:$|[^\d])`;
+var COERCE_FULL = String.raw`${COERCE_PLAIN}(?:${PRERELEASE})?(?:${BUILD})?(?:$|[^\d])`;
+function makeSafeRegexSource(source) {
+	const replacements = [
+		[String.raw`\s`, 1],
+		[String.raw`\d`, 256],
+		[LETTER_DASH_NUMBER, 250]
+	];
+	for (const [token, maximum] of replacements) source = source.split(`${token}*`).join(`${token}{0,${maximum}}`).split(`${token}+`).join(`${token}{1,${maximum}}`);
+	return source;
+}
+function safeRegex(source, flags) {
+	return new RegExp(makeSafeRegexSource(source), flags);
+}
+var NUMERIC$1 = /^\d+$/;
+function compareIdentifiers(left, right) {
+	if (typeof left === "number" && typeof right === "number") return left === right ? 0 : left < right ? -1 : 1;
+	const leftNumeric = NUMERIC$1.test(String(left));
+	const rightNumeric = NUMERIC$1.test(String(right));
+	const normalizedLeft = leftNumeric ? Number(left) : left;
+	const normalizedRight = rightNumeric ? Number(right) : right;
+	return normalizedLeft === normalizedRight ? 0 : leftNumeric && !rightNumeric ? -1 : rightNumeric && !leftNumeric ? 1 : normalizedLeft < normalizedRight ? -1 : 1;
+}
+var FULL = safeRegex(`^${FULL_PLAIN}$`);
+var LOOSE = safeRegex(`^${LOOSE_PLAIN}$`);
+safeRegex(`^${PRERELEASE}$`);
+safeRegex(`^${PRERELEASE_LOOSE}$`);
+safeRegex(COERCE);
+safeRegex(COERCE_FULL);
+var NUMERIC = /^\d+$/;
+function formatComparableVersion(version) {
+	const base = `${version.major}.${version.minor}.${version.patch}`;
+	return version.prerelease?.length ? `${base}-${version.prerelease.join(".")}` : base;
+}
+function parse(version, options = {}) {
+	if (typeof version !== "string") return version;
+	if (version.length > 256) throw new TypeError(`Version exceeds the maximum length of 256 characters`);
+	const match = version.trim().match(options.loose ? LOOSE : FULL);
+	if (!match) throw new TypeError(`Invalid version syntax: ${version}`);
+	const major = Number(match[1]);
+	const minor = Number(match[2]);
+	const patch = Number(match[3]);
+	if (major > Number.MAX_SAFE_INTEGER || major < 0) throw new TypeError(`Invalid major version: ${match[1]}`);
+	if (minor > Number.MAX_SAFE_INTEGER || minor < 0) throw new TypeError(`Invalid minor version: ${match[2]}`);
+	if (patch > Number.MAX_SAFE_INTEGER || patch < 0) throw new TypeError(`Invalid patch version: ${match[3]}`);
+	const prerelease = match[4] ? match[4].split(".").map((identifier) => {
+		if (NUMERIC.test(identifier)) {
+			const numeric = Number(identifier);
+			if (numeric >= 0 && numeric < Number.MAX_SAFE_INTEGER) return numeric;
+		}
+		return identifier;
+	}) : void 0;
+	return {
+		build: match[5]?.split("."),
+		major,
+		minor,
+		patch,
+		prerelease
+	};
+}
+function tryParse(version, options = {}) {
+	try {
+		return parse(version, options);
+	} catch {
+		return null;
+	}
+}
+function compareMainParsed(left, right) {
+	return left.major === right.major ? left.minor === right.minor ? left.patch === right.patch ? 0 : left.patch < right.patch ? -1 : 1 : left.minor < right.minor ? -1 : 1 : left.major < right.major ? -1 : 1;
+}
+function comparePrereleaseParsed(left, right) {
+	const leftPrerelease = left.prerelease;
+	const rightPrerelease = right.prerelease;
+	if (leftPrerelease?.length && !rightPrerelease?.length) return -1;
+	if (!leftPrerelease?.length && rightPrerelease?.length) return 1;
+	if (!leftPrerelease?.length && !rightPrerelease?.length) return 0;
+	for (let index = 0;; index++) {
+		const leftIdentifier = leftPrerelease?.[index];
+		const rightIdentifier = rightPrerelease?.[index];
+		if (leftIdentifier === void 0 && rightIdentifier === void 0) return 0;
+		if (rightIdentifier === void 0) return 1;
+		if (leftIdentifier === void 0) return -1;
+		if (leftIdentifier !== rightIdentifier) return compareIdentifiers(leftIdentifier, rightIdentifier);
+	}
+}
+function compareParsed(left, right) {
+	return compareMainParsed(left, right) || comparePrereleaseParsed(left, right);
+}
+var STRICT_COMPARATOR = safeRegex(String.raw`^${GREATER_LESS_THAN}\s*(${FULL_PLAIN})$|^$`);
+var LOOSE_COMPARATOR$1 = safeRegex(String.raw`^${GREATER_LESS_THAN}\s*(${LOOSE_PLAIN})$|^$`);
+function parseComparator(comparator, options = {}) {
+	const normalized = comparator.trim().replaceAll(/\s+/g, " ");
+	const match = normalized.match(options.loose ? LOOSE_COMPARATOR$1 : STRICT_COMPARATOR);
+	if (!match) throw new TypeError(`Invalid comparator: ${normalized}`);
+	const operator = match[1] === "=" ? "" : match[1] || "";
+	const version = match[2] ? parse(match[2], options) : null;
+	return {
+		operator,
+		options,
+		value: version ? `${operator}${formatComparableVersion(version)}` : "",
+		version
+	};
+}
+function compare(left, right, options = {}) {
+	return compareParsed(parse(left, options), parse(right, options));
+}
+var BUILD_STRIP = new RegExp(BUILD, "g");
+var BUILD_SAFE = safeRegex(BUILD);
+var STRICT_HYPHEN = safeRegex(String.raw`^\s*(${XRANGE_PLAIN})\s+-\s+(${XRANGE_PLAIN})\s*$`);
+var LOOSE_HYPHEN = safeRegex(String.raw`^\s*(${XRANGE_PLAIN_LOOSE})\s+-\s+(${XRANGE_PLAIN_LOOSE})\s*$`);
+var COMPARATOR_TRIM = safeRegex(String.raw`(\s*)${GREATER_LESS_THAN}\s*(${LOOSE_PLAIN}|${XRANGE_PLAIN})`, "g");
+var TILDE_TRIM = safeRegex(String.raw`(\s*)${LONE_TILDE}\s+`, "g");
+var CARET_TRIM = safeRegex(String.raw`(\s*)${LONE_CARET}\s+`, "g");
+var STRICT_TILDE = safeRegex(`^${LONE_TILDE}${XRANGE_PLAIN}$`);
+var LOOSE_TILDE = safeRegex(`^${LONE_TILDE}${XRANGE_PLAIN_LOOSE}$`);
+var STRICT_CARET = safeRegex(`^${LONE_CARET}${XRANGE_PLAIN}$`);
+var LOOSE_CARET = safeRegex(`^${LONE_CARET}${XRANGE_PLAIN_LOOSE}$`);
+var STRICT_XRANGE = safeRegex(String.raw`^${GREATER_LESS_THAN}\s*${XRANGE_PLAIN}$`);
+var LOOSE_XRANGE = safeRegex(String.raw`^${GREATER_LESS_THAN}\s*${XRANGE_PLAIN_LOOSE}$`);
+var STAR = safeRegex(String.raw`(<|>)?=?\s*\*`);
+var GTE_ZERO = /^\s*>=\s*0\.0\.0\s*$/;
+var GTE_ZERO_PRERELEASE = /^\s*>=\s*0\.0\.0-0\s*$/;
+var LOOSE_COMPARATOR = safeRegex(String.raw`^${GREATER_LESS_THAN}\s*(${LOOSE_PLAIN})$|^$`);
+function isWildcard(value) {
+	return !value || String(value).toLowerCase() === "x" || String(value) === "*";
+}
+function hasInvalidWildcardOrder(major, minor, patch) {
+	return isWildcard(major) && !isWildcard(minor) || isWildcard(minor) && Boolean(patch) && !isWildcard(patch);
+}
+function replaceTilde(comparator, options) {
+	const expression = options.loose ? LOOSE_TILDE : STRICT_TILDE;
+	const lowerPrerelease = options.includePrerelease ? "-0" : "";
+	return comparator.replace(expression, (_match, major, minor, patch, prerelease) => {
+		if (isWildcard(major)) return "";
+		if (isWildcard(minor)) return `>=${major}.0.0${lowerPrerelease} <${Number(major) + 1}.0.0-0`;
+		if (isWildcard(patch)) return `>=${major}.${minor}.0${lowerPrerelease} <${major}.${Number(minor) + 1}.0-0`;
+		return prerelease ? `>=${major}.${minor}.${patch}-${prerelease} <${major}.${Number(minor) + 1}.0-0` : `>=${major}.${minor}.${patch} <${major}.${Number(minor) + 1}.0-0`;
+	});
+}
+function replaceTildes(comparator, options) {
+	return comparator.trim().split(/\s+/).map((part) => replaceTilde(part, options)).join(" ");
+}
+function replaceCaret(comparator, options) {
+	const expression = options.loose ? LOOSE_CARET : STRICT_CARET;
+	const lowerPrerelease = options.includePrerelease ? "-0" : "";
+	return comparator.replace(expression, (_match, major, minor, patch, prerelease) => {
+		if (isWildcard(major)) return "";
+		if (isWildcard(minor)) return `>=${major}.0.0${lowerPrerelease} <${Number(major) + 1}.0.0-0`;
+		if (isWildcard(patch)) return major === "0" ? `>=${major}.${minor}.0${lowerPrerelease} <${major}.${Number(minor) + 1}.0-0` : `>=${major}.${minor}.0${lowerPrerelease} <${Number(major) + 1}.0.0-0`;
+		if (prerelease) return major === "0" ? minor === "0" ? `>=${major}.${minor}.${patch}-${prerelease} <${major}.${minor}.${Number(patch) + 1}-0` : `>=${major}.${minor}.${patch}-${prerelease} <${major}.${Number(minor) + 1}.0-0` : `>=${major}.${minor}.${patch}-${prerelease} <${Number(major) + 1}.0.0-0`;
+		return major === "0" ? minor === "0" ? `>=${major}.${minor}.${patch} <${major}.${minor}.${Number(patch) + 1}-0` : `>=${major}.${minor}.${patch} <${major}.${Number(minor) + 1}.0-0` : `>=${major}.${minor}.${patch} <${Number(major) + 1}.0.0-0`;
+	});
+}
+function replaceCarets(comparator, options) {
+	return comparator.trim().split(/\s+/).map((part) => replaceCaret(part, options)).join(" ");
+}
+function replaceXRange(comparator, options) {
+	const expression = options.loose ? LOOSE_XRANGE : STRICT_XRANGE;
+	return comparator.trim().replace(expression, (match, rawOperator, rawMajor, rawMinor, rawPatch) => {
+		let operator = rawOperator;
+		let major = rawMajor;
+		let minor = rawMinor;
+		let patch = rawPatch;
+		if (hasInvalidWildcardOrder(String(major), minor === void 0 ? void 0 : String(minor), patch === void 0 ? void 0 : String(patch))) return comparator;
+		const wildcardMajor = isWildcard(major);
+		const wildcardMinor = wildcardMajor || isWildcard(minor);
+		const wildcardPatch = wildcardMinor || isWildcard(patch);
+		if (operator === "=" && wildcardPatch) operator = "";
+		if (wildcardMajor) return operator === ">" || operator === "<" ? "<0.0.0-0" : "*";
+		let prerelease = options.includePrerelease ? "-0" : "";
+		if (operator && wildcardPatch) {
+			if (wildcardMinor) minor = 0;
+			patch = 0;
+			if (operator === ">") {
+				operator = ">=";
+				if (wildcardMinor) {
+					major = Number(major) + 1;
+					minor = 0;
+				} else minor = Number(minor) + 1;
+			} else if (operator === "<=") {
+				operator = "<";
+				if (wildcardMinor) major = Number(major) + 1;
+				else minor = Number(minor) + 1;
+			}
+			if (operator === "<") prerelease = "-0";
+			return `${operator}${major}.${minor}.${patch}${prerelease}`;
+		}
+		if (wildcardMinor) return `>=${major}.0.0${prerelease} <${Number(major) + 1}.0.0-0`;
+		if (wildcardPatch) return `>=${major}.${minor}.0${prerelease} <${major}.${Number(minor) + 1}.0-0`;
+		return match;
+	});
+}
+function replaceXRanges(comparator, options) {
+	return comparator.split(/\s+/).map((part) => replaceXRange(part, options)).join(" ");
+}
+function replaceHyphenRange(range, options) {
+	const expression = options.loose ? LOOSE_HYPHEN : STRICT_HYPHEN;
+	return range.replace(expression, (_match, rawFrom, fromMajor, fromMinor, fromPatch, fromPrerelease, _fromBuild, rawTo, toMajor, toMinor, toPatch, toPrerelease) => {
+		let from = rawFrom;
+		let to = rawTo;
+		if (isWildcard(fromMajor)) from = "";
+		else if (isWildcard(fromMinor)) from = `>=${fromMajor}.0.0${options.includePrerelease ? "-0" : ""}`;
+		else if (isWildcard(fromPatch)) from = `>=${fromMajor}.${fromMinor}.0${options.includePrerelease ? "-0" : ""}`;
+		else if (fromPrerelease) from = `>=${from}`;
+		else from = `>=${from}${options.includePrerelease ? "-0" : ""}`;
+		if (isWildcard(toMajor)) to = "";
+		else if (isWildcard(toMinor)) to = `<${Number(toMajor) + 1}.0.0-0`;
+		else if (isWildcard(toPatch)) to = `<${toMajor}.${Number(toMinor) + 1}.0-0`;
+		else if (toPrerelease) to = `<=${toMajor}.${toMinor}.${toPatch}-${toPrerelease}`;
+		else if (options.includePrerelease) to = `<${toMajor}.${toMinor}.${Number(toPatch) + 1}-0`;
+		else to = `<=${to}`;
+		return `${from} ${to}`.trim();
+	});
+}
+function expandComparator(comparator, options) {
+	return replaceXRanges(replaceTildes(replaceCarets(comparator.replace(BUILD_SAFE, ""), options), options), options).trim().replace(STAR, "");
+}
+function parseSimpleRange(input, options) {
+	let parts = replaceHyphenRange(input.replace(BUILD_STRIP, ""), options).replace(COMPARATOR_TRIM, "$1$2$3").replace(TILDE_TRIM, "$1~").replace(CARET_TRIM, "$1^").split(" ").map((part) => expandComparator(part, options)).join(" ").split(/\s+/).map((part) => part.trim().replace(options.includePrerelease ? GTE_ZERO_PRERELEASE : GTE_ZERO, ""));
+	if (options.loose) parts = parts.filter((part) => LOOSE_COMPARATOR.test(part));
+	const unique = /* @__PURE__ */ new Map();
+	for (const comparator of parts.map((part) => parseComparator(part, options))) {
+		if (comparator.value === "<0.0.0-0") return [comparator];
+		unique.set(comparator.value, comparator);
+	}
+	if (unique.size > 1) unique.delete("");
+	return [...unique.values()];
+}
+function parseRange(range, options = {}) {
+	if (typeof range !== "string") return range;
+	const parsedOptions = { ...options };
+	const raw = range.trim().replaceAll(/\s+/g, " ");
+	let sets = raw.split("||").map((part) => parseSimpleRange(part.trim(), parsedOptions)).filter((set) => set.length);
+	if (!sets.length) throw new TypeError(`Range contains no valid comparator sets: ${raw}`);
+	if (sets.length > 1) {
+		const first = sets[0];
+		sets = sets.filter((set) => set[0]?.value !== "<0.0.0-0");
+		if (!sets.length) sets = [first];
+		else if (sets.length > 1) {
+			const any = sets.find((set) => set.length === 1 && set[0]?.value === "");
+			if (any) sets = [any];
+		}
+	}
+	return {
+		normalized: sets.map((set) => set.map((comparator) => comparator.value).join(" ")).join("||"),
+		options: parsedOptions,
+		raw,
+		sets
+	};
+}
+function normalize(version, options = {}) {
+	const parsed = tryParse(version, options);
+	return parsed ? formatComparableVersion(parsed) : null;
+}
+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(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 > 100) throw new ReleaseCatalogCompilationError("TARGET_COHORT_LIMIT", `Release ${release.id} exceeds 100 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) >= 1e3)) {
+		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 >= 1e3) 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: 1,
+			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: 1,
+			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 > 512) throw new ReleaseCatalogCompilationError("DISTINCT_TARGET_COHORT_LIMIT", `Scope exceeds 512 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 > 262144) 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
+	};
+}
+var RELEASE_PAGE_SIZE$1 = 1e3;
+var DEFAULT_MAX_ATTEMPTS = 3;
+var ReleaseCatalogMutationError = class extends Error {
+	name = "ReleaseCatalogMutationError";
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+	}
+};
+var 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$1,
+			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$1) 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;
+	}
+};
+var validateScope = (scope) => {
+	const channelKey = 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" ? createReleaseCatalogScopeKey({
+		channelKey,
+		platform: scope.platform,
+		strategy: "APP_VERSION"
+	}) : 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");
+};
+var 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
+	};
+};
+var 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 createUUIDv7();
+};
+var 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
+	};
+};
+var prepareReleaseCatalogMutation = async (database, mutationInput) => {
+	const { rows, currentCatalog } = await readCatalogScope(database, mutationInput.scope.scopeKey);
+	const applied = applyMutation(rows, mutationInput.scope, mutationInput.mutation);
+	const compilation = await compileReleaseCatalog({
+		strategy: mutationInput.scope.strategy,
+		releases: applied.nextRows.map(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: 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;
+}
+var RELEASE_PAGE_SIZE = 1e3;
+var ReleaseManagementError = class extends Error {
+	name = "ReleaseManagementError";
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+	}
+};
+var readReleaseScope = async (database, scopeKey) => {
+	const rows = [];
+	let afterReleaseId;
+	for (;;) {
+		const page = await database.models.releases.findManyByScope({
+			scopeKey,
+			...afterReleaseId === void 0 ? {} : { afterReleaseId },
+			consistency: "strong",
+			limit: RELEASE_PAGE_SIZE
+		});
+		rows.push(...page);
+		if (page.length < RELEASE_PAGE_SIZE) return rows;
+		const nextCursor = page.at(-1)?.id;
+		if (nextCursor === void 0 || nextCursor === afterReleaseId) throw new ReleaseCatalogMutationError("INVALID_SCOPE", `Release paging did not advance for scope "${scopeKey}".`);
+		afterReleaseId = nextCursor;
+	}
+};
+var createForwardReleaseId = (rows, candidates, nowMs) => {
+	return createUUIDv7After([...candidates, rows.at(-1)?.id ?? null].filter((value) => value !== null && isUUIDv7(value)).sort().at(-1) ?? null, nowMs);
+};
+var prepareTargetScope = async ({ channelName, database, fingerprintHash, platform, strategy }) => {
+	const channelKey = encodeChannelKey(channelName);
+	const channel = (await database.models.channels.list({})).channels.find(({ name }) => name === channelName) ?? (await database.models.channels.insert({
+		row: {
+			id: `channel:${channelKey}`,
+			name: channelName
+		},
+		onConflict: "returnExisting"
+	})).row;
+	const scopeKey = strategy === "APP_VERSION" ? createReleaseCatalogScopeKey({
+		channelKey,
+		platform,
+		strategy
+	}) : createReleaseCatalogScopeKey({
+		channelKey,
+		fingerprintHash: fingerprintHash ?? "",
+		platform,
+		strategy
+	});
+	return { scope: {
+		channelId: channel.id,
+		channelName,
+		fingerprintHash,
+		platform,
+		scopeKey,
+		strategy
+	} };
+};
+var loadReleaseTarget = async (input) => {
+	const release = await input.database.models.releases.findById(input.releaseId);
+	if (release === null) throw new ReleaseManagementError("RELEASE_NOT_FOUND", `Release "${input.releaseId}" was not found.`);
+	if (input.expectedRevision !== void 0 && input.expectedRevision !== release.revision) throw new ReleaseManagementError("VERSION_CONFLICT", `Release "${release.id}" is revision ${release.revision}; expected ${input.expectedRevision}.`);
+	const catalog = await input.database.models.releaseCatalogs.findByScopeKey(release.scope_key);
+	if (catalog === null) throw new ReleaseCatalogMutationError("INVALID_SCOPE", `Release "${release.id}" has no catalog projection.`);
+	return {
+		release,
+		scope: {
+			channelId: release.channel_id,
+			channelName: decodeChannelKey(catalog.channel_key),
+			fingerprintHash: release.fingerprint_hash,
+			platform: release.platform,
+			scopeKey: release.scope_key,
+			strategy: release.strategy
+		}
+	};
+};
+var releasePolicyUpdate = (release, patch, updatedAtMs) => {
+	if (patch.fingerprintHash !== void 0 && patch.fingerprintHash !== release.fingerprint_hash) throw new 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
+	};
+};
+async function updateReleasePolicy(input) {
+	const { release, scope } = await loadReleaseTarget(input);
+	const updatedAtMs = input.updatedAtMs ?? Date.now();
+	return commitReleaseCatalogMutation({
+		database: input.database,
+		mutation: {
+			id: release.id,
+			operation: "update",
+			update: releasePolicyUpdate(release, input.patch, updatedAtMs)
+		},
+		scope,
+		updatedAtMs
+	});
+}
+async function preflightReleasePolicy(input) {
+	const { release, scope } = await loadReleaseTarget(input);
+	const updatedAtMs = input.updatedAtMs ?? Date.now();
+	return preflightReleaseCatalogMutation({
+		database: input.database,
+		mutation: {
+			id: release.id,
+			operation: "update",
+			update: releasePolicyUpdate(release, input.patch, updatedAtMs)
+		},
+		scope,
+		updatedAtMs
+	});
+}
+async function deleteRelease$1(input) {
+	const { release, scope } = await loadReleaseTarget(input);
+	if (release.enabled) throw new ReleaseManagementError("ENABLED_RELEASE", `Disable Release "${release.id}" before hard deletion.`);
+	return commitReleaseCatalogMutation({
+		database: input.database,
+		mutation: {
+			id: release.id,
+			operation: "delete"
+		},
+		scope,
+		updatedAtMs: input.updatedAtMs
+	});
+}
+async function promoteRelease$1(input) {
+	const { release: source, scope: sourceScope } = await loadReleaseTarget(input);
+	if (source.kind !== "BUNDLE" || source.bundle_id === null) throw new ReleaseManagementError("TARGET_RELEASE_INVALID", "Only a Bundle Release can be promoted.");
+	const targetChannel = input.targetChannel.trim();
+	if (targetChannel.length === 0) throw new ReleaseManagementError("TARGET_RELEASE_INVALID", "Promotion requires a target channel.");
+	const { scope: targetScope } = await prepareTargetScope({
+		channelName: targetChannel,
+		database: input.database,
+		fingerprintHash: source.fingerprint_hash,
+		platform: source.platform,
+		strategy: source.strategy
+	});
+	if (targetScope.scopeKey === sourceScope.scopeKey) throw new ReleaseManagementError("TARGET_RELEASE_INVALID", "Source and target Release scopes are the same.");
+	const targetRows = await readReleaseScope(input.database, targetScope.scopeKey);
+	const updatedAtMs = input.updatedAtMs ?? Date.now();
+	const targetMutation = {
+		mutation: {
+			operation: "insert",
+			row: {
+				...source,
+				id: createForwardReleaseId(targetRows, [source.id, source.bundle_id], 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
+			}
+		},
+		scope: targetScope,
+		updatedAtMs
+	};
+	const sourceMutation = input.action === "move" ? {
+		mutation: {
+			id: source.id,
+			operation: "update",
+			update: {
+				enabled: false,
+				updated_at_ms: updatedAtMs
+			}
+		},
+		scope: sourceScope,
+		updatedAtMs
+	} : null;
+	const results = await commitReleaseCatalogMutations({
+		database: input.database,
+		mutations: sourceMutation === null ? [targetMutation] : [sourceMutation, targetMutation]
+	});
+	return {
+		source: sourceMutation === null ? null : results[0],
+		target: results.at(-1)
+	};
+}
+async function listReleases(releases, input) {
+	const page = input.page ?? 1;
+	const rows = await releases.findMany({
+		...input.afterReleaseId === void 0 ? {} : { afterReleaseId: input.afterReleaseId },
+		...input.beforeReleaseId === void 0 ? {} : { beforeReleaseId: input.beforeReleaseId },
+		...input.bundleId === void 0 ? {} : { bundleId: input.bundleId },
+		...input.channelId === void 0 ? {} : { channelId: input.channelId },
+		...input.enabled === void 0 ? {} : { enabled: input.enabled },
+		...input.platform === void 0 ? {} : { platform: input.platform },
+		...input.targetAppVersion === void 0 ? {} : { targetAppVersion: input.targetAppVersion },
+		limit: input.limit + 1
+	});
+	const isPreviousRequest = input.afterReleaseId !== void 0;
+	const hasExtraRow = rows.length > input.limit;
+	return {
+		data: isPreviousRequest ? hasExtraRow ? rows.slice(1) : rows : rows.slice(0, input.limit),
+		pagination: {
+			currentPage: page,
+			hasNextPage: isPreviousRequest || hasExtraRow,
+			hasPreviousPage: page > 1
+		}
+	};
+}
+async function getReleaseActivity30d(insights, releases) {
+	const bundleIds = [...new Set(releases.flatMap(({ bundle_id }) => bundle_id === null ? [] : [bundle_id]))];
+	if (insights === null || bundleIds.length === 0) return /* @__PURE__ */ new Map();
+	try {
+		const summaries = await insights.getBundleEventSummaries(bundleIds, "30d");
+		return new Map(summaries.map((summary) => [summary.bundleId, summary]));
+	} catch (error) {
+		console.error("Error during Release list activity retrieval:", error);
+		return /* @__PURE__ */ new Map();
+	}
+}
+var NON_TARGETED_COHORT = "release-catalog-non-targeted-cohort";
+function collectReachableFromIndexes(catalog, indexes, reachableReleaseIds) {
+	const descriptors = indexes.flatMap((index) => {
+		const descriptor = catalog.releaseDescriptors[index];
+		return descriptor === void 0 ? [] : [descriptor];
+	});
+	const cohorts = new Set([
+		void 0,
+		...Array.from({ length: NUMERIC_COHORT_SIZE }, (_, index) => String(index + 1)),
+		...descriptors.flatMap(({ targetCohorts }) => targetCohorts),
+		NON_TARGETED_COHORT
+	]);
+	for (const cohort of cohorts) {
+		const selected = descriptors.find((descriptor) => descriptor.kind === "BUNDLE" && descriptor.bundleId !== null && isReleaseEligibleForCohort(descriptor, cohort));
+		if (selected !== void 0) reachableReleaseIds.add(selected.releaseId);
+	}
+}
+function collectCurrentlyReachableReleaseIds(catalog) {
+	const reachableReleaseIds = /* @__PURE__ */ new Set();
+	const indexGroups = catalog.strategy === "APP_VERSION" ? catalog.segments.map(({ releaseIndexes }) => releaseIndexes) : [catalog.releaseIndexes];
+	for (const indexes of indexGroups) collectReachableFromIndexes(catalog, indexes, reachableReleaseIds);
+	return reachableReleaseIds;
+}
+async function addReleaseReachability(releaseCatalogs, releases) {
+	const scopeKeys = [...new Set(releases.map(({ scope_key }) => scope_key))];
+	const reachableByScope = new Map(await Promise.all(scopeKeys.map(async (scopeKey) => {
+		const row = await releaseCatalogs.findByScopeKey(scopeKey);
+		return [scopeKey, row === null ? /* @__PURE__ */ new Set() : collectCurrentlyReachableReleaseIds(JSON.parse(row.payload))];
+	})));
+	return releases.map((release) => ({
+		...release,
+		currentlyUnreachable: !reachableByScope.get(release.scope_key)?.has(release.id)
+	}));
+}
+var getReleases_createServerFn_handler = createServerRpc({
+	id: "206547cb1526f961070a989818ca7b9e34f6b2b0e4ab851698c3807fe9fb5e0c",
+	name: "getReleases",
+	filename: "src/lib/api-rpc.ts"
+}, (opts) => getReleases.__executeServer(opts));
+var getReleases = createServerFn({ method: "GET" }).inputValidator((input) => input).handler(getReleases_createServerFn_handler, async ({ data }) => {
+	const { prepareConfig } = await import("./config.server-DQYEr_5X.mjs");
+	const { config, hotUpdater } = await prepareConfig();
+	const result = await listReleases(config.database.models.releases, {
+		...data?.afterReleaseId === void 0 ? {} : { afterReleaseId: data.afterReleaseId },
+		...data?.beforeReleaseId === void 0 ? {} : { beforeReleaseId: data.beforeReleaseId },
+		...data?.bundleId === void 0 ? {} : { bundleId: data.bundleId },
+		...data?.channelId === void 0 ? {} : { channelId: data.channelId },
+		...data?.enabled === void 0 ? {} : { enabled: data.enabled },
+		...data?.page === void 0 ? {} : { page: data.page },
+		...data?.platform === void 0 ? {} : { platform: data.platform },
+		...data?.targetAppVersion === void 0 ? {} : { targetAppVersion: data.targetAppVersion },
+		limit: data?.limit ?? 20
+	});
+	const [releases, activityByBundleId] = await Promise.all([addReleaseReachability(config.database.models.releaseCatalogs, result.data), getReleaseActivity30d(hotUpdater, result.data)]);
+	return {
+		...result,
+		data: releases.map((release) => ({
+			...release,
+			activity30d: release.bundle_id === null ? null : activityByBundleId.get(release.bundle_id) ?? null
+		}))
+	};
+});
+var getRelease_createServerFn_handler = createServerRpc({
+	id: "a6f23116eeaf76166d405e28a95213123025613c6603030894e519015bf48032",
+	name: "getRelease",
+	filename: "src/lib/api-rpc.ts"
+}, (opts) => getRelease.__executeServer(opts));
+var getRelease = createServerFn({ method: "GET" }).inputValidator((input) => input).handler(getRelease_createServerFn_handler, async ({ data }) => {
+	const { prepareConfig } = await import("./config.server-DQYEr_5X.mjs");
+	const { config } = await prepareConfig();
+	return config.database.models.releases.findById(data.releaseId);
+});
+var updateRelease_createServerFn_handler = createServerRpc({
+	id: "7ea0186f19f9f2bc2ca4b26e3c59636891cf046957f84287b6783f8d88bd8cb7",
+	name: "updateRelease",
+	filename: "src/lib/api-rpc.ts"
+}, (opts) => updateRelease.__executeServer(opts));
+var updateRelease = createServerFn({ method: "POST" }).inputValidator((input) => input).handler(updateRelease_createServerFn_handler, async ({ data }) => {
+	const { prepareConfig } = await import("./config.server-DQYEr_5X.mjs");
+	const { config } = await prepareConfig();
+	return updateReleasePolicy({
+		database: config.database,
+		...data
+	});
+});
+var preflightRelease_createServerFn_handler = createServerRpc({
+	id: "b46c95dba95a6a3e8fa5c9d100e3622fa5ae7af4f38e10fb1ed2fa48289a3a8f",
+	name: "preflightRelease",
+	filename: "src/lib/api-rpc.ts"
+}, (opts) => preflightRelease.__executeServer(opts));
+var preflightRelease = createServerFn({ method: "POST" }).inputValidator((input) => input).handler(preflightRelease_createServerFn_handler, async ({ data }) => {
+	const { prepareConfig } = await import("./config.server-DQYEr_5X.mjs");
+	const { config } = await prepareConfig();
+	return preflightReleasePolicy({
+		database: config.database,
+		...data
+	});
+});
+var deleteRelease_createServerFn_handler = createServerRpc({
+	id: "d5b58722ce514e3b63a377f736b4823c2011782495442ae4870ed547e392c70b",
+	name: "deleteRelease",
+	filename: "src/lib/api-rpc.ts"
+}, (opts) => deleteRelease.__executeServer(opts));
+var deleteRelease = createServerFn({ method: "POST" }).inputValidator((input) => input).handler(deleteRelease_createServerFn_handler, async ({ data }) => {
+	const { prepareConfig } = await import("./config.server-DQYEr_5X.mjs");
+	const { config } = await prepareConfig();
+	return deleteRelease$1({
+		database: config.database,
+		...data
+	});
+});
+var promoteRelease_createServerFn_handler = createServerRpc({
+	id: "956539a300d79a7efa191c1cc2d529d62fc4bfd940442548fdbc1404e0d53078",
+	name: "promoteRelease",
+	filename: "src/lib/api-rpc.ts"
+}, (opts) => promoteRelease.__executeServer(opts));
+var promoteRelease = createServerFn({ method: "POST" }).inputValidator((input) => input).handler(promoteRelease_createServerFn_handler, async ({ data }) => {
+	const { prepareConfig } = await import("./config.server-DQYEr_5X.mjs");
+	const { config } = await prepareConfig();
+	return promoteRelease$1({
+		database: config.database,
+		...data
+	});
+});
+var getReleaseCatalogDiagnostics_createServerFn_handler = createServerRpc({
+	id: "e8c24b7247936f045a145ffd5c177fd0e3df3b52769d67dfbd8d1de491d66396",
+	name: "getReleaseCatalogDiagnostics",
+	filename: "src/lib/api-rpc.ts"
+}, (opts) => getReleaseCatalogDiagnostics.__executeServer(opts));
+var getReleaseCatalogDiagnostics = createServerFn({ method: "GET" }).inputValidator((input) => input).handler(getReleaseCatalogDiagnostics_createServerFn_handler, async ({ data }) => {
+	const { prepareConfig } = await import("./config.server-DQYEr_5X.mjs");
+	const { config } = await prepareConfig();
+	return config.database.models.releaseCatalogs.findByScopeKey(data.scopeKey);
+});
+var getConfig_createServerFn_handler = createServerRpc({
+	id: "51a34c05479a893c7d320bd4cd1604427289d667698c48b9f30a01aabf8a5e68",
+	name: "getConfig",
+	filename: "src/lib/api-rpc.ts"
+}, (opts) => getConfig.__executeServer(opts));
+var getConfig = createServerFn().handler(getConfig_createServerFn_handler, async () => {
+	try {
+		const { prepareConfig } = await import("./config.server-DQYEr_5X.mjs");
+		const { config } = await prepareConfig();
+		return { console: config.console };
+	} catch (error) {
+		console.error("Error during config retrieval:", error);
+		throw error;
+	}
+});
+var getChannels_createServerFn_handler = createServerRpc({
+	id: "79ada05964de8f2123bfcd62b10097d59bf8fd689ef5c7161031e5871d8396c5",
+	name: "getChannels",
+	filename: "src/lib/api-rpc.ts"
+}, (opts) => getChannels.__executeServer(opts));
+var getChannels = createServerFn().handler(getChannels_createServerFn_handler, async () => {
+	try {
+		const { prepareConfig } = await import("./config.server-DQYEr_5X.mjs");
+		const { databaseClient } = await prepareConfig();
+		return await databaseClient.getChannels() ?? [];
+	} catch (error) {
+		console.error("Error during channel retrieval:", error);
+		throw error;
+	}
+});
+var createChannel_createServerFn_handler = createServerRpc({
+	id: "2b9b8d1f49f79a511589617d8d4bfc6094a3acf5264f33651b9569ba66d3f321",
+	name: "createChannel",
+	filename: "src/lib/api-rpc.ts"
+}, (opts) => createChannel.__executeServer(opts));
+var createChannel = createServerFn({ method: "POST" }).inputValidator((input) => input).handler(createChannel_createServerFn_handler, async ({ data }) => {
+	try {
+		const { prepareConfig } = await import("./config.server-DQYEr_5X.mjs");
+		const { databaseClient } = await prepareConfig();
+		return { data: await databaseClient.insertChannel(data) };
+	} catch (error) {
+		console.error("Error during channel creation:", error);
+		throw error;
+	}
+});
+var deleteChannel_createServerFn_handler = createServerRpc({
+	id: "52756dde414919a906bfe83d1ab6d29910c63bcafdb47653d6f1df562d958920",
+	name: "deleteChannel",
+	filename: "src/lib/api-rpc.ts"
+}, (opts) => deleteChannel.__executeServer(opts));
+var deleteChannel = createServerFn({ method: "POST" }).inputValidator((input) => input).handler(deleteChannel_createServerFn_handler, async ({ data }) => {
+	try {
+		const { prepareConfig } = await import("./config.server-DQYEr_5X.mjs");
+		const { databaseClient } = await prepareConfig();
+		return { data: await databaseClient.deleteChannel(data) };
+	} catch (error) {
+		console.error("Error during channel deletion:", error);
+		throw error;
+	}
+});
+var getConfigLoaded_createServerFn_handler = createServerRpc({
+	id: "f8bdca3d0579adb812d6404f55d9261a89cdb025e920b1fcad82883646a5fe9e",
+	name: "getConfigLoaded",
+	filename: "src/lib/api-rpc.ts"
+}, (opts) => getConfigLoaded.__executeServer(opts));
+var getConfigLoaded = createServerFn().handler(getConfigLoaded_createServerFn_handler, async () => {
+	try {
+		const [{ getRequest }, { requireConsoleAccess }] = await Promise.all([import("./server-CpzW--lT.mjs").then((n) => n.t), import("./auth.server-DW71WzsD.mjs")]);
+		await requireConsoleAccess(getRequest());
+		const { isConfigLoaded } = await import("./config.server-DQYEr_5X.mjs");
+		return { configLoaded: isConfigLoaded() };
+	} catch (error) {
+		console.error("Error during config loaded retrieval:", error);
+		throw error;
+	}
+});
+var getBundles_createServerFn_handler = createServerRpc({
+	id: "00ccacb4a0212c83ec29f4d11719046ad91ea8291cfc557d514dbf00d3bd7f5f",
+	name: "getBundles",
+	filename: "src/lib/api-rpc.ts"
+}, (opts) => getBundles.__executeServer(opts));
+var getBundles = createServerFn({ method: "GET" }).inputValidator((input) => input).handler(getBundles_createServerFn_handler, async ({ data }) => {
+	try {
+		const { prepareConfig } = await import("./config.server-DQYEr_5X.mjs");
+		const query = {
+			platform: data?.platform ?? void 0,
+			page: typeof data?.page === "number" && Number.isInteger(data.page) && data.page > 1 ? data.page : void 0,
+			limit: data?.limit ? Number(data.limit) : 20,
+			after: data?.after ?? void 0,
+			before: data?.before ?? void 0
+		};
+		if (query.after !== void 0 && query.before !== void 0 || query.page !== void 0 && (query.after !== void 0 || query.before !== void 0)) throw new DatabasePluginInputError("invalid-pagination");
+		const pagination = query.page !== void 0 ? { page: query.page } : query.after !== void 0 ? { cursor: { after: query.after } } : query.before !== void 0 ? { cursor: { before: query.before } } : {};
+		const { databaseClient } = await prepareConfig();
+		const bundleQueryOptions = {
+			where: { platform: query.platform },
+			limit: query.limit,
+			...pagination
+		};
+		return await databaseClient.getBundles(bundleQueryOptions) ?? {
+			data: [],
+			pagination: {
+				total: 0,
+				hasNextPage: false,
+				hasPreviousPage: false,
+				currentPage: 1,
+				totalPages: 0
+			}
+		};
+	} catch (error) {
+		console.error("Error during bundle retrieval:", error);
+		throw error;
+	}
+});
+var getBundle_createServerFn_handler = createServerRpc({
+	id: "1bd85c2a50e24785cb6abb023a247a9f048f37ddfa85cbb1c57e579563bad013",
+	name: "getBundle",
+	filename: "src/lib/api-rpc.ts"
+}, (opts) => getBundle.__executeServer(opts));
+var getBundle = createServerFn({ method: "GET" }).inputValidator((input) => input).handler(getBundle_createServerFn_handler, async ({ data }) => {
+	try {
+		const { prepareConfig } = await import("./config.server-DQYEr_5X.mjs");
+		const { databaseClient } = await prepareConfig();
+		return await databaseClient.getBundleById(data.bundleId) ?? null;
+	} catch (error) {
+		console.error("Error during bundle retrieval:", error);
+		throw error;
+	}
+});
+var getBundleEventSummary_createServerFn_handler = createServerRpc({
+	id: "d4320e02be8e5c6ae7ec70a17604c835fde4686756031277b09d96b7f3de5f14",
+	name: "getBundleEventSummary",
+	filename: "src/lib/api-rpc.ts"
+}, (opts) => getBundleEventSummary.__executeServer(opts));
+var getBundleEventSummary = createServerFn({ method: "GET" }).inputValidator(parseBundleEventSummaryInput).handler(getBundleEventSummary_createServerFn_handler, async ({ data }) => {
+	try {
+		const { prepareConfig } = await import("./config.server-DQYEr_5X.mjs");
+		const { getBundleEventSummary: getBundleEventSummaryWithRuntime } = await import("./runtime.server-la7TRAH_.mjs");
+		const { hotUpdater } = await prepareConfig();
+		return await getBundleEventSummaryWithRuntime(hotUpdater, data);
+	} catch (error) {
+		console.error("Error during bundle event summary retrieval:", error);
+		throw error;
+	}
+});
+var getBundleEventInsights_createServerFn_handler = createServerRpc({
+	id: "49ae6512305a083b6aff68bc430bd8bb1bf4d3a5f528d38865c97830b5481e0e",
+	name: "getBundleEventInsights",
+	filename: "src/lib/api-rpc.ts"
+}, (opts) => getBundleEventInsights.__executeServer(opts));
+var getBundleEventInsights = createServerFn({ method: "GET" }).inputValidator(parseBundleEventInsightsInput).handler(getBundleEventInsights_createServerFn_handler, async ({ data }) => {
+	try {
+		const { prepareConfig } = await import("./config.server-DQYEr_5X.mjs");
+		const { getBundleEventInsights: getBundleEventInsightsWithRuntime } = await import("./runtime.server-la7TRAH_.mjs");
+		const { hotUpdater } = await prepareConfig();
+		return await getBundleEventInsightsWithRuntime(hotUpdater, data);
+	} catch (error) {
+		console.error("Error during bundle event insights retrieval:", error);
+		throw error;
+	}
+});
+var searchInstallations_createServerFn_handler = createServerRpc({
+	id: "57cc4fac8359876a1d5c4b04615ba6d39bcc4b76768bb5395309ec350bd61a51",
+	name: "searchInstallations",
+	filename: "src/lib/api-rpc.ts"
+}, (opts) => searchInstallations.__executeServer(opts));
+var searchInstallations = createServerFn({ method: "GET" }).inputValidator(parseSearchInstallationsInput).handler(searchInstallations_createServerFn_handler, async ({ data }) => {
+	try {
+		const { prepareConfig } = await import("./config.server-DQYEr_5X.mjs");
+		const { searchInstallations: searchInstallationsWithRuntime } = await import("./runtime.server-la7TRAH_.mjs");
+		const { hotUpdater } = await prepareConfig();
+		return await searchInstallationsWithRuntime(hotUpdater, data);
+	} catch (error) {
+		console.error("Error during installation search:", error);
+		throw error;
+	}
+});
+var getInstallationHistory_createServerFn_handler = createServerRpc({
+	id: "9a9d750535dcdd25b01cb1c4b9439dd1ef5b719f3f835b9aee7889191ef6ec81",
+	name: "getInstallationHistory",
+	filename: "src/lib/api-rpc.ts"
+}, (opts) => getInstallationHistory.__executeServer(opts));
+var getInstallationHistory = createServerFn({ method: "GET" }).inputValidator(parseInstallationHistoryInput).handler(getInstallationHistory_createServerFn_handler, async ({ data }) => {
+	try {
+		const { prepareConfig } = await import("./config.server-DQYEr_5X.mjs");
+		const { getInstallationHistory: getInstallationHistoryWithRuntime } = await import("./runtime.server-la7TRAH_.mjs");
+		const { hotUpdater } = await prepareConfig();
+		return await getInstallationHistoryWithRuntime(hotUpdater, data);
+	} catch (error) {
+		console.error("Error during installation history retrieval:", error);
+		throw error;
+	}
+});
+var getBundleChildren_createServerFn_handler = createServerRpc({
+	id: "4370f1bf70b91f1168d85379d3008449a1bedb915e9878ca4ef89d5f3a80fa7f",
+	name: "getBundleChildren",
+	filename: "src/lib/api-rpc.ts"
+}, (opts) => getBundleChildren.__executeServer(opts));
+var getBundleChildren = createServerFn({ method: "GET" }).inputValidator((input) => input).handler(getBundleChildren_createServerFn_handler, async ({ data }) => {
+	try {
+		const { prepareConfig } = await import("./config.server-DQYEr_5X.mjs");
+		const { getBundleChildren: getBundleChildrenWithConfig } = await import("./getBundleChildren-BcRMFoDF.mjs");
+		const { databaseClient } = await prepareConfig();
+		return await getBundleChildrenWithConfig(data, { databaseClient });
+	} catch (error) {
+		console.error("Error during bundle children retrieval:", error);
+		throw error;
+	}
+});
+var getBundleChildCounts_createServerFn_handler = createServerRpc({
+	id: "4ca367070b00f58179a572f0bb8196a4ccdd3881e9b1dbfe33deee0cb6e1f549",
+	name: "getBundleChildCounts",
+	filename: "src/lib/api-rpc.ts"
+}, (opts) => getBundleChildCounts.__executeServer(opts));
+var getBundleChildCounts = createServerFn({ method: "GET" }).inputValidator((input) => input).handler(getBundleChildCounts_createServerFn_handler, async ({ data }) => {
+	try {
+		const { prepareConfig } = await import("./config.server-DQYEr_5X.mjs");
+		const { getBundleChildCounts: getBundleChildCountsWithConfig } = await import("./getBundleChildren-BcRMFoDF.mjs");
+		const { databaseClient } = await prepareConfig();
+		return await getBundleChildCountsWithConfig(data.bundleIds, { databaseClient });
+	} catch (error) {
+		console.error("Error during bundle child count retrieval:", error);
+		throw error;
+	}
+});
+var createBundle_createServerFn_handler = createServerRpc({
+	id: "16cc7c2f080ea5b73e0c6bba815b110dbd7727796036d248ba0d8ae819ddef08",
+	name: "createBundle",
+	filename: "src/lib/api-rpc.ts"
+}, (opts) => createBundle.__executeServer(opts));
+var createBundle = createServerFn({ method: "POST" }).inputValidator((input) => input).handler(createBundle_createServerFn_handler, async ({ data }) => {
+	try {
+		const { prepareConfig } = await import("./config.server-DQYEr_5X.mjs");
+		const { databaseClient } = await prepareConfig();
+		await databaseClient.insertBundle(data);
+		return {
+			success: true,
+			bundleId: data.id
+		};
+	} catch (error) {
+		console.error("Error during bundle creation:", error);
+		throw error;
+	}
+});
+var deleteBundle_createServerFn_handler = createServerRpc({
+	id: "3a27ff5679228b86a346b3fe42142e7a5bf0264f73173c0dbe5f07fb37c43cf7",
+	name: "deleteBundle",
+	filename: "src/lib/api-rpc.ts"
+}, (opts) => deleteBundle.__executeServer(opts));
+var deleteBundle = createServerFn({ method: "POST" }).inputValidator((input) => input).handler(deleteBundle_createServerFn_handler, async ({ data }) => {
+	try {
+		const { prepareConfig } = await import("./config.server-DQYEr_5X.mjs");
+		const { deleteBundle: deleteBundleWithStorage } = await import("./deleteBundle-Cu_XOMt0.mjs");
+		const { databaseClient, storagePlugin } = await prepareConfig();
+		await deleteBundleWithStorage(data, {
+			databaseClient,
+			storagePlugin,
+			waitForStorageCleanup: false
+		});
+		return { success: true };
+	} catch (error) {
+		console.error("Error during bundle deletion:", error);
+		throw error;
+	}
+});
+var deleteBundles_createServerFn_handler = createServerRpc({
+	id: "61de3b69779c5ce2a5f5d3c27e2cfaca8fba8f14c8803559b9cd733c456494fa",
+	name: "deleteBundles",
+	filename: "src/lib/api-rpc.ts"
+}, (opts) => deleteBundles.__executeServer(opts));
+var deleteBundles = createServerFn({ method: "POST" }).inputValidator((input) => input).handler(deleteBundles_createServerFn_handler, async ({ data }) => {
+	try {
+		const { prepareConfig } = await import("./config.server-DQYEr_5X.mjs");
+		const { deleteBundles: deleteBundlesWithStorage } = await import("./deleteBundle-Cu_XOMt0.mjs");
+		const { databaseClient, storagePlugin } = await prepareConfig();
+		return {
+			success: true,
+			...await deleteBundlesWithStorage(data, {
+				databaseClient,
+				storagePlugin,
+				waitForStorageCleanup: false
+			})
+		};
+	} catch (error) {
+		console.error("Error during bundle deletion:", error);
+		throw error;
+	}
+});
+//#endregion
+export { createBundle_createServerFn_handler, createChannel_createServerFn_handler, deleteBundle_createServerFn_handler, deleteBundles_createServerFn_handler, deleteChannel_createServerFn_handler, deleteRelease_createServerFn_handler, getBundleChildCounts_createServerFn_handler, getBundleChildren_createServerFn_handler, getBundleEventInsights_createServerFn_handler, getBundleEventSummary_createServerFn_handler, getBundle_createServerFn_handler, getBundles_createServerFn_handler, getChannels_createServerFn_handler, getConfigLoaded_createServerFn_handler, getConfig_createServerFn_handler, getInstallationHistory_createServerFn_handler, getReleaseCatalogDiagnostics_createServerFn_handler, getRelease_createServerFn_handler, getReleases_createServerFn_handler, preflightRelease_createServerFn_handler, promoteRelease_createServerFn_handler, searchInstallations_createServerFn_handler, updateRelease_createServerFn_handler };