@hot-updater/console 1.0.0-rc.2 → 1.0.0-rc.20

package/.output/server/_ssr/api-C0G9MTMI.mjs

@@ -0,0 +1,4205 @@
+import { C as isUUIDv7, D as parseReleaseCatalogScopeKey, E as normalizeRolloutCohortCount, T as normalizeCohortValue, a as RELEASE_CATALOG_FALLBACK_POLICY, b as getRolledOutNumericCohorts, c as encodeChannelKey, f as getManifestFileHash, h as getNumericCohortValue, l as getAssetBaseStorageUri, n as MAX_COMPILED_CATALOG_BYTES, o as createReleaseCatalogScopeKey, p as getManifestStorageUri, r as NIL_UUID, s as decodeChannelKey, u as getBundlePatch, x as isCustomCohort } from "./dist-B-r4u3Lg.mjs";
+import { a as bundleToRow, c as rowToBundle, i as bundleToPatchRows, r as DatabaseRowReferencedError, s as releaseRowToRelease, t as DatabaseBundleNotFoundError } from "./databaseRows-CXxf_VIB.mjs";
+import { t as ReleaseManagementError } from "./releaseManagement-B3e7I8J9.mjs";
+import { n as createUUIDv7After, t as createUUIDv7 } from "./uuidv7-BzSO-fr-.mjs";
+import { n as rangesIntersect, t as normalizeRange } from "../_libs/verkit.mjs";
+//#region node_modules/.nitro/vite/services/ssr/assets/api-C0G9MTMI.js
+var SHA256_FILE_HASH_RE = /^[0-9a-f]{64}$/;
+var isContentAddressedAssetFileHash = (value) => {
+	return typeof value === "string" && SHA256_FILE_HASH_RE.test(value);
+};
+var getContentAddressedAssetStoragePath = ({ assetPath, fileHash }) => {
+	const extension = assetPath.endsWith(".br") ? ".br" : assetPath.includes(".") ? `.${assetPath.split(".").pop()}` : "";
+	return `sha256/${fileHash.slice(0, 2)}/${fileHash}${extension}`;
+};
+var normalizeStorageKeyParts = (values) => {
+	if (values.some((value) => value.includes("\\"))) throw new Error("Storage keys must use '/' as the hierarchy separator.");
+	const segments = values.flatMap((value) => value.split("/").filter(Boolean));
+	if (segments.some((segment) => segment === "." || segment === "..")) throw new Error("Storage key segments must not be '.' or '..'.");
+	return segments;
+};
+var createStorageKeyBuilder = (basePath) => {
+	const baseSegments = normalizeStorageKeyParts([basePath ?? ""]);
+	return (...args) => [...baseSegments, ...normalizeStorageKeyParts(args)].join("/");
+};
+var PROTOCOL_PATTERN = /^[a-z][a-z\d+.-]*$/;
+var INVALID_BUCKET_CHARACTER_PATTERN = /[\s/?#%@:\\]/;
+var assertProtocol = (protocol) => {
+	if (!PROTOCOL_PATTERN.test(protocol)) throw new Error(`Invalid storage URI protocol: ${protocol}`);
+};
+var assertBucket = (bucket) => {
+	if (bucket.length === 0 || INVALID_BUCKET_CHARACTER_PATTERN.test(bucket)) throw new Error(`Invalid storage URI bucket: ${bucket}`);
+};
+var getKeySegments = (key) => {
+	if (key.length === 0) throw new Error("Invalid storage URI key: key must not be empty");
+	const segments = key.split("/");
+	if (segments.some((segment) => segment.length === 0 || segment === "." || segment === ".." || segment.includes("\\"))) throw new Error("Invalid storage URI key: segments must not be empty, '.', '..' or contain '\\'");
+	return segments;
+};
+/**
+* Creates a hierarchical storage identifier in the form
+* `protocol://bucket/slash-separated-encoded-key`.
+*/
+var createStorageUri = ({ protocol, bucket, key }) => {
+	assertProtocol(protocol);
+	assertBucket(bucket);
+	return `${protocol}://${bucket}/${getKeySegments(key).map(encodeURIComponent).join("/")}`;
+};
+/**
+* Parses a hierarchical storage identifier and decodes each key segment.
+*
+* Search parameters and fragments are not part of a storage identifier.
+*/
+function parseStorageUri(storageUri, expectedProtocol) {
+	assertProtocol(expectedProtocol);
+	if (storageUri.includes("?") || storageUri.includes("#")) throw new Error(`Invalid storage URI format: ${storageUri}`);
+	const match = /^([a-z][a-z\d+.-]*):\/\/([^/]+)\/(.*)$/.exec(storageUri);
+	if (!match) throw new Error(`Invalid storage URI format: ${storageUri}`);
+	const [, protocol, bucket, encodedKey] = match;
+	if (protocol !== expectedProtocol) throw new Error(`Invalid storage URI protocol. Expected ${expectedProtocol}, got ${protocol}`);
+	assertBucket(bucket);
+	let segments;
+	try {
+		segments = getKeySegments(encodedKey).map((segment) => {
+			const decoded = decodeURIComponent(segment);
+			if (decoded.includes("/") || decoded.includes("\\")) throw new Error("encoded hierarchy separator");
+			if (encodeURIComponent(decoded) !== segment) throw new Error("non-canonical segment");
+			return decoded;
+		});
+	} catch {
+		throw new Error(`Invalid storage URI format: ${storageUri}`);
+	}
+	return {
+		protocol,
+		bucket,
+		key: segments.join("/")
+	};
+}
+var isBrotliManifestAssetPath = (assetPath) => /(^|\/)index\.[^/]+\.bundle$/.test(assetPath.replace(/\\/g, "/"));
+var getManifestAssetDownloadPath = (assetPath) => isBrotliManifestAssetPath(assetPath) ? `${assetPath}.br` : assetPath;
+var createStorageUriWithRelativePath = ({ baseStorageUri, relativePath }) => {
+	const parsed = parseStorageUri(baseStorageUri, new URL(baseStorageUri).protocol.replace(":", ""));
+	const childKey = createStorageKeyBuilder(void 0)(relativePath);
+	if (!childKey) throw new Error("Relative storage key must not be empty.");
+	return createStorageUri({
+		protocol: parsed.protocol,
+		bucket: parsed.bucket,
+		key: createStorageKeyBuilder(parsed.key)(childKey)
+	});
+};
+var replaceStorageUriKeySuffix = ({ storageUri, keySuffix, replacement }) => {
+	const parsed = parseStorageUri(storageUri, new URL(storageUri).protocol.replace(":", ""));
+	const normalizedSuffix = createStorageKeyBuilder(void 0)(keySuffix);
+	const normalizedReplacement = createStorageKeyBuilder(void 0)(replacement);
+	if (!normalizedSuffix || !normalizedReplacement) throw new Error("Storage URI key suffix and replacement must not be empty.");
+	const keySegments = parsed.key.split("/");
+	const suffixSegments = normalizedSuffix.split("/");
+	const suffixOffset = keySegments.length - suffixSegments.length;
+	if (suffixOffset < 0 || suffixSegments.some((segment, index) => keySegments[suffixOffset + index] !== segment)) throw new Error("Storage URI key does not end with the expected suffix.");
+	const prefix = keySegments.slice(0, suffixOffset).join("/");
+	return createStorageUri({
+		protocol: parsed.protocol,
+		bucket: parsed.bucket,
+		key: createStorageKeyBuilder(prefix)(normalizedReplacement)
+	});
+};
+var resolveManifestAssetStorageFileHash = ({ downloadFileHash, fileHash }) => isContentAddressedAssetFileHash(downloadFileHash) ? downloadFileHash : fileHash;
+var getManifestAssetStoragePath = ({ assetPath, downloadFileHash, fileHash }) => getContentAddressedAssetStoragePath({
+	assetPath,
+	fileHash: resolveManifestAssetStorageFileHash({
+		downloadFileHash,
+		fileHash
+	})
+});
+var resolveManifestAssetStorageUri = ({ assetBaseStorageUri, assetPath, downloadFileHash, fileHash }) => createStorageUriWithRelativePath({
+	baseStorageUri: assetBaseStorageUri,
+	relativePath: getManifestAssetStoragePath({
+		assetPath,
+		downloadFileHash,
+		fileHash
+	})
+});
+var BUNDLE_STORAGE_PREFIX = "bundles";
+var createBundleStorageKey = (bundleId, ...relativePaths) => [
+	BUNDLE_STORAGE_PREFIX,
+	bundleId,
+	...relativePaths
+].filter(Boolean).join("/");
+var getBundleArchiveStorageUri = ({ manifestStorageUri, bundleId }) => replaceStorageUriKeySuffix({
+	storageUri: manifestStorageUri,
+	keySuffix: createBundleStorageKey(bundleId, "manifest.json"),
+	replacement: createBundleStorageKey(bundleId, "bundle.tar.br")
+});
+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 FULL = safeRegex(`^${FULL_PLAIN}$`);
+var LOOSE = safeRegex(`^${LOOSE_PLAIN}$`);
+var NUMERIC$1 = /^\d+$/;
+function formatComparableVersion(version) {
+	const base = `${version.major}.${version.minor}.${version.patch}`;
+	return version.prerelease?.length ? `${base}-${version.prerelease.join(".")}` : base;
+}
+function formatFullVersion(version) {
+	const comparable = formatComparableVersion(version);
+	return version.build?.length ? `${comparable}+${version.build.join(".")}` : comparable;
+}
+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$1.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;
+	}
+}
+var NUMERIC = /^\d+$/;
+function compareIdentifiers(left, right) {
+	if (typeof left === "number" && typeof right === "number") return left === right ? 0 : left < right ? -1 : 1;
+	const leftNumeric = NUMERIC.test(String(left));
+	const rightNumeric = NUMERIC.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;
+}
+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);
+}
+function compare(left, right, options = {}) {
+	return compareParsed(parse(left, options), parse(right, options));
+}
+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 = {}) {
+	if (typeof comparator !== "string") return comparator;
+	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
+	};
+}
+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 normalizedRange = range.trim().replaceAll(/\s+/g, " ");
+	let sets = normalizedRange.split("||").map((part) => parseSimpleRange(part.trim(), parsedOptions)).filter((set) => set.length);
+	if (!sets.length) throw new TypeError(`Range contains no valid comparator sets: ${normalizedRange}`);
+	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 {
+		options: parsedOptions,
+		sets
+	};
+}
+var COERCE_EXACT = safeRegex(COERCE);
+var COERCE_FULL_EXACT = safeRegex(COERCE_FULL);
+safeRegex(`^${PRERELEASE}$`);
+safeRegex(`^${PRERELEASE_LOOSE}$`);
+function normalizeFull(version, options = {}) {
+	const parsed = tryParse(version, options);
+	return parsed ? formatFullVersion(parsed) : null;
+}
+function normalize(version, options = {}) {
+	const parsed = tryParse(version, options);
+	return parsed ? formatComparableVersion(parsed) : null;
+}
+function coerce(value, options = {}) {
+	if (typeof value === "object") return value;
+	const input = typeof value === "number" ? String(value) : value;
+	let match = null;
+	if (options.rtl) {
+		const expression = safeRegex(options.includePrerelease ? COERCE_FULL : COERCE, "g");
+		let next;
+		while ((next = expression.exec(input)) && (!match || match.index + match[0].length !== input.length)) {
+			if (!match || next.index + next[0].length !== match.index + match[0].length) match = next;
+			expression.lastIndex = next.index + next[1].length + next[2].length;
+		}
+	} else match = (options.includePrerelease ? COERCE_FULL_EXACT : COERCE_EXACT).exec(input);
+	if (!match) return null;
+	const major = match[2];
+	return tryParse(`${major}.${match[3] || "0"}.${match[4] || "0"}${options.includePrerelease && match[5] ? `-${match[5]}` : ""}${options.includePrerelease && match[6] ? `+${match[6]}` : ""}`, options);
+}
+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
+	};
+}
+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) {
+	const version = coerce(appVersion);
+	return version ? normalizeFull(version) : null;
+}
+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]);
+}
+var ReleaseCatalogMutationError = class extends Error {
+	code;
+	name = "ReleaseCatalogMutationError";
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+	}
+};
+/** A stored catalog payload, checked against its strategy's shape. */
+var parseCompiledCatalog = (payload, strategy) => {
+	const parsed = JSON.parse(payload);
+	if (typeof parsed !== "object" || parsed === null || Reflect.get(parsed, "schemaVersion") !== 1 || Reflect.get(parsed, "strategy") !== strategy || Reflect.get(parsed, "fallbackPolicy") !== "BUILTIN_IF_ACTIVE_INELIGIBLE" || !Array.isArray(Reflect.get(parsed, "releaseDescriptors"))) throw new Error("Stored Release catalog payload is invalid");
+	if (strategy === "APP_VERSION" && !Array.isArray(Reflect.get(parsed, "segments"))) throw new Error("Stored app-version Release catalog is invalid");
+	if (strategy === "FINGERPRINT" && !Array.isArray(Reflect.get(parsed, "releaseIndexes"))) throw new Error("Stored fingerprint Release catalog is invalid");
+	return parsed;
+};
+/** The scope key an update check reads. */
+var releaseCatalogScopeKeyOf = (input) => input.strategy === "APP_VERSION" ? createReleaseCatalogScopeKey({
+	channelKey: input.channelKey,
+	platform: input.platform,
+	strategy: "APP_VERSION"
+}) : createReleaseCatalogScopeKey({
+	channelKey: input.channelKey,
+	fingerprintHash: input.fingerprintHash,
+	platform: input.platform,
+	strategy: "FINGERPRINT"
+});
+/** Projects a stored catalog row for one update check; null when the row is not this scope's. */
+var projectReleaseCatalogRow = (row, input, scopeKey = releaseCatalogScopeKeyOf(input)) => {
+	if (row === null || row.platform !== input.platform || row.strategy !== input.strategy || row.channel_key !== input.channelKey || row.scope_key !== scopeKey || row.fingerprint_hash !== (input.strategy === "FINGERPRINT" ? input.fingerprintHash : null)) return null;
+	const compiled = parseCompiledCatalog(row.payload, input.strategy);
+	const appVersion = input.strategy === "APP_VERSION" ? input.appVersion : void 0;
+	return {
+		catalogId: row.catalog_id,
+		catalogHash: row.catalog_hash,
+		fallbackPolicy: RELEASE_CATALOG_FALLBACK_POLICY,
+		generation: row.generation,
+		releases: projectCompiledCatalog(compiled, appVersion),
+		rollbackReleases: projectCompiledRollbackCatalog(compiled, appVersion),
+		schemaVersion: 1,
+		scopeKey
+	};
+};
+/** The scope and range a base-candidate key names; null for any other string. */
+var parseBaseCandidateKey = (key) => {
+	try {
+		const parsed = JSON.parse(key);
+		if (!Array.isArray(parsed) || typeof parsed[0] !== "string") return null;
+		const [scopeKey, text] = parsed;
+		const { strategy } = parseReleaseCatalogScopeKey(scopeKey);
+		if (strategy === "FINGERPRINT") return parsed.length === 1 ? {
+			scopeKey,
+			range: null
+		} : null;
+		const range = parsed.length === 2 && typeof text === "string" ? normalizeRange(text) : null;
+		return range === null ? null : {
+			scopeKey,
+			range
+		};
+	} catch {
+		return null;
+	}
+};
+/** A compiled segment as a range: its version when it holds exactly one. */
+var segmentRange = ({ lower, upper }) => lower?.inclusive && upper?.inclusive && lower.version === upper.version ? lower.version : [lower === null ? "" : `${lower.inclusive ? ">=" : ">"}${lower.version}`, upper === null ? "" : `${upper.inclusive ? "<=" : "<"}${upper.version}`].join(" ").trim() || "*";
+/**
+* Auto-patch bases from a scope's compiled Release Catalog, which holds
+* every enabled bundle release of the scope: those whose range intersects
+* `range` (all of them in a fingerprint scope), newest release first, each
+* bundle once and older than `bundleId`, at most `limit`.
+*/
+var baseBundleIdsOf = (row, range, bundleId, limit) => {
+	const catalog = parseCompiledCatalog(row.payload, row.strategy);
+	const serving = new Set(catalog.strategy === "FINGERPRINT" ? catalog.rollbackReleaseIndexes : catalog.segments.flatMap((segment) => range !== null && rangesIntersect(range, segmentRange(segment)) ? segment.rollbackReleaseIndexes : []));
+	const newestFirst = catalog.releaseDescriptors.map((descriptor, index) => ({
+		descriptor,
+		index
+	})).sort((left, right) => left.descriptor.releaseId < right.descriptor.releaseId ? 1 : -1);
+	const ids = [];
+	for (const { descriptor, index } of newestFirst) {
+		if (ids.length >= limit) break;
+		const id = descriptor.bundleId;
+		if (serving.has(index) && descriptor.kind === "BUNDLE" && id !== null && id < bundleId && !ids.includes(id)) ids.push(id);
+	}
+	return ids;
+};
+var MINUTE_MS = 6e4;
+var HOUR_MS = 60 * MINUTE_MS;
+var DAY_MS = 24 * HOUR_MS;
+/** A model's retention as its physical table carries it, which each adapter maps natively. */
+var physicalRetention = ({ retention }) => retention === void 0 ? {} : { retention: {
+	column: retention.field,
+	ms: retention.days * DAY_MS
+} };
+/** Models in a reference or a rooted index, which an expired row's delete would break. */
+var linkedModels = (schema) => Object.entries(schema).flatMap(([name, { fields, indexes }]) => [...Object.values(fields).map(({ references }) => references), ...Object.values(indexes).map(({ root }) => root)].flatMap((link) => link ? [name, link.model] : []));
+/**
+* What is wrong with a model's retention: it counts from an integer field,
+* over whole days, and expired rows are deleted without cascades, counter
+* moves, or root bumps, so the model is in no reference or rooted index.
+*/
+var retentionProblems = (schema, model) => {
+	const definition = schema[model];
+	if (definition.retention === void 0) return [];
+	const { field, days } = definition.retention;
+	const declared = definition.fields[field] ?? (definition.kind === "table" ? definition.derived[field] : void 0);
+	return [
+		...declared?.type !== "integer" || "multi" in declared && declared.multi === true ? [`retention field "${field}" is not an integer field`] : [],
+		...Number.isSafeInteger(days) && days >= 1 ? [] : ["retention days must be a whole number of at least 1"],
+		...linkedModels(schema).includes(model) ? ["a model with retention is in no reference or rooted index"] : []
+	];
+};
+/**
+* Rows a pass deletes from each table: one statement or two a table, so a
+* pass stays well inside D1's 50 queries an invocation.
+*/
+var PASS_LIMIT = 500;
+/** The lease row: when the next pass is due, in epoch ms. */
+var LEASE_KEY = "retention.nextPassAt";
+/**
+* The adapter, pruning during its writes with no scheduler: once the lease
+* row in `leaseTable` is due, the write that takes it first runs one bounded
+* pass over the tables with retention, and other writers skip. The next pass is due in an hour, or in a minute while a pass still
+* found a full batch of expired rows in some table. A backend that expires
+* rows natively, or a schema without retention, gets its adapter back.
+*/
+var pruneDuringWrites = (adapter, tables, { leaseTable: table, now }) => {
+	const expiring = tables.filter(({ retention }) => retention !== void 0);
+	if (adapter.prune === void 0 || expiring.length === 0) return adapter;
+	const key = [LEASE_KEY];
+	let checkAt = 0;
+	const lease = async (row, due) => {
+		const value = String(due);
+		const guard = { v: row === null ? -1 : Number(row._v) };
+		const next = {
+			key: LEASE_KEY,
+			value,
+			_v: guard.v + 1
+		};
+		const op = row === null ? {
+			type: "insert",
+			table,
+			row: next
+		} : {
+			type: "patch",
+			table,
+			key,
+			set: { value },
+			guard,
+			previous: row
+		};
+		return (await adapter.write([op])).ok ? next : null;
+	};
+	const pass = async () => {
+		const at = now();
+		if (at < checkAt) return;
+		checkAt = at + MINUTE_MS;
+		const [row = null] = await adapter.get(table, [key]);
+		checkAt = row === null ? at : Number(row.value);
+		if (checkAt > at) return;
+		const held = await lease(row, at + HOUR_MS);
+		if (held === null) return;
+		checkAt = at + HOUR_MS;
+		const deleted = [];
+		for (const t of expiring) deleted.push(await adapter.prune(t, at - t.retention.ms, PASS_LIMIT));
+		if (deleted.includes(PASS_LIMIT) && await lease(held, at + MINUTE_MS) !== null) checkAt = at + MINUTE_MS;
+	};
+	const warn = (error) => console.warn("[hot-updater] Pruning expired rows failed.", error);
+	return Object.assign(Object.create(adapter), { async write(ops) {
+		await pass().catch(warn);
+		return adapter.write(ops);
+	} });
+};
+var DatabaseSchemaError = class extends Error {
+	name = "DatabaseSchemaError";
+};
+var findPhysicalColumn = (table, name) => {
+	const column = table.columns.find((candidate) => candidate.name === name);
+	if (column === void 0) throw new DatabaseSchemaError(`${table.name} has no column ${name}.`);
+	return column;
+};
+var findPhysicalIndex = (table, name) => {
+	const index = table.indexes.find((candidate) => candidate.name === name);
+	if (index === void 0) throw new DatabaseSchemaError(`${table.name} has no index ${name}.`);
+	return index;
+};
+/**
+* The columns that order an index read and close its cursors: the sort
+* columns, then the key columns that neither `eq` nor `sort` fixes.
+*/
+var indexOrderColumns = (table, index) => [...index.sort, ...table.key.filter((column) => !index.sort.includes(column) && !index.eq.includes(column))];
+/** The primary key of a row, in key-column order. */
+var rowKey = (table, row) => table.key.map((column) => {
+	const value = row[column];
+	if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") throw new DatabaseSchemaError(`${table.name}.${column} is a key column and must be a string, number, or boolean.`);
+	return value;
+});
+var REGISTER_COUNT = 1024;
+var MAX_RANK = 55;
+var OFFSET = 33;
+var decode = (summary) => {
+	if (!summary) return new Uint8Array(REGISTER_COUNT);
+	if (summary.length !== REGISTER_COUNT) throw new Error("Invalid distinct sketch");
+	const registers = new Uint8Array(REGISTER_COUNT);
+	for (let index = 0; index < REGISTER_COUNT; index += 1) {
+		const value = summary.charCodeAt(index) - OFFSET;
+		if (!Number.isInteger(value) || value < 0 || value > MAX_RANK) throw new Error("Invalid distinct sketch");
+		registers[index] = value;
+	}
+	return registers;
+};
+var encode$1 = (registers) => Array.from(registers, (value) => String.fromCharCode(value + OFFSET)).join("");
+/** The union of sketches, register by register. */
+var mergeDistinct = (summaries) => {
+	const merged = new Uint8Array(REGISTER_COUNT);
+	for (const summary of summaries) {
+		const registers = decode(summary);
+		for (let index = 0; index < REGISTER_COUNT; index += 1) merged[index] = Math.max(merged[index], registers[index]);
+	}
+	return encode$1(merged);
+};
+var DatabaseValueError = class extends Error {
+	name = "DatabaseValueError";
+};
+/** Compares strings in UTF-8 byte order, which is Unicode code point order. */
+var compareUtf8 = (left, right) => {
+	let leftIndex = 0;
+	let rightIndex = 0;
+	while (leftIndex < left.length && rightIndex < right.length) {
+		const leftPoint = left.codePointAt(leftIndex);
+		const rightPoint = right.codePointAt(rightIndex);
+		if (leftPoint !== rightPoint) return leftPoint < rightPoint ? -1 : 1;
+		leftIndex += leftPoint > 65535 ? 2 : 1;
+		rightIndex += rightPoint > 65535 ? 2 : 1;
+	}
+	const leftDone = leftIndex >= left.length;
+	return leftDone === rightIndex >= right.length ? 0 : leftDone ? -1 : 1;
+};
+/** Orders strings by UTF-8 bytes, numbers numerically, and false before true. */
+var compareKeyValues = (left, right) => {
+	if (typeof left === "string" && typeof right === "string") return compareUtf8(left, right);
+	if (typeof left === "number" && typeof right === "number") return left < right ? -1 : left > right ? 1 : 0;
+	if (typeof left === "boolean" && typeof right === "boolean") return Number(left) - Number(right);
+	throw new DatabaseValueError(`Cannot compare ${typeof left} with ${typeof right}.`);
+};
+/** Compares tuples element by element; a shorter equal prefix sorts first. */
+var compareTuples = (left, right) => {
+	for (let index = 0; index < Math.min(left.length, right.length); index += 1) {
+		const result = compareKeyValues(left[index], right[index]);
+		if (result !== 0) return result;
+	}
+	return left.length - right.length;
+};
+/** JSON text with object keys sorted, so a value compares equal after a store reorders map keys. */
+var canonicalJson = (value) => JSON.stringify(value ?? null, (_, inner) => inner !== null && typeof inner === "object" && !Array.isArray(inner) ? Object.fromEntries(Object.entries(inner).sort(([left], [right]) => compareUtf8(left, right))) : inner);
+var isKeyValue = (value) => typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value);
+/** Every `eq` tuple a row is indexed under; none when an index field is null. */
+var indexEntries = (table, index, row) => {
+	if (index.sort.some((column) => !isKeyValue(row[column]))) return [];
+	let entries = [[]];
+	for (const column of index.eq) {
+		const value = row[column];
+		const values = findPhysicalColumn(table, column).multi ? Array.isArray(value) ? value.filter(isKeyValue) : [] : isKeyValue(value) ? [value] : [];
+		if (values.length === 0) return [];
+		entries = entries.flatMap((entry) => [...new Set(values)].map((item) => [...entry, item]));
+	}
+	return entries;
+};
+/** The row's position in an index read, following `indexOrderColumns`. */
+var indexOrderTuple = (table, index, row) => indexOrderColumns(table, index).map((column) => {
+	const value = row[column];
+	if (!isKeyValue(value)) throw new DatabaseValueError(`${table.name}.${column} is not orderable for index ${index.name}.`);
+	return value;
+});
+var satisfiesBound = (tuple, bound, side) => {
+	if (bound === void 0) return true;
+	const result = compareTuples(tuple.slice(0, bound.values.length), bound.values);
+	if (result === 0) return bound.inclusive;
+	return side === "lower" ? result > 0 : result < 0;
+};
+/** Whether a stored row belongs to the result range of a query. */
+var matchesQuery = (table, index, request, row) => indexEntries(table, index, row).some((entry) => compareTuples(entry, request.eq) === 0) && satisfiesBound(indexOrderTuple(table, index, row), request.lower, "lower") && satisfiesBound(indexOrderTuple(table, index, row), request.upper, "upper");
+var DatabaseAdapterContractError = class extends Error {
+	name = "DatabaseAdapterContractError";
+};
+var EMPTY = {
+	gets: 0,
+	keys: 0,
+	queries: 0,
+	rows: 0
+};
+var createReadMeter = () => {
+	const tables = /* @__PURE__ */ new Map();
+	const add = (table, count) => {
+		const current = tables.get(table) ?? EMPTY;
+		tables.set(table, {
+			gets: current.gets + (count.gets ?? 0),
+			keys: current.keys + (count.keys ?? 0),
+			queries: current.queries + (count.queries ?? 0),
+			rows: current.rows + (count.rows ?? 0)
+		});
+	};
+	return {
+		add,
+		meter: {
+			total: () => [...tables.values()].reduce((sum, count) => ({
+				gets: sum.gets + count.gets,
+				keys: sum.keys + count.keys,
+				queries: sum.queries + count.queries,
+				rows: sum.rows + count.rows
+			}), EMPTY),
+			byTable: (table) => tables.get(table) ?? EMPTY,
+			reset: () => tables.clear()
+		}
+	};
+};
+var fail$1 = (message) => {
+	throw new DatabaseAdapterContractError(message);
+};
+var sameKey = (left, right) => left.length === right.length && compareTuples(left, right) === 0;
+var verifyRequest = (table, request) => {
+	const index = findPhysicalIndex(table, request.index);
+	if (!Number.isSafeInteger(request.limit) || request.limit < 1 || request.limit > 500) fail$1(`query limit must be 1–500.`);
+	if (request.eq.length !== index.eq.length || !request.eq.every(isKeyValue)) fail$1(`query on ${table.name}.${index.name} must bind every eq column.`);
+	return index;
+};
+var verifyRows = (table, request, rows) => {
+	const index = findPhysicalIndex(table, request.index);
+	if (rows.length > request.limit) fail$1(`${table.name}.${index.name} returned more than ${request.limit} rows.`);
+	let previous;
+	for (const row of rows) {
+		if (!matchesQuery(table, index, request, row)) fail$1(`${table.name}.${index.name} returned a row outside the request.`);
+		const tuple = indexOrderTuple(table, index, row);
+		if (previous !== void 0) {
+			const order = compareTuples(previous, tuple);
+			if (request.order === "asc" ? order >= 0 : order <= 0) fail$1(`${table.name}.${index.name} returned rows out of order.`);
+		}
+		previous = tuple;
+	}
+	return previous;
+};
+var verifyWrite = (adapter, ops) => {
+	if (ops.length === 0) fail$1("write needs at least one op.");
+	const seen = /* @__PURE__ */ new Set();
+	for (const op of ops) {
+		const key = op.type === "insert" ? rowKey(op.table, op.row) : op.key;
+		const id = JSON.stringify([op.table.name, key]);
+		if (seen.has(id)) fail$1(`write touches ${op.table.name} ${id} twice.`);
+		seen.add(id);
+		if (op.type === "insert" && typeof op.row["_v"] !== "number") fail$1(`insert into ${op.table.name} must set _v.`);
+		if (op.type === "patch" && Object.keys(op.set).some((column) => column === "_v" || op.table.key.includes(column))) fail$1(`patch of ${op.table.name} may not set key columns or _v.`);
+	}
+	if (!adapter.fits(ops)) fail$1("write does not fit in one atomic write.");
+};
+/** Wraps an adapter to check the contract at its boundary and count reads. */
+var verifyAdapter = (adapter, options = {}) => {
+	const { add, meter } = createReadMeter();
+	return {
+		...adapter,
+		id: adapter.id,
+		reads: meter,
+		fits: (ops) => adapter.fits(ops),
+		async get(table, keys) {
+			const rows = await adapter.get(table, keys);
+			add(table.name, {
+				gets: 1,
+				keys: keys.length
+			});
+			if (rows.length !== keys.length) fail$1(`${table.name} get returned ${rows.length} rows for ${keys.length} keys.`);
+			rows.forEach((row, position) => {
+				if (row !== null && !sameKey(rowKey(table, row), keys[position])) fail$1(`${table.name} get returned a row for another key.`);
+			});
+			return rows;
+		},
+		async query(table, request) {
+			const index = verifyRequest(table, request);
+			const rows = await adapter.query(table, request);
+			add(table.name, {
+				queries: 1,
+				rows: rows.length
+			});
+			const last = verifyRows(table, request, rows);
+			if (options.probeShortPages && last !== void 0 && rows.length < request.limit) {
+				const bound = {
+					values: last,
+					inclusive: false
+				};
+				if ((await adapter.query(table, {
+					...request,
+					limit: 1,
+					...request.order === "asc" ? { lower: bound } : { upper: bound }
+				})).length > 0) fail$1(`${table.name}.${index.name} returned a short page before the range ended.`);
+			}
+			return rows;
+		},
+		...adapter.prune && { async prune(table, before, limit) {
+			if (table.retention === void 0) fail$1(`${table.name} has no retention to prune by.`);
+			if (!Number.isSafeInteger(limit) || limit < 1) fail$1("prune limit must be a positive integer.");
+			const deleted = await adapter.prune(table, before, limit);
+			if (!Number.isSafeInteger(deleted) || deleted < 0 || deleted > limit) fail$1(`${table.name} prune reported ${deleted} rows for ${limit}.`);
+			return deleted;
+		} },
+		async write(ops) {
+			verifyWrite(adapter, ops);
+			const result = await adapter.write(ops);
+			if (!result.ok && "failedOp" in result) {
+				if (!Number.isSafeInteger(result.failedOp) || result.failedOp < 0 || result.failedOp >= ops.length) fail$1(`write reported failedOp ${result.failedOp} for ${ops.length} ops.`);
+			}
+			return result;
+		}
+	};
+};
+var SHARD_COLUMN = "_shard";
+var NAME = /^[a-z][a-z0-9_]*$/u;
+var INDEX_NAME = /^[A-Za-z][A-Za-z0-9_]*$/u;
+var tableName = (module, model) => module.namespace ? `${module.namespace}_${model}` : model;
+var integer = (name, defaulted = false) => ({
+	name,
+	type: "integer",
+	nullable: false,
+	...defaulted ? { default: 0 } : {}
+});
+/** A declared or derived field's type, and whether it holds several values. */
+var fieldType = (model, name) => {
+	const field = model.fields[name] ?? (model.kind === "table" ? model.derived[name] : void 0);
+	return field && {
+		type: field.type,
+		multi: "multi" in field && !!field.multi
+	};
+};
+var metricsOf$1 = (model) => [
+	...model.counters,
+	...model.gauges,
+	...model.distinct
+];
+/** Field names, the key, and each field's options. */
+var fieldProblems = (definition, add) => {
+	const names = [...Object.keys(definition.fields), ...definition.kind === "table" ? Object.keys(definition.derived) : metricsOf$1(definition)];
+	for (const name of new Set(names)) {
+		if (!NAME.test(name)) add(`field "${name}" must match ${NAME.source}`);
+		if (names.indexOf(name) !== names.lastIndexOf(name)) add(`field "${name}" is declared twice`);
+	}
+	const { key } = definition;
+	if (key.length === 0) add("key is empty");
+	if (new Set(key).size !== key.length) add("key repeats a field");
+	for (const name of key) {
+		const field = definition.fields[name];
+		if (field === void 0) add(`key field "${name}" is not a declared field`);
+		else if (field.required === false) add(`key field "${name}" is nullable`);
+		else if (field.type === "json") add(`key field "${name}" is json`);
+	}
+	for (const [name, { type, maxLength, ascii }] of Object.entries(definition.fields)) {
+		if (maxLength !== void 0 && (type !== "string" || !Number.isSafeInteger(maxLength) || maxLength < 1)) add(`field "${name}" has an invalid maxLength`);
+		if (ascii && type !== "string") add(`field "${name}" is ascii but not a string`);
+	}
+};
+/** A table's derived fields and references. */
+var tableProblems = (definition, add, table) => {
+	for (const [name, derived] of Object.entries(definition.derived)) {
+		if (typeof derived.compute !== "function") add(`derived field "${name}" has no compute function`);
+		if (derived.multi && derived.type === "json") add(`derived field "${name}" cannot be multi-valued json`);
+	}
+	for (const [name, { type, references }] of Object.entries(definition.fields)) {
+		if (references === void 0) continue;
+		const target = table(references.model);
+		const targetKey = target?.key.length === 1 ? target.fields[target.key[0]] : void 0;
+		if (targetKey === void 0) add(`field "${name}" references "${references.model}", which is not a single-key table of this module`);
+		else if (targetKey.type !== type) add(`field "${name}" and the key of "${references.model}" differ in type`);
+		if (references.onDelete === "cascade" && !Object.values(definition.indexes).some(({ eq }) => eq.length === 1 && eq[0] === name)) add(`cascade on "${name}" needs an index whose eq is exactly [${name}]`);
+	}
+};
+/** An aggregate's identity, metrics, and shards. */
+var aggregateProblems = (definition, add) => {
+	const identity = Object.keys(definition.fields);
+	if (definition.key.join("\0") !== identity.join("\0")) add(`key must list the identity fields in declaration order: ${identity.join(", ")}`);
+	if (metricsOf$1(definition).length === 0) add("aggregate has no metrics");
+	if (definition.distinct.length > 0 && definition.counters.length + definition.gauges.length > 0) add("distinct sketches need an aggregate of their own");
+	const { shards } = definition;
+	if (!Number.isSafeInteger(shards) || shards < 1 || shards > 64) add(`shards must be 1–64`);
+};
+/** Every problem in one model's declaration, its roots and references included. */
+var problemsOf = (module, model, definition) => {
+	const problems = [];
+	const add = (message) => problems.push(`${module.id}.${model}: ${message}`);
+	const table = (name) => {
+		const target = module.schema[name];
+		return target?.kind === "table" ? target : void 0;
+	};
+	if (!NAME.test(model)) add("model names use lowercase letters, digits, and _");
+	fieldProblems(definition, add);
+	for (const [name, index] of Object.entries(definition.indexes)) {
+		const columns = [...index.eq, ...index.sort];
+		if (!INDEX_NAME.test(name)) add(`index "${name}" must match ${INDEX_NAME.source}`);
+		if (columns.length === 0) add(`index "${name}" has no fields`);
+		if (index.unique && index.sort.length > 0) add(`unique index "${name}" cannot sort`);
+		if (columns.filter((column) => {
+			const type = fieldType(definition, column);
+			if (type === void 0) add(`index "${name}" names undeclared field "${column}"`);
+			else if (type.type === "json") add(`index "${name}" names json field "${column}"`);
+			else if (type.multi && index.sort.includes(column)) add(`index "${name}" sorts by multi-valued field "${column}"`);
+			return type?.type !== "json" && type?.multi;
+		}).length > 1) add(`index "${name}" has more than one multi-valued field`);
+		if (index.root === void 0) continue;
+		const root = table(index.root.model);
+		if (root === void 0) add(`index "${name}" is rooted at unknown table "${index.root.model}"`);
+		else if (root.key.length > index.eq.length || root.key.some((field, position) => fieldType(definition, index.eq[position])?.type !== root.fields[field].type)) add(`index "${name}" eq must start with the key of "${index.root.model}"`);
+	}
+	if (definition.kind === "table") tableProblems(definition, add, table);
+	else aggregateProblems(definition, add);
+	for (const problem of retentionProblems(module.schema, model)) add(problem);
+	return problems;
+};
+/** Rejects invalid module schemas at startup, listing every problem. */
+var validateSchema = (modules) => {
+	const problems = [];
+	const owners = /* @__PURE__ */ new Map();
+	for (const module of modules) for (const [model, definition] of Object.entries(module.schema)) {
+		const name = tableName(module, model);
+		const owner = owners.get(name);
+		if (owner !== void 0) problems.push(`${module.id}.${model}: table "${name}" is also declared by ${owner}`);
+		owners.set(name, `${module.id}.${model}`);
+		problems.push(...problemsOf(module, model, definition));
+	}
+	if (problems.length > 0) throw new DatabaseSchemaError(`Invalid database schema:\n- ${problems.join("\n- ")}`);
+};
+var indexesOf = (definition) => [...Object.entries(definition.indexes).map(([name, index]) => ({
+	name,
+	eq: [...index.eq],
+	sort: [...index.sort],
+	...index.unique ? { unique: true } : {}
+})), ...Object.entries(definition.fields).flatMap(([name, field]) => field.unique ? [{
+	name,
+	eq: [name],
+	sort: [],
+	unique: true
+}] : [])];
+/** Validates the modules, then resolves them into physical tables with engine columns. */
+var resolveSchema = (modules) => {
+	validateSchema(modules);
+	const references = [];
+	for (const module of modules) for (const [model, definition] of Object.entries(module.schema)) {
+		if (definition.kind !== "table") continue;
+		const table = tableName(module, model);
+		for (const [field, { references: to }] of Object.entries(definition.fields)) {
+			if (to === void 0) continue;
+			const { onDelete } = to;
+			const target = tableName(module, to.model);
+			const counter = onDelete === "none" ? {} : { counter: `_refs_${table}_${field}` };
+			references.push({
+				table,
+				field,
+				target,
+				onDelete,
+				...counter
+			});
+		}
+	}
+	const models = /* @__PURE__ */ new Map();
+	for (const module of modules) for (const [model, definition] of Object.entries(module.schema)) {
+		const name = tableName(module, model);
+		const referencedBy = references.filter(({ target }) => target === name);
+		const columns = Object.entries(definition.fields).map(([field, { type, required, maxLength, ascii }]) => ({
+			name: field,
+			type,
+			nullable: required === false,
+			...maxLength === void 0 ? {} : { maxLength },
+			...ascii ? { ascii } : {}
+		}));
+		if (definition.kind === "table") for (const [field, { type, multi }] of Object.entries(definition.derived)) columns.push({
+			name: field,
+			type,
+			nullable: true,
+			...multi ? { multi } : {}
+		});
+		else columns.push(integer(SHARD_COLUMN), ...[...definition.counters, ...definition.gauges].map((metric) => integer(metric)), ...definition.distinct.map((metric) => ({
+			name: metric,
+			type: "string",
+			nullable: true
+		})));
+		for (const { counter } of referencedBy) if (counter !== void 0) columns.push(integer(counter, true));
+		columns.push(integer("_v", true));
+		models.set(name, {
+			module: module.id,
+			model,
+			definition,
+			table: {
+				name,
+				columns,
+				key: definition.kind === "aggregate" ? [...definition.key, SHARD_COLUMN] : [...definition.key],
+				indexes: indexesOf(definition),
+				...physicalRetention(definition)
+			},
+			references: references.filter(({ table }) => table === name),
+			referencedBy,
+			roots: new Map(Object.entries(definition.indexes).flatMap(([index, { root }]) => root === void 0 ? [] : [[index, tableName(module, root.model)]]))
+		});
+	}
+	return {
+		models,
+		tables: [...models.values()].map(({ table }) => table)
+	};
+};
+var DatabaseConstraintError = class extends Error {
+	reason;
+	model;
+	name = "DatabaseConstraintError";
+	constructor(reason, model) {
+		super(`${model}: ${reason}`);
+		this.reason = reason;
+		this.model = model;
+	}
+};
+/** The retry budget ran out; ingestion answers 503 with Retry-After. */
+var DatabaseConflictError = class extends Error {
+	name = "DatabaseConflictError";
+};
+/** The write may or may not have committed; it is reported, never rerun. */
+var DatabaseAmbiguousCommitError = class extends Error {
+	name = "DatabaseAmbiguousCommitError";
+};
+var DatabaseTransactionError = class extends Error {
+	name = "DatabaseTransactionError";
+};
+var DatabaseCursorError = class extends Error {
+	name = "DatabaseCursorError";
+};
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+var toBase64Url = (text) => {
+	let binary = "";
+	for (const byte of encoder.encode(text)) binary += String.fromCharCode(byte);
+	return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/u, "");
+};
+var fromBase64Url = (value) => {
+	const binary = atob(value.replaceAll("-", "+").replaceAll("_", "/"));
+	return decoder.decode(Uint8Array.from(binary, (char) => char.charCodeAt(0)));
+};
+/** A stable 32-bit FNV-1a hash of the text's UTF-8 bytes. */
+var fnv1a = (text) => {
+	let hash = 2166136261;
+	for (const byte of encoder.encode(text)) hash = Math.imul(hash ^ byte, 16777619) >>> 0;
+	return hash;
+};
+/** A hash of the request's identity; a cursor only resumes the same read. */
+var cursorScope = (parts) => fnv1a(JSON.stringify(parts)).toString(36);
+var encodeCursor = (scope, after) => toBase64Url(JSON.stringify([scope, after]));
+/** The order tuple a cursor resumes after; rejects a cursor from another read. */
+var decodeCursor = (scope, cursor) => {
+	let decoded;
+	try {
+		decoded = JSON.parse(fromBase64Url(cursor));
+	} catch {
+		decoded = void 0;
+	}
+	const [from, after] = Array.isArray(decoded) ? decoded : [];
+	if (typeof from !== "string" || !Array.isArray(after) || !after.every(isKeyValue)) throw new DatabaseCursorError("The cursor is malformed.");
+	if (from !== scope) throw new DatabaseCursorError("The cursor belongs to a read with another model, index, filter, order, or range.");
+	return after;
+};
+var definitionOf = (model) => model.definition;
+/** Every change keyed by one value lands on one shard. */
+var shardOf = (value, shards) => fnv1a(value) % shards;
+/** Merges one `tx.aggregate` call into its shard row's pending changes. */
+var recordAggregate = (changes, model, identity, values, shardBy) => {
+	const { key: fields, counters, gauges, distinct, shards } = definitionOf(model);
+	const fail = (message) => new DatabaseTransactionError(`${model.table.name}: ${message}`);
+	if (Object.keys(identity).length !== fields.length || !fields.every((name) => isKeyValue(identity[name]))) throw fail(`aggregate takes exactly its identity fields: ${fields.join(", ")}.`);
+	if (shardBy === void 0 && shards > 1 && gauges.some((gauge) => gauge in values)) throw fail("gauges of a sharded aggregate need shardBy.");
+	const shard = shardBy === void 0 ? Math.floor(Math.random() * shards) : shardOf(shardBy, shards);
+	const key = [...fields.map((name) => identity[name]), shard];
+	const id = JSON.stringify([model.table.name, key]);
+	const change = changes.get(id) ?? {
+		model,
+		key,
+		deltas: {},
+		sketches: {}
+	};
+	changes.set(id, change);
+	for (const [metric, value] of Object.entries(values)) if (distinct.includes(metric) && typeof value === "string") change.sketches[metric] = mergeDistinct([change.sketches[metric], value]);
+	else if ((counters.includes(metric) || gauges.includes(metric)) && Number.isSafeInteger(value)) change.deltas[metric] = (change.deltas[metric] ?? 0) + Number(value);
+	else throw fail(`${metric} is not a counter, gauge, or sketch of this aggregate.`);
+};
+/** A shard row before its first change: every metric zero or empty. */
+var blank$1 = (model, key) => {
+	const { counters, gauges, distinct } = definitionOf(model);
+	return Object.fromEntries([
+		...model.table.key.map((column, position) => [column, key[position]]),
+		...[...counters, ...gauges].map((name) => [name, 0]),
+		...distinct.map((name) => [name, null]),
+		["_v", 0]
+	]);
+};
+/**
+* A gauge computed below zero. Deltas from a row another writer has since
+* moved do this, so the transaction reruns; it is thrown only when it lasts.
+*/
+var NegativeGaugeError = class extends DatabaseTransactionError {};
+/** The guarded write that merges `change` into `current`: insert, patch, or delete at zero. */
+var rewrite$1 = ({ model, key, deltas, sketches }, current) => {
+	const { table } = model;
+	const { counters, gauges, distinct } = definitionOf(model);
+	const base = current ?? blank$1(model, key);
+	const set = {};
+	for (const [metric, delta] of Object.entries(deltas)) set[metric] = Number(base[metric] ?? 0) + delta;
+	for (const [metric, sketch] of Object.entries(sketches)) set[metric] = mergeDistinct([base[metric], sketch]);
+	if (current && Object.entries(set).every(([metric, value]) => current[metric] === value)) return;
+	const row = {
+		...base,
+		...set
+	};
+	if (gauges.some((gauge) => Number(row[gauge]) < 0)) {
+		if (current === null && table.retention) return void 0;
+		throw new NegativeGaugeError(`${table.name}: a gauge went below 0.`);
+	}
+	const zero = distinct.length === 0 && [...counters, ...gauges].every((metric) => Number(row[metric]) === 0);
+	if (current === null) return zero ? void 0 : {
+		type: "insert",
+		table,
+		row
+	};
+	const guard = { v: Number(current["_v"]) };
+	return zero ? {
+		type: "delete",
+		table,
+		key,
+		guard,
+		previous: current
+	} : {
+		type: "patch",
+		table,
+		key,
+		set,
+		guard,
+		previous: current
+	};
+};
+/**
+* Counter-only rows become blind increments that create the row when it is
+* missing. Rows with gauges or sketches are read in one parallel batch per
+* table, merged, and written back under a guard, so a conflict resends only
+* them.
+*/
+var compileAggregates = async (adapter, changes) => {
+	const ops = [];
+	const merged = /* @__PURE__ */ new Map();
+	for (const change of changes) {
+		const { model, key, deltas, sketches } = change;
+		if (Object.keys(sketches).length > 0 || definitionOf(model).gauges.some((gauge) => (deltas[gauge] ?? 0) !== 0)) merged.set(model, [...merged.get(model) ?? [], change]);
+		else if (Object.values(deltas).some((delta) => delta !== 0)) {
+			const { table } = model;
+			const init = blank$1(model, key);
+			ops.push({
+				type: "increment",
+				table,
+				key,
+				by: deltas,
+				init
+			});
+		}
+	}
+	const groups = [...merged.values()];
+	const current = await Promise.all(groups.map((group) => adapter.get(group[0].model.table, group.map(({ key }) => key))));
+	groups.forEach((group, index) => group.forEach((change, position) => {
+		const op = rewrite$1(change, current[index][position] ?? null);
+		if (op !== void 0) ops.push(op);
+	}));
+	return ops;
+};
+var defineTable = (fields, options) => ({
+	kind: "table",
+	fields,
+	key: options.key,
+	derived: options.derived ?? {},
+	indexes: options.indexes ?? {},
+	...options.retention === void 0 ? {} : { retention: options.retention }
+});
+var defineAggregate = (fields, options) => ({
+	kind: "aggregate",
+	fields,
+	key: options.key,
+	counters: options.counters ?? [],
+	gauges: options.gauges ?? [],
+	distinct: options.distinct ?? [],
+	shards: options.shards ?? 1,
+	indexes: options.indexes ?? {},
+	...options.batched ? { batched: true } : {},
+	...options.retention === void 0 ? {} : { retention: options.retention }
+});
+/** Log rows spread over 8 tables, each its own DynamoDB partition. */
+var LOG_TABLES = [
+	0,
+	1,
+	2,
+	3,
+	4,
+	5,
+	6,
+	7
+].map((at) => `aggregate_log_${at}`);
+var LEASE_TABLE = "aggregate_lease";
+var LEASE = { id: "compaction" };
+/** How long a compaction holds the lease before another process may take it. */
+var LEASE_MS = 3e4;
+/**
+* Default windows: log mode compacts every 60 seconds, since reads compact
+* first; memory mode flushes every 15, since its window is what a crash
+* loses.
+*/
+var WINDOW_MS = {
+	log: 6e4,
+	memory: 15e3
+};
+/** Log rows a compaction reads from each log table for one group. */
+var LOG_PAGE = 200;
+/**
+* Groups one compaction applies: after a commit, so the request that runs
+* it waits for one group; before a read; and on flush.
+*/
+var GROUPS = {
+	commit: 1,
+	read: 8,
+	flush: 256
+};
+/** Tries per write after a conflict or a transient error. */
+var ATTEMPTS = 5;
+/** Aggregate rows a memory buffer holds before a commit waits for a flush. */
+var MAX_BUFFERED = 1e4;
+var log = defineTable({
+	id: {
+		type: "string",
+		maxLength: 32
+	},
+	changes: { type: "string" }
+}, {
+	key: ["id"],
+	indexes: { oldest: {
+		eq: [],
+		sort: ["id"]
+	} }
+});
+/**
+* Held by `holder` until `until`; the next compaction is due at `next`.
+* `applied` lists the log rows a compaction has applied and not yet deleted,
+* as `[log table's index, id]` pairs, so no compaction applies them again.
+*/
+var lease = defineTable({
+	id: {
+		type: "string",
+		maxLength: 16
+	},
+	holder: {
+		type: "string",
+		maxLength: 32
+	},
+	until: { type: "integer" },
+	next: { type: "integer" },
+	applied: { type: "string" }
+}, { key: ["id"] });
+/** The log and lease tables; an engine that batches has them in its schema. */
+var aggregateBatchingModule = {
+	id: "aggregateBatching",
+	schema: {
+		...Object.fromEntries(LOG_TABLES.map((table) => [table, log])),
+		[LEASE_TABLE]: lease
+	}
+};
+var shapeOf = (model) => model.definition;
+var isBatched = (model) => model?.definition.kind === "aggregate" && shapeOf(model).batched === true;
+var valuesOf = ({ deltas, sketches }) => ({
+	...deltas,
+	...sketches
+});
+/**
+* Merges `values` into the change for `key`'s identity as `tx.aggregate`
+* does: deltas add up and sketches merge. One constant `shardBy` keys each
+* identity to one entry; the write picks the shard.
+*/
+var merge = (into, model, key, values) => recordAggregate(into, model, Object.fromEntries(shapeOf(model).key.map((field, at) => [field, key[at]])), values, "");
+var mergeAll = (into, changes) => {
+	for (const change of changes) merge(into, change.model, change.key, valuesOf(change));
+	return into;
+};
+/** A row's metrics as values to merge: counters, gauges, and the sketches it has. */
+var metricsOf = (model, row) => {
+	const { counters, gauges, distinct } = shapeOf(model);
+	return Object.fromEntries([...[...counters, ...gauges].map((name) => [name, Number(row[name] ?? 0)]), ...distinct.flatMap((name) => row[name] === null || row[name] === void 0 ? [] : [[name, row[name]]])]);
+};
+/** A shard row before its first change: every metric zero or empty. */
+var blank = (model, key) => {
+	const { counters, gauges, distinct } = shapeOf(model);
+	return Object.fromEntries([
+		...model.table.key.map((column, at) => [column, key[at]]),
+		...[...counters, ...gauges].map((name) => [name, 0]),
+		...distinct.map((name) => [name, null]),
+		["_v", 0]
+	]);
+};
+/** Whether a change needs its row: sketches merge, and a gauge may reach zero. */
+var rewrites = ({ model, deltas, sketches }) => Object.keys(sketches).length > 0 || shapeOf(model).gauges.some((gauge) => (deltas[gauge] ?? 0) !== 0);
+var increment = ({ model, deltas }, key) => Object.values(deltas).some((delta) => delta !== 0) ? {
+	type: "increment",
+	table: model.table,
+	key,
+	by: deltas,
+	init: blank(model, key)
+} : void 0;
+/**
+* The guarded write that merges `change` into `current`: insert, patch, or
+* delete at zero. Unlike a transaction's, a gauge may go below zero here: a
+* shard row holds one writer's net changes, and reads sum every shard.
+*/
+var rewrite = (change, key, current) => {
+	const { model } = change;
+	const { table } = model;
+	const { counters, gauges, distinct } = shapeOf(model);
+	const base = current ?? blank(model, key);
+	const sum = mergeAll(/* @__PURE__ */ new Map(), [change]);
+	merge(sum, model, key, metricsOf(model, base));
+	const set = valuesOf([...sum.values()][0]);
+	if (current && Object.keys(set).every((name) => current[name] === set[name])) return void 0;
+	const row = {
+		...base,
+		...set
+	};
+	const zero = distinct.length === 0 && [...counters, ...gauges].every((name) => Number(row[name]) === 0);
+	if (current === null) return zero ? void 0 : {
+		type: "insert",
+		table,
+		row
+	};
+	const guard = { v: Number(current["_v"]) };
+	return zero ? {
+		type: "delete",
+		table,
+		key,
+		guard,
+		previous: current
+	} : {
+		type: "patch",
+		table,
+		key,
+		set,
+		guard,
+		previous: current
+	};
+};
+/**
+* The write for each change on its shard: a blind increment that creates
+* the row for counters, and a guarded rewrite for gauges and sketches, whose
+* rows are read in one batch per table.
+*/
+var compile = async (adapter, changes, shard) => {
+	const keys = changes.map(({ model, key }) => [...key.slice(0, -1), shard(model)]);
+	const reads = /* @__PURE__ */ new Map();
+	changes.forEach((change, at) => {
+		if (rewrites(change)) reads.set(change.model, [...reads.get(change.model) ?? [], at]);
+	});
+	const current = /* @__PURE__ */ new Map();
+	await Promise.all([...reads].map(async ([model, positions]) => {
+		const rows = await adapter.get(model.table, positions.map((at) => keys[at]));
+		positions.forEach((at, index) => current.set(at, rows[index] ?? null));
+	}));
+	return changes.map((change, at) => current.has(at) ? rewrite(change, keys[at], current.get(at)) : increment(change, keys[at]));
+};
+var isOp = (op) => op !== void 0;
+var sleep = (attempt) => new Promise((resolve) => setTimeout(resolve, Math.min(250, 5 * 2 ** attempt) * Math.random()));
+/** Runs of one character, where shorter: a sparse sketch packs into a few. */
+var pack = (text) => {
+	const runs = (text.match(/(.)\1*/gsu) ?? []).flatMap((run) => [run[0], run.length]);
+	return JSON.stringify(runs).length < JSON.stringify(text).length ? runs : text;
+};
+var unpack = (value) => Array.isArray(value) ? value.map((item, at) => at % 2 ? "" : item.repeat(value[at + 1])).join("") : value;
+/** Raw deflate of `text` as base64, where the runtime has `CompressionStream`. */
+var deflate = async (text) => {
+	if (typeof CompressionStream === "undefined") return void 0;
+	const stream = new Blob([text]).stream().pipeThrough(new CompressionStream("deflate-raw"));
+	let binary = "";
+	for (const byte of new Uint8Array(await new Response(stream).arrayBuffer())) binary += String.fromCharCode(byte);
+	return btoa(binary);
+};
+var inflate = (base64) => new Response(new Blob([Uint8Array.from(atob(base64), (char) => char.charCodeAt(0))]).stream().pipeThrough(new DecompressionStream("deflate-raw"))).text();
+/**
+* A log row's `changes`: entries of a table, an identity, and values, as
+* JSON, or `z` and its deflate where shorter, so a row stays under the 1 KB
+* that DynamoDB bills as one unit.
+*/
+var encode = async (changes) => {
+	const json = JSON.stringify({
+		v: 1,
+		c: [...changes].map(({ model, key, deltas, sketches }) => {
+			const packed = Object.entries(sketches).map(([name, sketch]) => [name, pack(sketch)]);
+			const values = {
+				...deltas,
+				...Object.fromEntries(packed)
+			};
+			return [
+				model.table.name,
+				key.slice(0, -1),
+				values
+			];
+		})
+	});
+	const zipped = await deflate(json);
+	return zipped !== void 0 && zipped.length < json.length ? `z${zipped}` : json;
+};
+/**
+* Batches changes to aggregates declared `batched`. A transaction records
+* them without writing their rows; once it commits, "memory" mode keeps
+* them in this process until its timer flushes them, and "log" mode has
+* written them as one log row in the same atomic write, which a compaction
+* later merges into the aggregates and deletes, atomically again, so each
+* applies exactly once. One lease row keeps compactions one at a time.
+*/
+var createAggregateBatches = ({ engine, adapter, schema, batching: { mode = "log", windowMs = WINDOW_MS[mode] }, now }) => {
+	if (!schema.models.has(LEASE_TABLE)) throw new DatabaseTransactionError("An engine that batches aggregates needs aggregateBatchingModule in its schema.");
+	const holder = crypto.randomUUID().replaceAll("-", "");
+	const table = (name) => schema.models.get(name).table;
+	const warned = /* @__PURE__ */ new Set();
+	const warn = (what) => (error) => {
+		if (warned.has(what)) return;
+		warned.add(what);
+		console.warn(`[hot-updater] Aggregate ${what} failed.`, error);
+	};
+	/** A log row's changes, or undefined when it names an aggregate or metric this schema lacks. */
+	const decode = async (text) => {
+		const changes = /* @__PURE__ */ new Map();
+		try {
+			const json = text.startsWith("z") ? await inflate(text.slice(1)) : text;
+			const { c } = JSON.parse(json);
+			for (const [name, identity, values] of c) {
+				const model = schema.models.get(name);
+				if (!isBatched(model)) return void 0;
+				const unpacked = Object.entries(values).map(([metric, value]) => [metric, unpack(value)]);
+				merge(changes, model, [...identity, 0], Object.fromEntries(unpacked));
+			}
+		} catch (error) {
+			warn("log decoding")(error);
+			return;
+		}
+		return changes;
+	};
+	/**
+	* Writes changes in atomic chunks within `fits`, and returns the ones it
+	* could not apply. A write whose outcome is unknown is dropped, never
+	* resent, so no change applies twice.
+	*/
+	const apply = async (changes, shard) => {
+		let rest = changes;
+		let ops = [];
+		let read = true;
+		for (let failures = 0; rest.length > 0 && failures < ATTEMPTS;) try {
+			if (read) ops = await compile(adapter, rest, shard);
+			let size = rest.length;
+			const chunk = () => ops.slice(0, size).filter(isOp);
+			while (size > 1 && !adapter.fits(chunk())) size = Math.ceil(size / 2);
+			let result = { ok: true };
+			if (chunk().length > 0) result = await adapter.write(chunk()).catch((error) => {
+				warn("flush")(error);
+				return { ok: true };
+			});
+			read = !result.ok && !("retry" in result);
+			if (result.ok) {
+				rest = rest.slice(size);
+				ops = ops.slice(size);
+				failures = 0;
+			} else {
+				failures += 1;
+				if (!read) await sleep(failures);
+			}
+		} catch (error) {
+			warn("flush")(error);
+			return rest;
+		}
+		return rest;
+	};
+	let buffer = /* @__PURE__ */ new Map();
+	let timer;
+	let flushing;
+	const shards = /* @__PURE__ */ new Map();
+	/** Each process writes its own shard, so flushes of two processes rarely meet. */
+	const processShard = (model) => {
+		if (!shards.has(model)) shards.set(model, Math.floor(Math.random() * shapeOf(model).shards));
+		return shards.get(model);
+	};
+	const schedule = () => {
+		if (timer !== void 0 || buffer.size === 0) return;
+		timer = setTimeout(() => {
+			timer = void 0;
+			flushBuffer();
+		}, windowMs);
+		timer.unref?.();
+	};
+	/** Never rejects: what it cannot apply goes back into the buffer. */
+	const flushBuffer = () => flushing ??= (async () => {
+		clearTimeout(timer);
+		timer = void 0;
+		const pending = [...buffer.values()];
+		buffer = /* @__PURE__ */ new Map();
+		mergeAll(buffer, await apply(pending, processShard));
+	})().catch(warn("flush")).finally(() => {
+		flushing = void 0;
+		schedule();
+	});
+	let nextDue = 0;
+	let compacting;
+	/** Log rows this process read, by `[log table's index, id]`, for the deletes after a group. */
+	const known = /* @__PURE__ */ new Map();
+	const idOf = (shard, id) => JSON.stringify([shard, id]);
+	/** The lease row as stored once `set` is written over it. */
+	const leaseOp = (held, set) => {
+		const next = {
+			...held,
+			...set,
+			_v: Number(held._v) + 1
+		};
+		return {
+			op: {
+				type: "patch",
+				table: table(LEASE_TABLE),
+				key: [LEASE.id],
+				set,
+				guard: { v: Number(held._v) },
+				previous: held
+			},
+			next
+		};
+	};
+	/** The lease row as stored after this process takes it, or undefined when it is held or not due. */
+	const takeLease = (force) => engine.transaction(async (tx) => {
+		const at = now();
+		const held = await tx.findOne(LEASE_TABLE, LEASE);
+		const fields = {
+			holder,
+			until: at + LEASE_MS
+		};
+		if (held === null) {
+			const row = {
+				...LEASE,
+				...fields,
+				next: 0,
+				applied: "[]"
+			};
+			tx.create(LEASE_TABLE, row);
+			return {
+				...row,
+				_v: 0
+			};
+		}
+		nextDue = Number(held.next);
+		if (held.holder !== holder && Number(held.until) > at || !force && nextDue > at) return void 0;
+		tx.update(LEASE_TABLE, held, fields);
+		return {
+			...held,
+			...fields,
+			_v: Number(held._v) + 1
+		};
+	});
+	/**
+	* Writes `ops` once, retrying transient errors; true when it committed.
+	* A conflict leaves its log rows for the next compaction; a write whose
+	* outcome is unknown throws, and the next compaction reads what it did.
+	*/
+	const commit = async (ops) => {
+		for (let failures = 0; failures < ATTEMPTS; failures += 1) {
+			const result = await adapter.write(ops);
+			if (result.ok) return true;
+			if (!("retry" in result)) return false;
+			await sleep(failures);
+		}
+		return false;
+	};
+	/** Deletes the log rows `held` lists as applied, in parallel writes; true once none is left. */
+	const deleteApplied = async (held) => {
+		const applied = JSON.parse(String(held.applied));
+		await Promise.all(LOG_TABLES.map(async (name, shard) => {
+			const ids = applied.flatMap(([at, id]) => at === shard && !known.has(idOf(at, id)) ? [id] : []);
+			if (ids.length === 0) return;
+			const rows = await adapter.get(table(name), ids.map((id) => [id]));
+			for (const row of rows) if (row) known.set(idOf(shard, row.id), row);
+		}));
+		const rows = applied.flatMap(([shard, id]) => {
+			const row = known.get(idOf(shard, id));
+			return row === void 0 ? [] : [{
+				shard,
+				row
+			}];
+		});
+		if (adapter.deleteConsumed && await Promise.all(LOG_TABLES.map((name, at) => {
+			const own = rows.flatMap(({ shard, row }) => shard === at ? [row] : []);
+			return own.length > 0 && adapter.deleteConsumed(table(name), own);
+		})).then(() => true, (error) => (warn("log cleanup")(error), false))) {
+			for (const [shard, id] of applied) known.delete(idOf(shard, id));
+			return true;
+		}
+		const deletes = rows.map(({ shard, row }) => {
+			const guard = { v: Number(row["_v"]) };
+			return {
+				type: "delete",
+				table: table(LOG_TABLES[shard]),
+				key: [String(row.id)],
+				guard,
+				previous: row
+			};
+		});
+		let size = deletes.length;
+		while (size > 1 && !adapter.fits(deletes.slice(0, size))) size = Math.ceil(size / 2);
+		const chunks = [];
+		for (let at = 0; at < deletes.length; at += size) chunks.push(deletes.slice(at, at + size));
+		if ((await Promise.all(chunks.map(commit))).includes(false)) return false;
+		for (const [shard, id] of applied) known.delete(idOf(shard, id));
+		return true;
+	};
+	/**
+	* The oldest pending log rows this schema can read, a page from each
+	* table; `more` when a page was full, so more may wait.
+	*/
+	const readLogs = async () => {
+		let more = false;
+		return {
+			logs: (await Promise.all(LOG_TABLES.map(async (name, shard) => {
+				const page = await engine.reads.findMany(name, {
+					index: "oldest",
+					limit: LOG_PAGE
+				});
+				more ||= page.next !== void 0;
+				return (await Promise.all(page.rows.map(async (row) => ({
+					shard,
+					row,
+					changes: await decode(String(row.changes))
+				})))).flatMap(({ changes, ...entry }) => changes === void 0 ? [] : [{
+					...entry,
+					changes
+				}]);
+			}))).flat().sort((left, right) => compareUtf8(String(left.row.id), String(right.row.id))),
+			more
+		};
+	};
+	const rowsFor = async (changes) => (await compile(adapter, changes, () => 0)).filter(isOp);
+	/**
+	* Applies the oldest pending log rows whose merged changes fit in one
+	* atomic write with the lease, which lists them as applied; the rows are
+	* deleted after it. A log row too large for one write applies in parts,
+	* keeping the rest in it. Returns the lease after the write and how many
+	* log rows it applied whole, or undefined when a conflict stopped it.
+	*/
+	const applyGroup = async (held, logs) => {
+		for (let count = logs.length; count > 0; count = Math.floor(count / 2)) {
+			const batch = logs.slice(0, count);
+			const changes = mergeAll(/* @__PURE__ */ new Map(), batch.flatMap((entry) => [...entry.changes.values()]));
+			const applied = batch.map(({ shard, row }) => [shard, row.id]);
+			const lease = leaseOp(held, { applied: JSON.stringify(applied) });
+			const ops = [...await rowsFor([...changes.values()]), lease.op];
+			if (!adapter.fits(ops)) continue;
+			for (const { shard, row } of batch) known.set(idOf(shard, row.id), row);
+			return await commit(ops) ? {
+				held: lease.next,
+				count
+			} : void 0;
+		}
+		const [{ shard, row, changes }] = logs;
+		const name = LOG_TABLES[shard];
+		const entries = [...changes.values()];
+		for (let take = entries.length - 1; take > 0; take = Math.floor(take / 2)) {
+			const kept = {
+				type: "patch",
+				table: table(name),
+				key: [String(row.id)],
+				set: { changes: await encode(entries.slice(take)) },
+				guard: { v: Number(row["_v"]) },
+				previous: row
+			};
+			const lease = leaseOp(held, {});
+			const ops = [
+				...await rowsFor(entries.slice(0, take)),
+				kept,
+				lease.op
+			];
+			if (adapter.fits(ops)) return await commit(ops) ? {
+				held: lease.next,
+				count: 0
+			} : void 0;
+		}
+		throw new DatabaseTransactionError(`${name}: one aggregate change does not fit in one write.`);
+	};
+	/**
+	* Applies up to `groups` groups under the lease, deleting each group's log
+	* rows before the next; the next compaction is due at once when some are
+	* left. The lease release clears the applied list once its rows are gone.
+	*/
+	const run = async (force, groups) => {
+		let held = await takeLease(force);
+		if (held === void 0) return;
+		let pending = true;
+		let clear = false;
+		try {
+			for (let group = 0;; group += 1) {
+				clear = await deleteApplied(held);
+				if (!clear || !pending || group === groups) break;
+				const { logs, more } = await readLogs();
+				if (logs.length === 0) {
+					pending = false;
+					break;
+				}
+				const applied = await applyGroup(held, logs);
+				if (applied === void 0) break;
+				[held, clear] = [applied.held, false];
+				pending = more || applied.count < logs.length;
+			}
+		} finally {
+			nextDue = now() + (pending ? 0 : windowMs);
+			const set = {
+				until: 0,
+				next: nextDue,
+				...clear ? { applied: "[]" } : {}
+			};
+			await commit([leaseOp(held, set).op]);
+			known.clear();
+		}
+	};
+	/** One compaction at a time in this process; never rejects. */
+	const compact = (force, groups) => compacting ??= run(force, groups).catch(warn("compaction")).finally(() => {
+		compacting = void 0;
+	});
+	let checking;
+	/** Whether any log row waits; reads at once share one check. */
+	const hasPending = () => checking ??= Promise.all(LOG_TABLES.map((name) => engine.reads.findMany(name, {
+		index: "oldest",
+		limit: 1
+	}))).then((pages) => pages.some((page) => page.rows.length > 0)).finally(() => {
+		checking = void 0;
+	});
+	/** Takes a committed transaction's changes; never rejects, since the transaction already committed. */
+	const committed = async (changes) => {
+		if (mode === "log") {
+			if (now() >= nextDue) await compact(false, GROUPS.commit);
+			return;
+		}
+		mergeAll(buffer, changes.values());
+		schedule();
+		if (buffer.size >= MAX_BUFFERED) await flushBuffer();
+	};
+	const flush = async () => {
+		await flushBuffer();
+		if (mode === "log" && await hasPending()) await compact(true, GROUPS.flush);
+	};
+	return {
+		async transaction(fn) {
+			let changes = /* @__PURE__ */ new Map();
+			const result = await engine.transaction(async (tx) => {
+				const attempt = /* @__PURE__ */ new Map();
+				changes = attempt;
+				let open = true;
+				let failure;
+				const aggregate = (name, identity, values, options) => {
+					const model = schema.models.get(name);
+					if (!isBatched(model)) return tx.aggregate(name, identity, values, options);
+					try {
+						if (!open) throw new DatabaseTransactionError("The transaction has ended.");
+						recordAggregate(attempt, model, identity, values, options?.shardBy);
+					} catch (error) {
+						failure ??= { error };
+						throw error;
+					}
+				};
+				try {
+					const value = await fn({
+						...tx,
+						aggregate
+					});
+					if (failure) throw failure.error;
+					if (mode === "log" && attempt.size > 0) {
+						const id = `${now().toString(36).padStart(9, "0")}${holder.slice(0, 8)}${crypto.randomUUID().slice(0, 8)}`;
+						const shard = Math.floor(Math.random() * LOG_TABLES.length);
+						const merged = mergeAll(/* @__PURE__ */ new Map(), attempt.values());
+						tx.create(LOG_TABLES[shard], {
+							id,
+							changes: await encode(merged.values())
+						});
+					}
+					return value;
+				} finally {
+					open = false;
+				}
+			});
+			if (changes.size > 0) await committed(changes);
+			return result;
+		},
+		async beforeRead(name) {
+			if (!isBatched(schema.models.get(name))) return;
+			if (buffer.size > 0 || flushing !== void 0) await flushBuffer();
+			if (mode === "log") {
+				if (await hasPending().catch((error) => {
+					warn("read")(error);
+					return false;
+				})) await compact(true, GROUPS.read);
+			}
+		},
+		flush,
+		async dispose() {
+			clearTimeout(timer);
+			timer = void 0;
+			await flush();
+		}
+	};
+};
+var DatabaseQueryError = class extends Error {
+	name = "DatabaseQueryError";
+};
+var sameFields = (left, right) => left.length === right.length && left.every((field) => right.includes(field));
+var keyValue = (value, field) => {
+	if (isKeyValue(value)) return value;
+	throw new DatabaseQueryError(`${field} needs a string, number, or boolean.`);
+};
+var bound = (exclusive, inclusive, columns) => {
+	if (exclusive !== void 0 && inclusive !== void 0) throw new DatabaseQueryError(`range on ${columns[0]} sets both bounds of one side.`);
+	const value = exclusive ?? inclusive;
+	if (value === void 0) return void 0;
+	const values = Array.isArray(value) ? value : [value];
+	if (values.length === 0 || values.length > columns.length) throw new DatabaseQueryError(`range on ${columns[0]} takes 1–${columns.length} values of ${columns.join(", ")}.`);
+	return {
+		values: values.map((item, position) => keyValue(item, columns[position])),
+		inclusive: inclusive !== void 0
+	};
+};
+var createEngineReads = ({ adapter, schema, maxPageSize: requested = 500 }) => {
+	const maxPageSize = Math.min(requested, 500);
+	let count = {
+		calls: 0,
+		rows: 0
+	};
+	const returned = (rows) => {
+		const size = Array.isArray(rows) ? rows.length : rows === null ? 0 : 1;
+		count = {
+			calls: count.calls + 1,
+			rows: count.rows + size
+		};
+		return rows;
+	};
+	/** A model of `kind` by physical table name, for reads and transactions. */
+	const modelOf = (name, kind = "table") => {
+		const model = schema.models.get(name);
+		if (model?.definition.kind === kind) return model;
+		throw new DatabaseQueryError(model === void 0 ? `Unknown model ${name}.` : kind === "table" ? `${name} is an aggregate; read it with findAggregates and change it with aggregate.` : `${name} is a table; read it with findMany and change it with create, update, or delete.`);
+	};
+	const plan = ({ table }, input) => {
+		const index = table.indexes.find(({ name }) => name === input.index);
+		if (index === void 0) throw new DatabaseQueryError(`${table.name} has no index ${input.index}.`);
+		const where = input.where ?? {};
+		if (!sameFields(Object.keys(where), index.eq)) throw new DatabaseQueryError(`${table.name}.${index.name} reads need where on exactly: ${index.eq.join(", ") || "(none)"}.`);
+		const { limit, order = "asc", range } = input;
+		if (!Number.isSafeInteger(limit) || limit < 1 || limit > maxPageSize) throw new DatabaseQueryError(`limit must be 1–${maxPageSize}.`);
+		const columns = indexOrderColumns(table, index);
+		const eq = index.eq.map((field) => keyValue(where[field], `${table.name}.${field}`));
+		const scope = cursorScope([
+			table.name,
+			index.name,
+			eq,
+			order,
+			range
+		]);
+		let lower = bound(range?.gt, range?.gte, columns);
+		let upper = bound(range?.lt, range?.lte, columns);
+		if (input.cursor !== void 0) {
+			const values = decodeCursor(scope, input.cursor);
+			if (order === "asc") lower = {
+				values,
+				inclusive: false
+			};
+			else upper = {
+				values,
+				inclusive: false
+			};
+		}
+		return {
+			request: {
+				index: index.name,
+				eq,
+				order,
+				limit,
+				...lower === void 0 ? {} : { lower },
+				...upper === void 0 ? {} : { upper }
+			},
+			index,
+			scope
+		};
+	};
+	/** Reads rows by key in one batch; the results follow the keys' order. */
+	const findByKeys = async (name, lookups) => {
+		const { table } = modelOf(name, "table");
+		const keys = lookups.map((lookup) => {
+			if (!sameFields(Object.keys(lookup), table.key)) throw new DatabaseQueryError(`findByKeys on ${name} takes its key: ${table.key.join(", ")}.`);
+			return table.key.map((field) => keyValue(lookup[field], `${name}.${field}`));
+		});
+		const rows = keys.length === 0 ? [] : await adapter.get(table, keys);
+		returned(rows.filter((row) => row !== null));
+		return rows.map((row) => row ?? null);
+	};
+	return {
+		maxPageSize,
+		modelOf,
+		reads: {
+			total: () => count,
+			reset: () => {
+				count = {
+					calls: 0,
+					rows: 0
+				};
+			}
+		},
+		findByKeys,
+		async findOne(name, lookup) {
+			const { table } = modelOf(name, "table");
+			const fields = Object.keys(lookup);
+			if (sameFields(fields, table.key)) return (await findByKeys(name, [lookup]))[0];
+			const index = table.indexes.find(({ unique, eq }) => unique && sameFields(fields, eq));
+			if (index === void 0) throw new DatabaseQueryError(`findOne on ${name} needs its key or a unique field, not ${fields.join(", ")}.`);
+			const [row] = await adapter.query(table, {
+				index: index.name,
+				eq: index.eq.map((field) => keyValue(lookup[field], `${name}.${field}`)),
+				order: "asc",
+				limit: 1
+			});
+			return returned(row ?? null);
+		},
+		async findMany(name, input) {
+			const model = modelOf(name, "table");
+			const { request, index, scope } = plan(model, input);
+			const rows = returned(await adapter.query(model.table, request));
+			const last = rows.at(-1);
+			return rows.length === input.limit && last !== void 0 ? {
+				rows,
+				next: encodeCursor(scope, indexOrderTuple(model.table, index, last))
+			} : { rows };
+		},
+		async findAggregates(name, input) {
+			const model = modelOf(name, "aggregate");
+			const { table, definition } = model;
+			if (definition.kind !== "aggregate") throw new DatabaseQueryError(name);
+			const { request, index, scope } = plan(model, input);
+			const rows = await adapter.query(table, request);
+			const logicalKey = (row) => definition.key.map((column) => keyValue(row[column], column));
+			const groups = /* @__PURE__ */ new Map();
+			for (const row of rows) {
+				const key = JSON.stringify(logicalKey(row));
+				groups.set(key, [...groups.get(key) ?? [], row]);
+			}
+			const full = rows.length === input.limit;
+			const last = [...groups.values()].at(-1);
+			if (full && last !== void 0) {
+				const seen = new Set(last.map((row) => row[SHARD_COLUMN]));
+				const missing = Array.from({ length: definition.shards }, (_, shard) => shard).filter((shard) => !seen.has(shard));
+				if (missing.length > 0) {
+					const key = logicalKey(last[0]);
+					const rest = await adapter.get(table, missing.map((shard) => [...key, shard]));
+					last.push(...rest.filter((row) => row !== null));
+				}
+			}
+			const merged = [...groups.values()].map((shards) => {
+				const row = Object.fromEntries(definition.key.map((field) => [field, shards[0][field]]));
+				for (const metric of [...definition.counters, ...definition.gauges]) row[metric] = shards.reduce((sum, shard) => sum + Number(shard[metric] ?? 0), 0);
+				for (const metric of definition.distinct) row[metric] = mergeDistinct(shards.map((shard) => shard[metric]));
+				return row;
+			});
+			returned(merged);
+			if (!full || last === void 0) return { rows: merged };
+			return {
+				rows: merged,
+				next: encodeCursor(scope, indexOrderTuple(table, index, last[0]).slice(0, -1))
+			};
+		}
+	};
+};
+/** A row this attempt read changed while it ran; the attempt reruns. */
+var StaleReadError = class extends Error {};
+var idOf = (table, key) => JSON.stringify([table, key]);
+var versionOf = (row) => Number(row["_v"]);
+var isKeyed = (value) => value !== null && value !== void 0;
+var misuse = (table, message) => new DatabaseTransactionError(`${table}: ${message}`);
+var once = (table) => misuse(table, "a transaction writes one key once.");
+var hooks = globalThis.process?.getBuiltinModule?.("node:async_hooks");
+/** Where the runtime tracks async context, `db.*` inside a transaction throws. */
+var transactionScope = hooks && new hooks.AsyncLocalStorage();
+var assertOutsideTransaction = () => {
+	if (transactionScope?.getStore() !== void 0) throw new DatabaseTransactionError("Inside transaction(), read and write through its handle; db and core are not part of it.");
+};
+var createTransactions = ({ adapter, schema, reads, retry = {} }) => {
+	const { attempts = 8, baseDelayMs = 5, maxDelayMs = 250, onRetry } = retry;
+	const { modelOf } = reads;
+	/**
+	* A key-value index copy has no `_v`. A transaction guards what it reads,
+	* so it reads such a row whole, and reruns if it changed since the copy.
+	*/
+	const complete = async ({ table }, rows) => {
+		const copies = rows.filter((row) => !("_v" in row));
+		if (copies.length === 0) return [...rows];
+		const current = await adapter.get(table, copies.map((copy) => rowKey(table, copy)));
+		return rows.map((row) => {
+			const at = copies.indexOf(row);
+			if (at < 0) return row;
+			const whole = current[at];
+			if (!whole || Object.keys(row).some((column) => canonicalJson(row[column]) !== canonicalJson(whole[column]))) throw new StaleReadError();
+			return whole;
+		});
+	};
+	const attempt = async (fn) => {
+		const read = /* @__PURE__ */ new Map();
+		/** Rows of rooted ranges: their root guards them, so they need no check of their own. */
+		const ranged = /* @__PURE__ */ new Map();
+		const writes = /* @__PURE__ */ new Map();
+		/** Deleted keys, children before their parents. */
+		const deleted = [];
+		const aggregates = /* @__PURE__ */ new Map();
+		let open = true;
+		let failure;
+		/** A failed call fails the attempt even when `fn` catches it. */
+		const step = (method) => (...args) => {
+			if (!open) throw new DatabaseTransactionError("The transaction has ended.");
+			const fail = (error) => {
+				failure ??= { error };
+				throw error;
+			};
+			try {
+				const result = method(...args);
+				return result instanceof Promise ? result.catch(fail) : result;
+			} catch (error) {
+				return fail(error);
+			}
+		};
+		const remember = (model, key, row) => {
+			const id = idOf(model.table.name, key);
+			const known = read.get(id);
+			if (known !== void 0 && (known && row ? versionOf(known) !== versionOf(row) : known !== row)) throw new StaleReadError();
+			read.set(id, row);
+			return row;
+		};
+		const readRow = ({ table }, row) => {
+			const id = idOf(table.name, rowKey(table, row));
+			const known = read.get(id) ?? ranged.get(id);
+			if (known && versionOf(known) === versionOf(row)) return known;
+			throw misuse(table.name, "update and delete take a row this transaction read.");
+		};
+		const checkFields = ({ table, definition: { fields } }, values, creating) => {
+			for (const field of Object.keys(values)) if (!(field in fields) || !creating && table.key.includes(field)) throw misuse(table.name, `${field} cannot be ${creating ? "set" : "changed"}.`);
+			for (const [field, { required }] of Object.entries(fields)) if (required !== false && (creating || field in values) && !isKeyed(values[field])) throw misuse(table.name, `${field} is required.`);
+		};
+		/** Adds counter deltas to a key's pending op; an empty `by` still bumps `_v`. */
+		const bump = (model, key, by) => {
+			const id = idOf(model.table.name, key);
+			const pending = writes.get(id);
+			if (pending === void 0) writes.set(id, {
+				model,
+				key,
+				type: "increment",
+				row: { ...by }
+			});
+			else if (pending.type !== "delete") for (const [column, delta] of Object.entries(by)) pending.row[column] = Number(pending.row[column] ?? pending.read?.[column] ?? 0) + delta;
+			else if (Object.values(by).some((delta) => delta > 0)) throw new DatabaseConstraintError("not_found", model.table.name);
+		};
+		/** Moves parent counters when a reference changes and bumps every rooted parent. */
+		const touchParents = (model, before, after) => {
+			for (const { field, counter, target } of model.references) {
+				const [from, to] = [before?.[field], after?.[field]];
+				if (counter === void 0 || from === to) continue;
+				if (isKeyed(from)) bump(modelOf(target), [from], { [counter]: -1 });
+				if (isKeyed(to)) bump(modelOf(target), [to], { [counter]: 1 });
+			}
+			for (const [index, root] of model.roots) {
+				const parent = modelOf(root);
+				const { eq } = model.table.indexes.find(({ name }) => name === index);
+				for (const row of [before, after]) {
+					const key = eq.slice(0, parent.table.key.length).map((field) => row?.[field]);
+					if (row && key.every(isKeyed)) bump(parent, key, {});
+				}
+			}
+		};
+		const derive = ({ definition }, row) => {
+			if (definition.kind === "table") for (const [name, derived] of Object.entries(definition.derived)) row[name] = derived.compute(row);
+			return row;
+		};
+		/** Deletes a row after its cascaded children, or refuses a restricted delete. */
+		const remove = async (model, known) => {
+			const { table } = model;
+			const key = rowKey(table, known);
+			const id = idOf(table.name, key);
+			const pending = writes.get(id);
+			if (pending?.type === "delete") return;
+			if (pending && pending.type !== "increment") throw once(table.name);
+			writes.set(id, {
+				model,
+				key,
+				type: "delete",
+				row: {},
+				read: known
+			});
+			touchParents(model, known, null);
+			for (const reference of model.referencedBy) {
+				const { counter, field, onDelete, table: name } = reference;
+				if (counter === void 0) continue;
+				const stored = Number(known[counter] ?? 0);
+				const added = Number(pending?.row[counter] ?? 0);
+				if (added > 0) throw new DatabaseConstraintError("referenced", table.name);
+				if (stored + added <= 0) continue;
+				if (onDelete === "restrict") {
+					const [current] = await adapter.get(table, [key]);
+					if (current && versionOf(current) === versionOf(known)) throw new DatabaseConstraintError("referenced", table.name);
+					throw new StaleReadError();
+				}
+				const child = modelOf(name);
+				const index = child.table.indexes.find(({ eq }) => eq.length === 1 && eq[0] === field);
+				let cursor;
+				let seen = 0;
+				do {
+					const page = await reads.findMany(name, {
+						index: index.name,
+						where: { [field]: key[0] },
+						limit: Math.min(stored - seen, reads.maxPageSize),
+						...cursor === void 0 ? {} : { cursor }
+					});
+					for (const row of await complete(child, page.rows)) {
+						remember(child, rowKey(child.table, row), row);
+						await remove(child, row);
+					}
+					seen += page.rows.length;
+					cursor = page.next;
+				} while (cursor !== void 0 && seen < stored);
+			}
+			deleted.push(id);
+		};
+		const tx = {
+			findOne: step(async (name, lookup) => {
+				const model = modelOf(name);
+				const { table } = model;
+				const found = await reads.findOne(name, lookup);
+				if (found === null && !table.key.every((field) => field in lookup)) return null;
+				const [row = null] = found ? await complete(model, [found]) : [];
+				return remember(model, row ? rowKey(table, row) : table.key.map((field) => lookup[field]), row);
+			}),
+			findMany: step(async (name, input) => {
+				const model = modelOf(name);
+				const root = model.roots.get(input.index);
+				if (root === void 0) throw new DatabaseQueryError(`${name}.${input.index} is not rooted; a transaction reads a range only under a guarded parent.`);
+				const parent = modelOf(root);
+				const { eq } = model.table.indexes.find(({ name: index }) => index === input.index);
+				const where = input.where ?? {};
+				const lookup = Object.fromEntries(parent.table.key.map((field, at) => [field, where[eq[at]]]));
+				remember(parent, Object.values(lookup), await reads.findOne(root, lookup));
+				const found = await reads.findMany(name, input);
+				const rows = await complete(model, found.rows);
+				for (const row of rows) ranged.set(idOf(name, rowKey(model.table, row)), row);
+				return {
+					...found,
+					rows
+				};
+			}),
+			create: step((name, values) => {
+				const model = modelOf(name);
+				checkFields(model, values, true);
+				const defaults = model.table.columns.flatMap((column) => column.nullable || column.default !== void 0 ? [[column.name, column.default ?? null]] : []);
+				const row = derive(model, {
+					...Object.fromEntries(defaults),
+					...values
+				});
+				const key = rowKey(model.table, row);
+				const id = idOf(name, key);
+				const pending = writes.get(id);
+				if (pending && pending.type !== "increment") throw once(name);
+				for (const [column, delta] of Object.entries(pending?.row ?? {})) row[column] = Number(row[column]) + Number(delta);
+				writes.set(id, {
+					model,
+					key,
+					type: "insert",
+					row
+				});
+				touchParents(model, null, row);
+			}),
+			update: step((name, row, set) => {
+				const model = modelOf(name);
+				const known = readRow(model, row);
+				checkFields(model, set, false);
+				const key = rowKey(model.table, known);
+				const id = idOf(name, key);
+				const pending = writes.get(id);
+				if (pending?.type === "insert" || pending?.type === "delete") throw once(name);
+				const before = pending?.type === "patch" ? {
+					...known,
+					...pending.row
+				} : known;
+				const next = derive(model, {
+					...before,
+					...set
+				});
+				const changed = Object.entries(next).filter(([column, value]) => column !== "_v" && JSON.stringify(value) !== JSON.stringify(known[column]));
+				const patch = Object.fromEntries(changed);
+				writes.set(id, {
+					model,
+					key,
+					type: "patch",
+					row: patch,
+					read: known
+				});
+				if (pending?.type === "increment") bump(model, key, pending.row);
+				touchParents(model, before, next);
+			}),
+			delete: step(async (name, row) => {
+				const model = modelOf(name);
+				await remove(model, readRow(model, row));
+			}),
+			aggregate: step((name, identity, values, options) => {
+				recordAggregate(aggregates, modelOf(name, "aggregate"), identity, values, options?.shardBy);
+			})
+		};
+		try {
+			const result = await (transactionScope ? transactionScope.run(tx, () => fn(tx)) : fn(tx));
+			if (failure) throw failure.error;
+			return {
+				result,
+				read,
+				ops: compile(writes, read, deleted),
+				aggregates: [...aggregates.values()]
+			};
+		} catch (error) {
+			throw failure?.error instanceof StaleReadError ? failure.error : error;
+		} finally {
+			open = false;
+		}
+	};
+	/** Inserts first, then patches and increments, then checks, then deletes, children before parents. */
+	const compile = (writes, read, deleted) => {
+		const toOp = (id) => {
+			const { model, key, type, row, read: previous } = writes.get(id);
+			const { table } = model;
+			if (type === "insert") return {
+				type,
+				table,
+				row
+			};
+			if (type === "increment") {
+				const known = read.get(id);
+				const by = row;
+				return known ? {
+					type,
+					table,
+					key,
+					by,
+					guard: { v: versionOf(known) }
+				} : {
+					type,
+					table,
+					key,
+					by
+				};
+			}
+			const guard = { v: versionOf(previous) };
+			return type === "patch" ? {
+				type,
+				table,
+				key,
+				set: row,
+				guard,
+				previous
+			} : {
+				type,
+				table,
+				key,
+				guard,
+				previous
+			};
+		};
+		const checks = [...read].flatMap(([id, row]) => {
+			if (row === null || writes.has(id)) return [];
+			const { table } = schema.models.get(JSON.parse(id)[0]);
+			const guard = { v: versionOf(row) };
+			return [{
+				type: "check",
+				table,
+				key: rowKey(table, row),
+				guard
+			}];
+		});
+		const ofType = (...types) => [...writes.keys()].filter((id) => types.includes(writes.get(id).type));
+		return [
+			...[...ofType("insert"), ...ofType("patch", "increment")].map(toOp),
+			...checks,
+			...deleted.map(toOp)
+		];
+	};
+	/** Only a constraint the current state confirms is reported; anything else reruns. */
+	const classify = async (op, read) => {
+		if (op.type === "check" || op.type === "delete") return void 0;
+		if (op.type === "increment" && op.guard) return void 0;
+		const { table } = op;
+		const key = op.type === "insert" ? rowKey(table, op.row) : op.key;
+		const [current] = await adapter.get(table, [key]);
+		if (op.type === "increment") return current ? void 0 : "not_found";
+		if (op.type === "insert" && current) {
+			const known = read.get(idOf(table.name, key));
+			return known === null || known !== void 0 && versionOf(known) !== versionOf(current) ? void 0 : "exists";
+		}
+		if (op.type === "patch" && current?.["_v"] !== op.guard.v) return;
+		const row = op.type === "insert" ? op.row : {
+			...current,
+			...op.set
+		};
+		for (const index of table.indexes) {
+			if (!index.unique) continue;
+			for (const eq of indexEntries(table, index, row)) if ((await adapter.query(table, {
+				index: index.name,
+				eq,
+				order: "asc",
+				limit: 2
+			})).some((other) => compareTuples(rowKey(table, other), key))) return "unique";
+		}
+	};
+	return { async transaction(fn) {
+		assertOutsideTransaction();
+		let run;
+		let negative;
+		for (let round = 0; round < attempts; round += 1) {
+			const delay = round && Math.min(maxDelayMs, baseDelayMs * 2 ** (round - 1));
+			if (delay > 0) await new Promise((resolve) => setTimeout(resolve, delay / 2 + Math.random() * (delay / 2)));
+			run ??= await attempt(fn).catch((error) => {
+				if (error instanceof StaleReadError) return void 0;
+				throw error;
+			});
+			if (run === void 0) {
+				onRetry?.("rerun", round + 1);
+				continue;
+			}
+			let aggregates;
+			try {
+				aggregates = await compileAggregates(adapter, run.aggregates);
+			} catch (error) {
+				if (!(error instanceof NegativeGaugeError)) throw error;
+				negative = error;
+				onRetry?.("rerun", round + 1);
+				run = void 0;
+				continue;
+			}
+			const ops = [...run.ops, ...aggregates];
+			if (ops.length <= 1 && ops.every(({ type }) => type === "check")) return run.result;
+			if (!adapter.fits(ops)) throw new DatabaseConstraintError("too_large", ops[0].table.name);
+			let outcome;
+			try {
+				outcome = await adapter.write(ops);
+			} catch (cause) {
+				throw new DatabaseAmbiguousCommitError("The commit outcome is unknown.", { cause });
+			}
+			if (outcome.ok) return run.result;
+			const failed = "failedOp" in outcome ? outcome.failedOp : void 0;
+			if (failed === void 0 || failed >= run.ops.length) {
+				onRetry?.("resend", round + 1);
+				continue;
+			}
+			const reason = await classify(ops[failed], run.read);
+			if (reason) throw new DatabaseConstraintError(reason, ops[failed].table.name);
+			onRetry?.("rerun", round + 1);
+			run = void 0;
+		}
+		throw negative ?? new DatabaseConflictError(`The transaction conflicted ${attempts} times.`);
+	} };
+};
+/** Storage semantics over one adapter, addressed by physical table name. */
+var createEngine = ({ adapter: given, schema, maxPageSize, verify, retry }) => {
+	const verified = verify ? verifyAdapter(given) : void 0;
+	const adapter = verified ?? given;
+	const reads = createEngineReads({
+		adapter,
+		schema,
+		maxPageSize
+	});
+	const { transaction } = createTransactions({
+		adapter,
+		schema,
+		reads,
+		retry
+	});
+	return {
+		reads,
+		transaction,
+		async measureReads(read) {
+			if (verified === void 0) throw new Error("measureReads needs an engine created with verify: true.");
+			verified.reads.reset();
+			reads.reads.reset();
+			return {
+				result: await read(),
+				adapter: verified.reads.total(),
+				engine: reads.reads.total()
+			};
+		}
+	};
+};
+/** The engine plus `database(module)`, which hands a module its typed handle. */
+var createDatabaseEngine = ({ batching, now = Date.now, ...options }) => {
+	const engine = createEngine(options);
+	const { reads } = engine;
+	const batches = batching && createAggregateBatches({
+		engine,
+		adapter: options.adapter,
+		schema: options.schema,
+		batching,
+		now
+	});
+	const transaction = batches?.transaction ?? engine.transaction;
+	const outside = (read) => (...args) => {
+		assertOutsideTransaction();
+		return read(...args);
+	};
+	/** No read outside a transaction returns `_v`, which a key-value index copy lacks. */
+	const bare = (row) => row && Object.fromEntries(Object.entries(row).filter(([column]) => column !== "_v"));
+	const barePage = async (page) => {
+		const { rows, next } = await page;
+		return {
+			rows: rows.map(bare),
+			...next === void 0 ? {} : { next }
+		};
+	};
+	return {
+		...engine,
+		flush: async () => {
+			await batches?.flush();
+		},
+		dispose: async () => {
+			await batches?.dispose();
+		},
+		database(module) {
+			const name = (model) => module.namespace ? `${module.namespace}_${model}` : model;
+			return {
+				findOne: outside(async (model, lookup) => bare(await reads.findOne(name(model), lookup))),
+				findByKeys: outside(async (model, keys) => (await reads.findByKeys(name(model), keys)).map(bare)),
+				findMany: outside((model, input) => barePage(reads.findMany(name(model), input))),
+				findAggregates: outside(async (model, input) => {
+					await batches?.beforeRead(name(model));
+					return await barePage(reads.findAggregates(name(model), input));
+				}),
+				transaction: (fn) => transaction((tx) => fn({
+					findOne: (model, lookup) => tx.findOne(name(model), lookup),
+					findMany: (model, input) => tx.findMany(name(model), input),
+					create: (model, row) => tx.create(name(model), row),
+					update: (model, row, set) => tx.update(name(model), row, set),
+					delete: (model, row) => tx.delete(name(model), row),
+					aggregate: (model, identity, changes, options) => tx.aggregate(name(model), identity, changes, options)
+				}))
+			};
+		}
+	};
+};
+var HBC_ASSET_PATH_RE = /\.bundle$/;
+var asByteSize = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
+var resolveUniqueHbcAssetPath = (manifest) => {
+	const candidates = Object.keys(manifest.assets).sort((left, right) => left.localeCompare(right)).filter((candidate) => HBC_ASSET_PATH_RE.test(candidate));
+	return candidates.length === 1 ? candidates[0] : null;
+};
+var isBundleManifest = (value) => {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const manifest = value;
+	if (typeof manifest.bundleId !== "string") return false;
+	if (!manifest.assets || typeof manifest.assets !== "object") return false;
+	return Object.values(manifest.assets).every((asset) => {
+		if (!asset || typeof asset !== "object" || Array.isArray(asset)) return false;
+		const manifestAsset = asset;
+		return typeof manifestAsset.fileHash === "string" && (manifestAsset.signature === void 0 || typeof manifestAsset.signature === "string");
+	});
+};
+async function fetchBundleManifest(storageUri, readStorageText) {
+	const storageText = await readStorageText(storageUri);
+	if (storageText === null) return null;
+	let payload;
+	try {
+		payload = JSON.parse(storageText);
+	} catch {
+		return null;
+	}
+	if (!isBundleManifest(payload)) return null;
+	return payload;
+}
+function resolveHbcPatchPlan({ currentBundle, targetBundle, targetManifest }) {
+	const matchingPatch = currentBundle ? getBundlePatch(targetBundle, currentBundle.id) : null;
+	const patchAssetPath = resolveUniqueHbcAssetPath(targetManifest);
+	if (!currentBundle || !matchingPatch || !patchAssetPath || !matchingPatch.patchStorageUri || !matchingPatch.patchFileHash || !matchingPatch.baseFileHash) return null;
+	return {
+		assetPath: patchAssetPath,
+		patch: {
+			baseBundleId: matchingPatch.baseBundleId,
+			baseFileHash: matchingPatch.baseFileHash,
+			byteSize: asByteSize(matchingPatch.byteSize),
+			patchFileHash: matchingPatch.patchFileHash,
+			storageUri: matchingPatch.patchStorageUri
+		}
+	};
+}
+function createManifestArtifactPlan({ assetBaseStorageUri, currentBundle, targetBundle, targetManifest }) {
+	const patchCandidate = resolveHbcPatchPlan({
+		currentBundle,
+		targetBundle,
+		targetManifest
+	});
+	return { assets: Object.entries(targetManifest.assets).map(([assetPath, asset]) => {
+		const downloadByteSize = asByteSize(asset.downloadByteSize);
+		const downloadPath = getManifestAssetDownloadPath(assetPath);
+		const isTransformedDownload = downloadPath !== assetPath;
+		const hasValidDownloadFileHash = isContentAddressedAssetFileHash(asset.downloadFileHash);
+		const file = {
+			byteSize: downloadByteSize !== null && (hasValidDownloadFileHash || !isTransformedDownload && asset.downloadFileHash === void 0) ? downloadByteSize : null,
+			storageUri: resolveManifestAssetStorageUri({
+				assetBaseStorageUri,
+				assetPath: downloadPath,
+				downloadFileHash: asset.downloadFileHash,
+				fileHash: asset.fileHash
+			})
+		};
+		if (isTransformedDownload) file.compression = "br";
+		const patch = patchCandidate?.assetPath === assetPath ? patchCandidate.patch : null;
+		return {
+			assetPath,
+			file,
+			fileHash: asset.fileHash,
+			patch
+		};
+	}) };
+}
+async function resolveAssets(plan, resolveFileUrl) {
+	const patchAsset = plan.assets.find((asset) => asset.patch !== null);
+	let resolvedPatch = null;
+	if (patchAsset?.patch) {
+		const patchUrl = await resolveFileUrl(patchAsset.patch.storageUri);
+		if (patchUrl) resolvedPatch = {
+			assetPath: patchAsset.assetPath,
+			patch: {
+				algorithm: "bsdiff",
+				baseBundleId: patchAsset.patch.baseBundleId,
+				baseFileHash: patchAsset.patch.baseFileHash,
+				patchFileHash: patchAsset.patch.patchFileHash,
+				patchUrl,
+				...patchAsset.patch.byteSize === null ? {} : { byteSize: patchAsset.patch.byteSize }
+			}
+		};
+	}
+	const entries = await Promise.all(plan.assets.map(async (asset) => {
+		let patch = resolvedPatch?.assetPath === asset.assetPath ? resolvedPatch.patch : null;
+		let fileUrl = null;
+		try {
+			fileUrl = await resolveFileUrl(asset.file.storageUri);
+		} catch (error) {
+			if (!patch) throw error;
+		}
+		if (fileUrl && patch && asset.file.byteSize !== null && asset.patch !== null && asset.patch.byteSize !== null && asset.patch.byteSize >= asset.file.byteSize) patch = null;
+		if (!fileUrl) return null;
+		const changedAsset = {
+			file: { url: fileUrl },
+			fileHash: asset.fileHash
+		};
+		if (asset.file.compression) changedAsset.file.compression = asset.file.compression;
+		if (patch) changedAsset.patch = patch;
+		return { asset: [asset.assetPath, changedAsset] };
+	}));
+	if (entries.some((entry) => entry === null)) return null;
+	const resolvedEntries = entries.filter((entry) => entry !== null);
+	return { assets: Object.fromEntries(resolvedEntries.map((entry) => entry.asset)) };
+}
+async function resolveManifestArtifacts({ currentBundle, resolveFileUrl, readStorageText, targetBundle }) {
+	const manifestStorageUri = targetBundle ? getManifestStorageUri(targetBundle) : null;
+	const manifestFileHash = targetBundle ? getManifestFileHash(targetBundle) : null;
+	const assetBaseStorageUri = targetBundle ? getAssetBaseStorageUri(targetBundle) : null;
+	if (!targetBundle || !manifestStorageUri || !manifestFileHash || !assetBaseStorageUri) return null;
+	const targetManifest = await fetchBundleManifest(manifestStorageUri, readStorageText);
+	if (!targetManifest) return null;
+	const plan = createManifestArtifactPlan({
+		assetBaseStorageUri,
+		currentBundle,
+		targetBundle,
+		targetManifest
+	});
+	const manifestUrl = await resolveFileUrl(manifestStorageUri);
+	if (!manifestUrl) return null;
+	const resolved = await resolveAssets(plan, resolveFileUrl);
+	if (!resolved) return null;
+	let archiveUrl = null;
+	const archive = targetManifest.archive;
+	if (archive && isContentAddressedAssetFileHash(archive.downloadFileHash) && (asByteSize(archive.downloadByteSize) ?? 0) > 0 && (asByteSize(archive.tarByteSize) ?? 0) > 0) try {
+		archiveUrl = await resolveFileUrl(getBundleArchiveStorageUri({
+			manifestStorageUri,
+			bundleId: targetBundle.id
+		}));
+	} catch {}
+	return {
+		artifactProtocolVersion: 1,
+		assets: resolved.assets,
+		manifestFileHash,
+		manifestUrl,
+		...archiveUrl ? { archiveUrl } : {}
+	};
+}
+var PAGE$2 = 500;
+var pick = (fields) => (row) => Object.fromEntries(fields.map((field) => [field, row[field]]));
+var toBundleRow = pick([
+	"id",
+	"platform",
+	"git_commit_hash",
+	"metadata",
+	"manifest_storage_uri",
+	"manifest_file_hash",
+	"asset_base_storage_uri"
+]);
+var toPatchRow = pick([
+	"id",
+	"bundle_id",
+	"base_bundle_id",
+	"base_file_hash",
+	"patch_file_hash",
+	"patch_storage_uri",
+	"byte_size",
+	"order_index"
+]);
+var toReleaseRow = pick([
+	"id",
+	"revision",
+	"scope_key",
+	"channel_id",
+	"platform",
+	"kind",
+	"bundle_id",
+	"strategy",
+	"target_app_version",
+	"fingerprint_hash",
+	"enabled",
+	"should_force_update",
+	"message",
+	"rollout_cohort_count",
+	"target_cohorts",
+	"operation",
+	"source_release_id",
+	"created_at_ms",
+	"updated_at_ms"
+]);
+var toCatalogRow = pick([
+	"scope_key",
+	"catalog_id",
+	"strategy",
+	"channel_id",
+	"channel_key",
+	"platform",
+	"fingerprint_hash",
+	"generation",
+	"payload",
+	"catalog_hash",
+	"byte_size",
+	"is_tombstone",
+	"updated_at_ms"
+]);
+var toChannelRow = pick(["id", "name"]);
+/** Every page of one read, in order. */
+var drain = async (read) => {
+	const rows = [];
+	let cursor;
+	do {
+		const page = await read(cursor === void 0 ? {} : { cursor });
+		rows.push(...page.rows);
+		cursor = page.next;
+	} while (cursor !== void 0);
+	return rows;
+};
+/** Core's reads, each through one declared index or key. */
+var createCoreReads = (db, storage) => {
+	/** A bundle row's patches, exactly as many as its reference counter holds. */
+	const detail = async (row) => {
+		const count = row._refs_bundle_patches_bundle_id ?? 0;
+		const patches = [];
+		let cursor;
+		while (patches.length < count) {
+			const page = await db.findMany("bundle_patches", {
+				index: "byBundle",
+				where: { bundle_id: row.id },
+				limit: Math.min(count - patches.length, PAGE$2),
+				...cursor === void 0 ? {} : { cursor }
+			});
+			patches.push(...page.rows.map(toPatchRow));
+			if (page.next === void 0) break;
+			cursor = page.next;
+		}
+		return {
+			bundle: toBundleRow(row),
+			patches,
+			childCount: row._refs_bundle_patches_base_bundle_id ?? 0
+		};
+	};
+	const after = (input) => input.after === void 0 ? {} : { range: (input.order ?? "asc") === "asc" ? { gt: input.after } : { lt: input.after } };
+	return {
+		async getReleaseCatalog(input) {
+			const scopeKey = releaseCatalogScopeKeyOf(input);
+			const row = await db.findOne("release_catalogs", { scope_key: scopeKey });
+			return projectReleaseCatalogRow(row === null ? null : toCatalogRow(row), input, scopeKey);
+		},
+		async getArtifactInfo(targetBundleId, currentBundleId, artifactProtocolVersion) {
+			const { readStorageText } = storage;
+			if (artifactProtocolVersion !== 1 || readStorageText === void 0) return null;
+			const withCurrent = currentBundleId !== NIL_UUID;
+			const [[target, current], patch] = await Promise.all([db.findByKeys("bundles", withCurrent ? [{ id: targetBundleId }, { id: currentBundleId }] : [{ id: targetBundleId }]), withCurrent ? db.findOne("bundle_patches", {
+				bundle_id: targetBundleId,
+				base_bundle_id: currentBundleId
+			}) : null]);
+			if (target === null || target === void 0) return null;
+			return resolveManifestArtifacts({
+				currentBundle: current ? rowToBundle(toBundleRow(current)) : null,
+				readStorageText,
+				resolveFileUrl: storage.resolveFileUrl,
+				targetBundle: rowToBundle(toBundleRow(target), patch === null ? [] : [toPatchRow(patch)])
+			});
+		},
+		async getBundle(id) {
+			const row = await db.findOne("bundles", { id });
+			return row === null ? null : detail(row);
+		},
+		async countBundleChildren(baseBundleIds) {
+			const ids = [...new Set(baseBundleIds)];
+			if (ids.length === 0) return {};
+			const rows = await db.findByKeys("bundles", ids.map((id) => ({ id })));
+			return Object.fromEntries(ids.map((id, position) => [id, rows[position]?._refs_bundle_patches_base_bundle_id ?? 0]));
+		},
+		async listPatchesFromBase(baseBundleId, input) {
+			return (await db.findMany("bundle_patches", {
+				index: "byBase",
+				where: { base_bundle_id: baseBundleId },
+				order: input.order ?? "asc",
+				limit: input.limit,
+				...after(input)
+			})).rows.map(toPatchRow);
+		},
+		async listBundles(input) {
+			const page = input.platform === void 0 ? await db.findMany("bundles", {
+				index: "all",
+				where: {},
+				order: input.order ?? "asc",
+				limit: input.limit,
+				...after(input)
+			}) : await db.findMany("bundles", {
+				index: "byPlatform",
+				where: { platform: input.platform },
+				order: input.order ?? "asc",
+				limit: input.limit,
+				...after(input)
+			});
+			return Promise.all(page.rows.map(detail));
+		},
+		async countBundles(platform) {
+			const { rows } = await db.findAggregates("bundle_totals", {
+				index: "byPlatform",
+				where: { platform_key: platform ?? "*" },
+				limit: 1
+			});
+			return rows[0]?.bundles ?? 0;
+		},
+		async findBaseBundleIds(candidateKey, bundleId, limit) {
+			const query = parseBaseCandidateKey(candidateKey);
+			if (query === null) return [];
+			const row = await db.findOne("release_catalogs", { scope_key: query.scopeKey });
+			return row === null ? [] : baseBundleIdsOf(toCatalogRow(row), query.range, bundleId, limit);
+		},
+		async getRelease(id) {
+			const row = await db.findOne("releases", { id });
+			return row === null ? null : toReleaseRow(row);
+		},
+		async listReleases(input) {
+			const { filter } = input;
+			const options = {
+				order: input.order ?? "asc",
+				limit: input.limit,
+				...after(input)
+			};
+			return (filter.kind === "all" ? await db.findMany("releases", {
+				index: "all",
+				where: {},
+				...options
+			}) : filter.kind === "bundle" ? await db.findMany("releases", {
+				index: "byBundle",
+				where: { bundle_id: filter.bundleId },
+				...options
+			}) : filter.kind === "scope" ? filter.enabled === void 0 ? await db.findMany("releases", {
+				index: "byScope",
+				where: { scope_key: filter.scopeKey },
+				...options
+			}) : await db.findMany("releases", {
+				index: "byScopeEnabled",
+				where: {
+					scope_key: filter.scopeKey,
+					enabled: filter.enabled
+				},
+				...options
+			}) : filter.enabled === void 0 ? await db.findMany("releases", {
+				index: "byChannelPlatform",
+				where: {
+					channel_id: filter.channelId,
+					platform: filter.platform
+				},
+				...options
+			}) : await db.findMany("releases", {
+				index: "byChannelPlatformEnabled",
+				where: {
+					channel_id: filter.channelId,
+					platform: filter.platform,
+					enabled: filter.enabled
+				},
+				...options
+			})).rows.map(toReleaseRow);
+		},
+		async latestReleaseId(scopeKey) {
+			const { rows } = await db.findMany("releases", {
+				index: "byScope",
+				where: { scope_key: scopeKey },
+				order: "desc",
+				limit: 1
+			});
+			return rows[0]?.id ?? null;
+		},
+		async getReleaseCatalogRow(scopeKey) {
+			const row = await db.findOne("release_catalogs", { scope_key: scopeKey });
+			return row === null ? null : toCatalogRow(row);
+		},
+		async listReleaseCatalogs(input) {
+			return (await db.findMany("release_catalogs", {
+				index: "all",
+				where: {},
+				order: input.order ?? "asc",
+				limit: input.limit,
+				...after(input)
+			})).rows.map(toCatalogRow);
+		},
+		async listChannels() {
+			return (await drain((page) => db.findMany("channels", {
+				index: "all",
+				where: {},
+				limit: PAGE$2,
+				...page
+			}))).map(toChannelRow);
+		},
+		async findChannelByName(name) {
+			const row = await db.findOne("channels", { name });
+			return row === null ? null : toChannelRow(row);
+		}
+	};
+};
+var PAGE$1 = 500;
+/** Moves one bundle into or out of its platform's total and the overall total. */
+var countBundle = (tx, platform, delta) => {
+	for (const key of [platform, "*"]) tx.aggregate("bundle_totals", { platform_key: key }, { bundles: delta });
+};
+var insertBundle = (tx, row) => {
+	tx.create("bundles", row);
+	countBundle(tx, row.platform, 1);
+};
+var updateBundle = (tx, current, set) => {
+	tx.update("bundles", current, set);
+	if (set.platform !== void 0 && set.platform !== current.platform) {
+		countBundle(tx, current.platform, -1);
+		countBundle(tx, set.platform, 1);
+	}
+};
+/** Deletes a bundle and, by cascade, every patch to or from it; a release on it refuses. */
+var deleteBundle = async (tx, current) => {
+	await tx.delete("bundles", current);
+	countBundle(tx, current.platform, -1);
+};
+/**
+* Replaces a bundle's patches with `rows`: kept patches are updated where
+* they changed, others deleted or created, so no key is written twice.
+*/
+var replaceBundlePatches = async (tx, bundle, rows) => {
+	const wanted = new Map(rows.map((row) => [row.id, row]));
+	const count = bundle._refs_bundle_patches_bundle_id ?? 0;
+	let cursor;
+	for (let seen = 0; seen < count;) {
+		const page = await tx.findMany("bundle_patches", {
+			index: "byBundle",
+			where: { bundle_id: bundle.id },
+			limit: Math.min(count - seen, PAGE$1),
+			...cursor === void 0 ? {} : { cursor }
+		});
+		for (const stored of page.rows) {
+			const next = wanted.get(stored.id);
+			wanted.delete(stored.id);
+			if (next === void 0) {
+				await tx.delete("bundle_patches", stored);
+				continue;
+			}
+			const set = Object.fromEntries(Object.entries(next).filter(([field, value]) => field !== "id" && stored[field] !== value));
+			if (Object.keys(set).length > 0) tx.update("bundle_patches", stored, set);
+		}
+		seen += page.rows.length;
+		if (page.next === void 0) break;
+		cursor = page.next;
+	}
+	for (const row of wanted.values()) tx.create("bundle_patches", row);
+};
+/** A channel by name, created when missing; a concurrent creator's row is returned instead. */
+var insertChannel = async (db, row) => {
+	for (let attempt = 1;; attempt += 1) try {
+		return await db.transaction(async (tx) => {
+			const existing = await tx.findOne("channels", { name: row.name });
+			if (existing !== null) return {
+				row: toChannelRow(existing),
+				inserted: false
+			};
+			tx.create("channels", row);
+			return {
+				row,
+				inserted: true
+			};
+		});
+	} catch (error) {
+		if (attempt < 3 && error instanceof DatabaseConstraintError && (error.reason === "unique" || error.reason === "exists")) continue;
+		throw error;
+	}
+};
+/** Deletes a channel no release uses: 1 read + 1 write. */
+var deleteChannel = (db, id) => db.transaction(async (tx) => {
+	const row = await tx.findOne("channels", { id });
+	if (row === null) return {
+		deleted: false,
+		reason: "not_found"
+	};
+	if ((row._refs_releases_channel_id ?? 0) > 0) return {
+		deleted: false,
+		reason: "not_empty"
+	};
+	await tx.delete("channels", row);
+	return { deleted: true };
+});
+var PAGE = 500;
+var fail = (code, message) => {
+	throw new ReleaseCatalogMutationError(code, message);
+};
+var checkScope = (scope) => {
+	const channelKey = encodeChannelKey(scope.channelName);
+	const expected = scope.strategy === "APP_VERSION" ? createReleaseCatalogScopeKey({
+		channelKey,
+		platform: scope.platform,
+		strategy: "APP_VERSION"
+	}) : createReleaseCatalogScopeKey({
+		channelKey,
+		fingerprintHash: scope.fingerprintHash ?? "",
+		platform: scope.platform,
+		strategy: "FINGERPRINT"
+	});
+	if (scope.strategy === "FINGERPRINT" !== (scope.fingerprintHash !== null) || scope.scopeKey !== expected) fail("INVALID_SCOPE", "Release catalog scope metadata is inconsistent");
+};
+/** A scope's enabled releases, all of them, under the catalog's guard. */
+var enabledReleases = async (tx, scopeKey) => {
+	const rows = [];
+	let cursor;
+	do {
+		const page = await tx.findMany("releases", {
+			index: "byScopeEnabled",
+			where: {
+				scope_key: scopeKey,
+				enabled: true
+			},
+			limit: PAGE,
+			...cursor === void 0 ? {} : { cursor }
+		});
+		rows.push(...page.rows.map(toReleaseRow));
+		cursor = page.next;
+	} while (cursor !== void 0);
+	return rows;
+};
+/** The scope's newest release id: `byScope` descending, limit 1. */
+var latestReleaseId = async (tx, scopeKey) => {
+	const { rows } = await tx.findMany("releases", {
+		index: "byScope",
+		where: { scope_key: scopeKey },
+		order: "desc",
+		limit: 1
+	});
+	return rows[0]?.id ?? null;
+};
+/** Compiles `enabled` and writes it as the scope's next catalog generation. */
+var writeCatalog = async (tx, scope, stored, enabled, updatedAtMs) => {
+	const compilation = await compileReleaseCatalog({
+		strategy: scope.strategy,
+		releases: enabled.map(releaseRowToRelease)
+	});
+	const generation = (stored.generation ?? 0) + 1;
+	if (!Number.isSafeInteger(generation)) fail("CATALOG_GENERATION_EXHAUSTED", `Catalog "${scope.scopeKey}" exhausted its generation counter`);
+	const catalog = {
+		scope_key: scope.scopeKey,
+		catalog_id: stored.catalog?.catalog_id ?? createUUIDv7(),
+		strategy: scope.strategy,
+		channel_id: scope.channelId,
+		channel_key: encodeChannelKey(scope.channelName),
+		platform: scope.platform,
+		fingerprint_hash: scope.fingerprintHash,
+		generation,
+		payload: compilation.canonicalPayload,
+		catalog_hash: compilation.catalogHash,
+		byte_size: compilation.byteSize,
+		is_tombstone: compilation.payload.releaseDescriptors.length === 0,
+		updated_at_ms: updatedAtMs
+	};
+	const { scope_key: _scopeKey, ...set } = catalog;
+	if (stored.row === null) tx.create("release_catalogs", catalog);
+	else tx.update("release_catalogs", stored.row, set);
+	return {
+		catalog,
+		compilation
+	};
+};
+/** The scope's catalog row, and its compiled catalog and generation if it has one. */
+var readCatalog = async (tx, scopeKey) => {
+	const row = await tx.findOne("release_catalogs", { scope_key: scopeKey });
+	return {
+		row,
+		generation: row?.generation ?? null,
+		catalog: row === null ? null : toCatalogRow(row)
+	};
+};
+/** A scope with releases and no compiled catalog lost its history. */
+var assertHistory = (stored, hasReleases) => {
+	if (stored.catalog === null && hasReleases) fail("CATALOG_IDENTITY_MISSING", "Catalog history is missing. Restore its catalog row from backup before rebuilding or deploying.");
+};
+/** One release change and its scope's next catalog, inside `tx`. */
+var changeRelease = async (tx, { scope, change, bundle, updatedAtMs }) => {
+	checkScope(scope);
+	const stored = await readCatalog(tx, scope.scopeKey);
+	const enabled = await enabledReleases(tx, scope.scopeKey);
+	if (bundle !== void 0) {
+		insertBundle(tx, bundle.row);
+		for (const patch of bundle.patches) tx.create("bundle_patches", patch);
+	}
+	let before = null;
+	let release;
+	if (change.operation === "insert") {
+		const latest = await latestReleaseId(tx, scope.scopeKey);
+		assertHistory(stored, latest !== null);
+		const floor = [latest, bundle && isUUIDv7(bundle.row.id) ? bundle.row.id : null].filter((id) => id !== null).sort().at(-1);
+		const id = change.row.id ?? createUUIDv7After(floor ?? null);
+		if (latest !== null && id <= latest) fail("NON_MONOTONIC_RELEASE_ID", `Release "${id}" must sort after "${latest}"`);
+		release = {
+			...change.row,
+			id
+		};
+		if (release.scope_key !== scope.scopeKey || release.channel_id !== scope.channelId || release.platform !== scope.platform || release.strategy !== scope.strategy || release.fingerprint_hash !== scope.fingerprintHash || release.revision !== 1) fail("INVALID_SCOPE", "Inserted Release does not match its catalog scope");
+		tx.create("releases", release);
+	} else {
+		const row = await tx.findOne("releases", { id: change.id });
+		if (row === null || row.scope_key !== scope.scopeKey) return fail("RELEASE_NOT_FOUND", `Release "${change.id}" was not found in scope "${scope.scopeKey}"`);
+		assertHistory(stored, true);
+		before = toReleaseRow(row);
+		if (change.operation === "delete") {
+			await tx.delete("releases", row);
+			release = null;
+		} else {
+			const set = {
+				...change.update,
+				revision: before.revision + 1
+			};
+			tx.update("releases", row, set);
+			release = {
+				...before,
+				...set
+			};
+		}
+	}
+	const changedId = before?.id ?? release?.id;
+	const { catalog, compilation } = await writeCatalog(tx, scope, stored, [...enabled.filter(({ id }) => id !== changedId), ...release?.enabled ? [release] : []].sort((left, right) => left.id < right.id ? -1 : 1), updatedAtMs);
+	return {
+		catalog,
+		release,
+		diagnostics: compilation.diagnostics
+	};
+};
+/**
+* Release changes rooted at their catalogs: each reads its scope's catalog
+* and enabled releases, applies the change, and writes the next catalog
+* generation, all in one transaction. A concurrent change in a scope bumps
+* its catalog row, so this transaction reruns instead of publishing a stale
+* catalog.
+*/
+var changeReleases = (db, inputs) => {
+	if (new Set(inputs.map(({ scope }) => scope.scopeKey)).size !== inputs.length) fail("INVALID_SCOPE", "A batch cannot change one catalog scope twice");
+	return db.transaction(async (tx) => {
+		const results = [];
+		for (const input of inputs) results.push(await changeRelease(tx, input));
+		return results;
+	});
+};
+/** Recompiles a scope's catalog from its enabled releases inside `tx`; an unchanged catalog is not rewritten. */
+var rebuildScope = async (tx, scope, updatedAtMs) => {
+	checkScope(scope);
+	const stored = await readCatalog(tx, scope.scopeKey);
+	assertHistory(stored, await latestReleaseId(tx, scope.scopeKey) !== null);
+	const enabled = await enabledReleases(tx, scope.scopeKey);
+	const compilation = await compileReleaseCatalog({
+		strategy: scope.strategy,
+		releases: enabled.map(releaseRowToRelease)
+	});
+	const current = stored.catalog;
+	if (current !== null && current.strategy === scope.strategy && current.channel_id === scope.channelId && current.channel_key === encodeChannelKey(scope.channelName) && current.platform === scope.platform && current.fingerprint_hash === scope.fingerprintHash && current.catalog_hash === compilation.catalogHash) return {
+		catalog: current,
+		current,
+		changed: false,
+		diagnostics: compilation.diagnostics
+	};
+	const written = await writeCatalog(tx, scope, stored, enabled, updatedAtMs);
+	return {
+		catalog: written.catalog,
+		current,
+		changed: true,
+		diagnostics: written.compilation.diagnostics
+	};
+};
+/** Carries a preflight's result out of the transaction it stops, so nothing is written. */
+var Preflight = class extends Error {
+	result;
+	constructor(result) {
+		super("preflight");
+		this.result = result;
+	}
+};
+var dryRun = async (db, read) => {
+	try {
+		await db.transaction(async (tx) => {
+			throw new Preflight(await read(tx));
+		});
+	} catch (error) {
+		if (error instanceof Preflight) return error.result;
+		throw error;
+	}
+	throw new Error("A preflight transaction returned without its result.");
+};
+/** A channel's catalog scope for a platform, and a fingerprint when it has one. */
+var scopeOf = (channel, platform, fingerprintHash) => {
+	const channelKey = encodeChannelKey(channel.name);
+	return fingerprintHash === null ? {
+		channelId: channel.id,
+		channelName: channel.name,
+		fingerprintHash,
+		platform,
+		scopeKey: createReleaseCatalogScopeKey({
+			channelKey,
+			platform,
+			strategy: "APP_VERSION"
+		}),
+		strategy: "APP_VERSION"
+	} : {
+		channelId: channel.id,
+		channelName: channel.name,
+		fingerprintHash,
+		platform,
+		scopeKey: createReleaseCatalogScopeKey({
+			channelKey,
+			fingerprintHash,
+			platform,
+			strategy: "FINGERPRINT"
+		}),
+		strategy: "FINGERPRINT"
+	};
+};
+/** A release and its scope, checked against the revision the caller saw. */
+var loadTarget = async (tx, { releaseId, expectedRevision }) => {
+	const row = await tx.findOne("releases", { id: releaseId });
+	if (row === null) throw new ReleaseManagementError("RELEASE_NOT_FOUND", `Release "${releaseId}" was not found.`);
+	const release = toReleaseRow(row);
+	if (expectedRevision !== void 0 && expectedRevision !== release.revision) throw new ReleaseManagementError("VERSION_CONFLICT", `Release "${release.id}" is revision ${release.revision}; expected ${expectedRevision}.`);
+	const catalog = await tx.findOne("release_catalogs", { scope_key: release.scope_key });
+	if (catalog === null) throw new 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 policyUpdate = (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
+	};
+};
+var mutationResult = ({ catalog, release }) => ({
+	attempts: 1,
+	catalog,
+	release
+});
+/** The scope a catalog row names, for a rebuild. */
+var catalogScope = async (tx, scopeKey) => {
+	const row = await tx.findOne("release_catalogs", { scope_key: scopeKey });
+	if (row === null) throw new Error(`Release catalog "${scopeKey}" was not found.`);
+	return {
+		channelId: row.channel_id,
+		channelName: decodeChannelKey(row.channel_key),
+		fingerprintHash: row.fingerprint_hash,
+		platform: row.platform,
+		scopeKey: row.scope_key,
+		strategy: row.strategy
+	};
+};
+/**
+* Core's typed writes: each runs in one engine transaction rooted at the
+* catalogs it changes, so a concurrent change reruns it instead of
+* publishing a stale catalog.
+*/
+var createCoreOperations = (db, { now = Date.now } = {}) => {
+	const ensureChannel = async (name) => (await insertChannel(db, {
+		id: `channel:${encodeChannelKey(name)}`,
+		name
+	})).row;
+	/**
+	* Runs a write that ensured its channels first. A channel deleted between
+	* that and the write refuses the write, so it runs again and ensures it anew.
+	*/
+	const withChannels = async (write) => {
+		for (let attempt = 1;; attempt += 1) try {
+			return await write();
+		} catch (error) {
+			if (attempt < 3 && error instanceof DatabaseConstraintError && error.reason === "not_found" && error.model === "channels") continue;
+			throw error;
+		}
+	};
+	const deployOnce = async (deployments) => {
+		const channels = /* @__PURE__ */ new Map();
+		for (const { release } of deployments) if (!channels.has(release.channel)) channels.set(release.channel, await ensureChannel(release.channel));
+		const platforms = /* @__PURE__ */ new Map();
+		for (const deployment of deployments) {
+			if (!("bundleId" in deployment) || platforms.has(deployment.bundleId)) continue;
+			const row = await db.findOne("bundles", { id: deployment.bundleId });
+			if (row === null) throw new DatabaseBundleNotFoundError(deployment.bundleId);
+			platforms.set(deployment.bundleId, toBundleRow(row).platform);
+		}
+		const updatedAtMs = now();
+		return (await changeReleases(db, deployments.map((deployment) => {
+			const { release: policy } = deployment;
+			const stored = "bundleId" in deployment;
+			const bundleId = stored ? deployment.bundleId : deployment.bundle.id;
+			const platform = stored ? platforms.get(deployment.bundleId) : deployment.bundle.platform;
+			const scope = scopeOf(channels.get(policy.channel), platform, policy.fingerprintHash);
+			return {
+				scope,
+				...stored ? {} : { bundle: {
+					row: bundleToRow(deployment.bundle),
+					patches: bundleToPatchRows(deployment.bundle)
+				} },
+				change: {
+					operation: "insert",
+					row: {
+						bundle_id: bundleId,
+						channel_id: scope.channelId,
+						created_at_ms: updatedAtMs,
+						enabled: policy.enabled,
+						fingerprint_hash: policy.fingerprintHash,
+						kind: "BUNDLE",
+						message: policy.message,
+						operation: "DEPLOY",
+						platform,
+						revision: 1,
+						rollout_cohort_count: policy.rolloutCohortCount ?? 1e3,
+						scope_key: scope.scopeKey,
+						should_force_update: policy.shouldForceUpdate,
+						source_release_id: null,
+						strategy: scope.strategy,
+						target_app_version: policy.targetAppVersion,
+						target_cohorts: policy.targetCohorts ?? [],
+						updated_at_ms: updatedAtMs
+					}
+				},
+				updatedAtMs
+			};
+		}))).map(mutationResult);
+	};
+	return {
+		deploy: (deployments) => withChannels(() => deployOnce(deployments)),
+		updateReleasePolicy: (input) => {
+			const updatedAtMs = now();
+			return db.transaction(async (tx) => {
+				const { release, scope } = await loadTarget(tx, input);
+				return mutationResult(await changeRelease(tx, {
+					scope,
+					change: {
+						operation: "update",
+						id: release.id,
+						update: policyUpdate(release, input.patch, updatedAtMs)
+					},
+					updatedAtMs
+				}));
+			});
+		},
+		preflightReleasePolicy: (input) => {
+			const updatedAtMs = now();
+			return dryRun(db, async (tx) => {
+				const { release, scope } = await loadTarget(tx, input);
+				const stored = await readCatalog(tx, scope.scopeKey);
+				const changed = await changeRelease(tx, {
+					scope,
+					change: {
+						operation: "update",
+						id: release.id,
+						update: policyUpdate(release, input.patch, updatedAtMs)
+					},
+					updatedAtMs
+				});
+				return {
+					catalog: changed.catalog,
+					currentCatalog: stored.catalog,
+					diagnostics: changed.diagnostics,
+					expectedReleaseRevision: release.revision,
+					release: changed.release
+				};
+			});
+		},
+		deleteRelease: (input) => db.transaction(async (tx) => {
+			const { release, scope } = await loadTarget(tx, input);
+			if (release.enabled) throw new ReleaseManagementError("ENABLED_RELEASE", `Disable Release "${release.id}" before hard deletion.`);
+			return mutationResult(await changeRelease(tx, {
+				scope,
+				change: {
+					operation: "delete",
+					id: release.id
+				},
+				updatedAtMs: now()
+			}));
+		}),
+		promoteRelease: (input) => withChannels(async () => {
+			const checkSource = (source) => {
+				if (source.kind !== "BUNDLE" || source.bundle_id === null) throw new ReleaseManagementError("TARGET_RELEASE_INVALID", "Only a Bundle Release can be promoted.");
+			};
+			checkSource((await db.transaction((tx) => loadTarget(tx, input))).release);
+			const targetChannel = input.targetChannel.trim();
+			if (targetChannel.length === 0) throw new ReleaseManagementError("TARGET_RELEASE_INVALID", "Promotion requires a target channel.");
+			const channel = await ensureChannel(targetChannel);
+			const updatedAtMs = now();
+			return db.transaction(async (tx) => {
+				const { release: source, scope: sourceScope } = await loadTarget(tx, input);
+				checkSource(source);
+				const targetScope = scopeOf(channel, source.platform, source.fingerprint_hash);
+				if (targetScope.scopeKey === sourceScope.scopeKey) throw new ReleaseManagementError("TARGET_RELEASE_INVALID", "Source and target Release scopes are the same.");
+				const { rows } = await tx.findMany("releases", {
+					index: "byScope",
+					where: { scope_key: targetScope.scopeKey },
+					order: "desc",
+					limit: 1
+				});
+				const floor = [
+					rows[0]?.id ?? null,
+					source.id,
+					source.bundle_id
+				].filter((id) => id !== null && isUUIDv7(id)).sort().at(-1);
+				const moved = input.action === "move" ? await changeRelease(tx, {
+					scope: sourceScope,
+					change: {
+						operation: "update",
+						id: source.id,
+						update: {
+							enabled: false,
+							updated_at_ms: updatedAtMs
+						}
+					},
+					updatedAtMs
+				}) : null;
+				const target = await changeRelease(tx, {
+					scope: targetScope,
+					change: {
+						operation: "insert",
+						row: {
+							...source,
+							id: createUUIDv7After(floor ?? null, updatedAtMs),
+							revision: 1,
+							scope_key: targetScope.scopeKey,
+							channel_id: targetScope.channelId,
+							enabled: true,
+							rollout_cohort_count: 1e3,
+							target_cohorts: [],
+							operation: "PROMOTE",
+							source_release_id: source.id,
+							created_at_ms: updatedAtMs,
+							updated_at_ms: updatedAtMs
+						}
+					},
+					updatedAtMs
+				});
+				return {
+					source: moved === null ? null : mutationResult(moved),
+					target: mutationResult(target)
+				};
+			});
+		}),
+		rebuildReleaseCatalog: (scopeKey) => {
+			const updatedAtMs = now();
+			return db.transaction(async (tx) => {
+				const { current: _current, ...rebuilt } = await rebuildScope(tx, await catalogScope(tx, scopeKey), updatedAtMs);
+				return {
+					attempts: 1,
+					...rebuilt
+				};
+			});
+		},
+		preflightReleaseCatalogRebuild: (scopeKey) => {
+			const updatedAtMs = now();
+			return dryRun(db, async (tx) => {
+				const rebuilt = await rebuildScope(tx, await catalogScope(tx, scopeKey), updatedAtMs);
+				return {
+					changed: rebuilt.changed,
+					currentCatalog: rebuilt.current,
+					diagnostics: rebuilt.diagnostics,
+					projectedCatalog: rebuilt.catalog
+				};
+			});
+		},
+		ensureChannel,
+		deleteChannel: (id) => deleteChannel(db, id),
+		updateBundle: (id, update) => db.transaction(async (tx) => {
+			const current = await tx.findOne("bundles", { id });
+			if (current === null) throw new DatabaseBundleNotFoundError(id);
+			const { patches, ...fields } = update;
+			const next = {
+				...rowToBundle(toBundleRow(current)),
+				...fields,
+				id
+			};
+			const { id: _id, ...set } = bundleToRow(next);
+			updateBundle(tx, current, set);
+			if (patches !== void 0) await replaceBundlePatches(tx, current, bundleToPatchRows({
+				...next,
+				patches
+			}));
+		}),
+		deleteBundles: async (ids) => {
+			try {
+				await db.transaction(async (tx) => {
+					for (const id of new Set(ids)) {
+						const current = await tx.findOne("bundles", { id });
+						if (current !== null) await deleteBundle(tx, current);
+					}
+				});
+			} catch (error) {
+				if (error instanceof DatabaseConstraintError && error.reason === "referenced") throw new DatabaseRowReferencedError();
+				throw error;
+			}
+		}
+	};
+};
+/** A channel's id is `channel:` and its name's channel key, so ids share channel_key's bound. */
+var CHANNEL_ID = {
+	type: "string",
+	maxLength: 1408,
+	ascii: true
+};
+/** Core's module: always installed, never a plugin. */
+var coreModule = {
+	id: "core",
+	schema: {
+		bundles: defineTable({
+			id: {
+				type: "string",
+				maxLength: 36
+			},
+			platform: {
+				type: "string",
+				maxLength: 16
+			},
+			git_commit_hash: {
+				type: "string",
+				maxLength: 255,
+				required: false
+			},
+			metadata: { type: "json" },
+			manifest_storage_uri: { type: "string" },
+			manifest_file_hash: { type: "string" },
+			asset_base_storage_uri: { type: "string" }
+		}, {
+			key: ["id"],
+			indexes: {
+				byPlatform: {
+					eq: ["platform"],
+					sort: ["id"]
+				},
+				all: {
+					eq: [],
+					sort: ["id"]
+				}
+			}
+		}),
+		bundle_patches: defineTable({
+			id: {
+				type: "string",
+				maxLength: 255
+			},
+			bundle_id: {
+				type: "string",
+				maxLength: 36,
+				references: {
+					model: "bundles",
+					onDelete: "cascade"
+				}
+			},
+			base_bundle_id: {
+				type: "string",
+				maxLength: 36,
+				references: {
+					model: "bundles",
+					onDelete: "cascade"
+				}
+			},
+			base_file_hash: { type: "string" },
+			patch_file_hash: { type: "string" },
+			patch_storage_uri: { type: "string" },
+			byte_size: { type: "integer" },
+			order_index: { type: "integer" }
+		}, {
+			key: ["id"],
+			indexes: {
+				pair: {
+					eq: ["bundle_id", "base_bundle_id"],
+					sort: [],
+					unique: true
+				},
+				byBundle: {
+					eq: ["bundle_id"],
+					sort: ["order_index"],
+					root: { model: "bundles" }
+				},
+				byBase: {
+					eq: ["base_bundle_id"],
+					sort: ["bundle_id"]
+				}
+			}
+		}),
+		releases: defineTable({
+			id: {
+				type: "string",
+				maxLength: 36
+			},
+			revision: { type: "integer" },
+			scope_key: {
+				type: "string",
+				maxLength: 2048,
+				ascii: true
+			},
+			channel_id: {
+				...CHANNEL_ID,
+				references: {
+					model: "channels",
+					onDelete: "restrict"
+				}
+			},
+			platform: {
+				type: "string",
+				maxLength: 16
+			},
+			kind: {
+				type: "string",
+				maxLength: 16
+			},
+			bundle_id: {
+				type: "string",
+				maxLength: 36,
+				required: false,
+				references: {
+					model: "bundles",
+					onDelete: "restrict"
+				}
+			},
+			strategy: {
+				type: "string",
+				maxLength: 16
+			},
+			target_app_version: {
+				type: "string",
+				required: false
+			},
+			fingerprint_hash: {
+				type: "string",
+				maxLength: 255,
+				required: false
+			},
+			enabled: { type: "boolean" },
+			should_force_update: { type: "boolean" },
+			message: {
+				type: "string",
+				required: false
+			},
+			rollout_cohort_count: { type: "integer" },
+			target_cohorts: { type: "json" },
+			operation: {
+				type: "string",
+				maxLength: 16
+			},
+			source_release_id: {
+				type: "string",
+				maxLength: 36,
+				required: false,
+				references: {
+					model: "releases",
+					onDelete: "none"
+				}
+			},
+			created_at_ms: { type: "integer" },
+			updated_at_ms: { type: "integer" }
+		}, {
+			key: ["id"],
+			indexes: {
+				byScope: {
+					eq: ["scope_key"],
+					sort: ["id"],
+					root: { model: "release_catalogs" }
+				},
+				byScopeEnabled: {
+					eq: ["scope_key", "enabled"],
+					sort: ["id"],
+					root: { model: "release_catalogs" }
+				},
+				byChannelPlatform: {
+					eq: ["channel_id", "platform"],
+					sort: ["id"]
+				},
+				byChannelPlatformEnabled: {
+					eq: [
+						"channel_id",
+						"platform",
+						"enabled"
+					],
+					sort: ["id"]
+				},
+				byBundle: {
+					eq: ["bundle_id"],
+					sort: ["id"]
+				},
+				all: {
+					eq: [],
+					sort: ["id"]
+				}
+			}
+		}),
+		release_catalogs: defineTable({
+			scope_key: {
+				type: "string",
+				maxLength: 2048,
+				ascii: true
+			},
+			catalog_id: {
+				type: "string",
+				maxLength: 255
+			},
+			strategy: {
+				type: "string",
+				maxLength: 16
+			},
+			channel_id: {
+				...CHANNEL_ID,
+				references: {
+					model: "channels",
+					onDelete: "none"
+				}
+			},
+			channel_key: {
+				type: "string",
+				maxLength: 1400,
+				ascii: true
+			},
+			platform: {
+				type: "string",
+				maxLength: 16
+			},
+			fingerprint_hash: {
+				type: "string",
+				maxLength: 255,
+				required: false
+			},
+			generation: { type: "integer" },
+			payload: { type: "string" },
+			catalog_hash: {
+				type: "string",
+				maxLength: 71
+			},
+			byte_size: { type: "integer" },
+			is_tombstone: { type: "boolean" },
+			updated_at_ms: { type: "integer" }
+		}, {
+			key: ["scope_key"],
+			indexes: { all: {
+				eq: [],
+				sort: ["scope_key"]
+			} }
+		}),
+		channels: defineTable({
+			id: CHANNEL_ID,
+			name: {
+				type: "string",
+				maxLength: 255,
+				unique: true
+			}
+		}, {
+			key: ["id"],
+			indexes: { all: {
+				eq: [],
+				sort: ["name"]
+			} }
+		}),
+		bundle_totals: defineAggregate({ platform_key: {
+			type: "string",
+			maxLength: 16
+		} }, {
+			key: ["platform_key"],
+			counters: ["bundles"],
+			indexes: { byPlatform: {
+				eq: ["platform_key"],
+				sort: []
+			} }
+		})
+	}
+};
+/**
+* The update check answers from one Release Catalog row, so a transaction
+* changes what the cacheable client routes answer only when it writes one.
+* The purge runs once, after the attempt that commits.
+*/
+var purgingCachedRoutes = (db, onCachedRoutesChange) => {
+	if (onCachedRoutesChange === void 0) return db;
+	return {
+		...db,
+		async transaction(fn) {
+			let changed = false;
+			const result = await db.transaction((tx) => {
+				changed = false;
+				return fn({
+					...tx,
+					create: (model, row) => {
+						changed ||= model === "release_catalogs";
+						tx.create(model, row);
+					},
+					update: (model, row, set) => {
+						changed ||= model === "release_catalogs";
+						tx.update(model, row, set);
+					},
+					delete: (model, row) => {
+						changed ||= model === "release_catalogs";
+						return tx.delete(model, row);
+					}
+				});
+			});
+			if (changed) await onCachedRoutesChange();
+			return result;
+		}
+	};
+};
+/** Core's reads and typed writes over one database handle. */
+var createCoreApi = (db, storage, options = {}) => {
+	const reads = createCoreReads(db, storage);
+	return {
+		...reads,
+		...createCoreOperations(purgingCachedRoutes(db, options.onCachedRoutesChange), options),
+		ready: async () => {
+			await reads.listReleaseCatalogs({ limit: 1 });
+		}
+	};
+};
+/**
+* Core's API in process, on a database's storage adapter: how the CLI reads
+* and writes a database that runs on the storage engine.
+*/
+var createInProcessCoreApi = (adapter, options = {}) => createCoreApi(createDatabaseEngine({
+	adapter,
+	schema: resolveSchema([coreModule])
+}).database(coreModule), { resolveFileUrl: async () => null }, options);
+var isRecord = (value) => typeof value === "object" && value !== null;
+var isAdapter = (value) => isRecord(value) && [
+	"fits",
+	"get",
+	"query",
+	"write"
+].every((method) => typeof value[method] === "function");
+/** The storage adapter a configured database runs on, if it is on the engine. */
+var engineAdapterOf = (database) => isRecord(database) && isAdapter(database.adapter) ? database.adapter : isAdapter(database) ? database : void 0;
+var OFF_ENGINE_DATABASE = "This database does not run on Hot Updater's storage engine. Upgrade its provider package to 1.0.";
+/**
+* Core's API for a configured database, as the CLI uses it: a self-hosted
+* server's admin API when the database is `standaloneRepository`, or the
+* database's own storage adapter, in process.
+*/
+var createDatabaseCoreApi = (database, options = {}) => {
+	if (isRecord(database) && isRecord(database.core)) return database.core;
+	const adapter = engineAdapterOf(database);
+	if (adapter === void 0) throw new Error(OFF_ENGINE_DATABASE);
+	const engineDatabase = database;
+	return createInProcessCoreApi(adapter, {
+		...options,
+		...typeof engineDatabase.onCachedRoutesChange === "function" ? { onCachedRoutesChange: () => engineDatabase.onCachedRoutesChange() } : {}
+	});
+};
+//#endregion
+export { createCoreReads as a, engineAdapterOf as c, validateSchema as d, createCoreApi as i, pruneDuringWrites as l, aggregateBatchingModule as n, createDatabaseCoreApi as o, coreModule as r, createDatabaseEngine as s, OFF_ENGINE_DATABASE as t, resolveSchema as u };