@hot-updater/plugin-core 0.29.4 → 0.29.6

package/dist/createBlobDatabasePlugin.mjs

@@ -1,6 +1,9 @@
 import { calculatePagination } from "./calculatePagination.mjs";
 import { createDatabasePlugin } from "./createDatabasePlugin.mjs";
+import { filterCompatibleAppVersions } from "./filterCompatibleAppVersions.mjs";
 import { bundleMatchesQueryWhere, sortBundles } from "./queryBundles.mjs";
+import { paginateBundles } from "./paginateBundles.mjs";
+import { getUpdateInfo } from "@hot-updater/js";
 import { orderBy } from "es-toolkit";
 import semver from "semver";
 //#region src/createBlobDatabasePlugin.ts
@@ -44,6 +47,135 @@ function resolveStorageTarget({ targetAppVersion, fingerprintHash }) {
 	if (!target) throw new Error("target not found");
 	return target;
 }
+const DEFAULT_DESC_ORDER = {
+	field: "id",
+	direction: "desc"
+};
+const MANAGEMENT_INDEX_PREFIX = "_index";
+const MANAGEMENT_INDEX_VERSION = 1;
+const DEFAULT_MANAGEMENT_INDEX_PAGE_SIZE = 128;
+const ALL_SCOPE_CACHE_KEY = "*|*";
+function resolveManagementIndexPageSize(config) {
+	const pageSize = config.managementIndexPageSize ?? DEFAULT_MANAGEMENT_INDEX_PAGE_SIZE;
+	if (!Number.isInteger(pageSize) || pageSize < 1) throw new Error("managementIndexPageSize must be a positive integer.");
+	return pageSize;
+}
+function sortManagedBundles(bundles, orderBy = DEFAULT_DESC_ORDER) {
+	return sortBundles(bundles, orderBy);
+}
+function isDefaultManagementOrder(orderBy) {
+	return orderBy === void 0 || orderBy.field === DEFAULT_DESC_ORDER.field && orderBy.direction === DEFAULT_DESC_ORDER.direction;
+}
+function hasUnsupportedManagementFilters(where) {
+	if (!where) return false;
+	return Boolean(where.enabled !== void 0 || where.id !== void 0 || where.targetAppVersion !== void 0 || where.targetAppVersionIn !== void 0 || where.targetAppVersionNotNull !== void 0 || where.fingerprintHash !== void 0);
+}
+function getSupportedManagementScope(where, orderBy) {
+	if (!isDefaultManagementOrder(orderBy) || hasUnsupportedManagementFilters(where)) return null;
+	return {
+		channel: where?.channel,
+		platform: where?.platform
+	};
+}
+function encodeScopePart(value) {
+	return encodeURIComponent(value);
+}
+function getManagementScopeCacheKey({ channel, platform }) {
+	return `${channel ?? "*"}|${platform ?? "*"}`;
+}
+function getManagementScopePrefix({ channel, platform }) {
+	if (channel && platform) return `${MANAGEMENT_INDEX_PREFIX}/channel/${encodeScopePart(channel)}/platform/${platform}`;
+	if (channel) return `${MANAGEMENT_INDEX_PREFIX}/channel/${encodeScopePart(channel)}`;
+	if (platform) return `${MANAGEMENT_INDEX_PREFIX}/platform/${platform}`;
+	return `${MANAGEMENT_INDEX_PREFIX}/all`;
+}
+function getManagementRootKey(scope) {
+	return `${getManagementScopePrefix(scope)}/root.json`;
+}
+function getManagementPageKey(scope, pageIndex) {
+	return `${getManagementScopePrefix(scope)}/pages/${String(pageIndex).padStart(4, "0")}.json`;
+}
+function createBundleWithUpdateJsonKey(bundle) {
+	const target = resolveStorageTarget(bundle);
+	return {
+		...bundle,
+		_updateJsonKey: `${bundle.channel}/${bundle.platform}/${target}/update.json`
+	};
+}
+function getPageStartOffsets(pages) {
+	const startOffsets = [];
+	let offset = 0;
+	for (const page of pages) {
+		startOffsets.push(offset);
+		offset += page.count;
+	}
+	return startOffsets;
+}
+function createEmptyManagementResult(limit) {
+	return {
+		data: [],
+		pagination: calculatePagination(0, {
+			limit,
+			offset: 0
+		})
+	};
+}
+function buildManagementIndexArtifacts(allBundles, pageSize) {
+	const sortedAllBundles = sortManagedBundles(allBundles);
+	const pages = /* @__PURE__ */ new Map();
+	const scopes = [];
+	const channels = [...new Set(sortedAllBundles.map((bundle) => bundle.channel))].sort();
+	const addScope = (scope, scopeBundles, options) => {
+		if (!options?.includeChannels && scopeBundles.length === 0) return;
+		const pageKeys = [];
+		const pageDescriptors = [];
+		for (let pageIndex = 0; pageIndex * pageSize < scopeBundles.length; pageIndex++) {
+			const page = scopeBundles.slice(pageIndex * pageSize, (pageIndex + 1) * pageSize);
+			const key = getManagementPageKey(scope, pageIndex);
+			pages.set(key, page);
+			pageKeys.push(key);
+			pageDescriptors.push({
+				key,
+				count: page.length,
+				firstId: page[0].id,
+				lastId: page.at(-1).id
+			});
+		}
+		const root = {
+			version: MANAGEMENT_INDEX_VERSION,
+			pageSize,
+			total: scopeBundles.length,
+			pages: pageDescriptors,
+			...options?.includeChannels ? { channels } : {}
+		};
+		scopes.push({
+			cacheKey: getManagementScopeCacheKey(scope),
+			rootKey: getManagementRootKey(scope),
+			root,
+			pageKeys
+		});
+	};
+	addScope({}, sortedAllBundles, { includeChannels: true });
+	for (const channel of channels) {
+		const channelBundles = sortedAllBundles.filter((bundle) => bundle.channel === channel);
+		addScope({ channel }, channelBundles);
+		for (const platform of ["ios", "android"]) {
+			const scopedBundles = channelBundles.filter((bundle) => bundle.platform === platform);
+			addScope({
+				channel,
+				platform
+			}, scopedBundles);
+		}
+	}
+	for (const platform of ["ios", "android"]) {
+		const platformBundles = sortedAllBundles.filter((bundle) => bundle.platform === platform);
+		addScope({ platform }, platformBundles);
+	}
+	return {
+		pages,
+		scopes
+	};
+}
 /**
 * Creates a blob storage-based database plugin with lazy initialization.
 *
@@ -53,22 +185,282 @@ function resolveStorageTarget({ targetAppVersion, fingerprintHash }) {
 */
 const createBlobDatabasePlugin = ({ name, factory }) => {
 	return (config, hooks) => {
+		const managementIndexPageSize = resolveManagementIndexPageSize(config);
 		const { listObjects, loadObject, uploadObject, deleteObject, invalidatePaths, apiBasePath } = factory(config);
 		const bundlesMap = /* @__PURE__ */ new Map();
 		const pendingBundlesMap = /* @__PURE__ */ new Map();
+		const managementRootCache = /* @__PURE__ */ new Map();
 		const PLATFORMS = ["ios", "android"];
+		const getAllManagementArtifact = (artifacts) => {
+			const allArtifact = artifacts.scopes.find((scope) => scope.cacheKey === ALL_SCOPE_CACHE_KEY);
+			if (!allArtifact) throw new Error("all-bundles management index artifact not found");
+			return allArtifact;
+		};
+		const replaceManagementRootCache = (artifacts) => {
+			managementRootCache.clear();
+			for (const scope of artifacts.scopes) managementRootCache.set(scope.cacheKey, scope.root);
+		};
+		const createHydratedBundle = (bundle) => {
+			const hydratedBundle = createBundleWithUpdateJsonKey(bundle);
+			bundlesMap.set(hydratedBundle.id, hydratedBundle);
+			return hydratedBundle;
+		};
+		const loadStoredManagementRoot = async (scope) => {
+			const cacheKey = getManagementScopeCacheKey(scope);
+			const storedRoot = await loadObject(getManagementRootKey(scope));
+			if (storedRoot) {
+				managementRootCache.set(cacheKey, storedRoot);
+				return storedRoot;
+			}
+			managementRootCache.delete(cacheKey);
+			return null;
+		};
+		const loadManagementPage = async (descriptor, pageCache) => {
+			if (pageCache?.has(descriptor.key)) return pageCache.get(descriptor.key) ?? null;
+			const page = await loadObject(descriptor.key);
+			pageCache?.set(descriptor.key, page);
+			return page;
+		};
+		const loadBundleFromManagementRoot = async (root, bundleId) => {
+			const pageIndex = findPageIndexContainingId(root.pages, bundleId);
+			if (pageIndex < 0) return null;
+			const descriptor = root.pages[pageIndex];
+			const page = await loadManagementPage(descriptor);
+			if (!page) return null;
+			return page.find((item) => item.id === bundleId) ?? null;
+		};
+		const loadAllBundlesFromRoot = async (root) => {
+			const allBundles = [];
+			const pageCache = /* @__PURE__ */ new Map();
+			for (const descriptor of root.pages) {
+				const page = await loadManagementPage(descriptor, pageCache);
+				if (!page) return null;
+				allBundles.push(...page);
+			}
+			return allBundles;
+		};
+		const persistManagementIndexArtifacts = async (nextArtifacts, previousArtifacts) => {
+			for (const [key, page] of nextArtifacts.pages.entries()) await uploadObject(key, page);
+			for (const scope of nextArtifacts.scopes) await uploadObject(scope.rootKey, scope.root);
+			if (!previousArtifacts) return;
+			const nextPageKeys = new Set(nextArtifacts.pages.keys());
+			const nextRootKeys = new Set(nextArtifacts.scopes.map((scope) => scope.rootKey));
+			for (const [key] of previousArtifacts.pages.entries()) if (!nextPageKeys.has(key)) await deleteObject(key).catch(() => {});
+			for (const scope of previousArtifacts.scopes) if (!nextRootKeys.has(scope.rootKey)) await deleteObject(scope.rootKey).catch(() => {});
+		};
+		const ensureAllManagementRoot = async () => {
+			const storedAllRoot = await loadStoredManagementRoot({});
+			if (storedAllRoot && storedAllRoot.pageSize === managementIndexPageSize) return storedAllRoot;
+			const rebuiltBundles = sortManagedBundles((await reloadBundles()).map((bundle) => removeBundleInternalKeys(bundle)));
+			const nextArtifacts = buildManagementIndexArtifacts(rebuiltBundles, managementIndexPageSize);
+			await persistManagementIndexArtifacts(nextArtifacts, storedAllRoot ? buildManagementIndexArtifacts(rebuiltBundles, storedAllRoot.pageSize) : void 0);
+			replaceManagementRootCache(nextArtifacts);
+			return getAllManagementArtifact(nextArtifacts).root;
+		};
+		const loadManagementScopeRoot = async (scope) => {
+			const cacheKey = getManagementScopeCacheKey(scope);
+			if (cacheKey === ALL_SCOPE_CACHE_KEY) return ensureAllManagementRoot();
+			const storedRoot = await loadStoredManagementRoot(scope);
+			if (storedRoot) return storedRoot;
+			await ensureAllManagementRoot();
+			const storedScopedRoot = await loadStoredManagementRoot(scope);
+			if (storedScopedRoot) return storedScopedRoot;
+			managementRootCache.set(cacheKey, null);
+			return null;
+		};
+		const loadAllBundlesForManagementFallback = async () => {
+			const allRoot = await loadManagementScopeRoot({});
+			if (allRoot) {
+				const pagedBundles = await loadAllBundlesFromRoot(allRoot);
+				if (pagedBundles) return pagedBundles;
+			}
+			return sortManagedBundles((await reloadBundles()).map((bundle) => removeBundleInternalKeys(bundle)));
+		};
+		const loadCurrentBundlesForIndexRebuild = async () => {
+			return loadAllBundlesForManagementFallback();
+		};
+		const findPageIndexContainingId = (pages, id) => {
+			return pages.findIndex((page) => id.localeCompare(page.firstId) <= 0 && id.localeCompare(page.lastId) >= 0);
+		};
+		const readPagedBundles = async ({ root, limit, offset, cursor }) => {
+			if (root.total === 0 || root.pages.length === 0) return createEmptyManagementResult(limit);
+			const pageStartOffsets = getPageStartOffsets(root.pages);
+			const pageCache = /* @__PURE__ */ new Map();
+			if (offset !== void 0) {
+				const normalizedOffset = Math.max(0, offset);
+				if (normalizedOffset >= root.total) return {
+					data: [],
+					pagination: calculatePagination(root.total, {
+						limit,
+						offset: normalizedOffset
+					})
+				};
+				let pageIndex = 0;
+				for (let index = pageStartOffsets.length - 1; index >= 0; index--) if ((pageStartOffsets[index] ?? 0) <= normalizedOffset) {
+					pageIndex = index;
+					break;
+				}
+				const startInPage = normalizedOffset - (pageStartOffsets[pageIndex] ?? 0);
+				const data = [];
+				for (let currentPageIndex = pageIndex; currentPageIndex < root.pages.length && (limit <= 0 || data.length < limit); currentPageIndex++) {
+					const descriptor = root.pages[currentPageIndex];
+					const page = await loadManagementPage(descriptor, pageCache);
+					if (!page) return paginateBundles({
+						bundles: await loadAllBundlesForManagementFallback(),
+						limit,
+						offset: normalizedOffset
+					});
+					data.push(...currentPageIndex === pageIndex ? page.slice(startInPage) : page);
+				}
+				const paginatedData = limit > 0 ? data.slice(0, limit) : data;
+				return {
+					data: paginatedData,
+					pagination: {
+						...calculatePagination(root.total, {
+							limit,
+							offset: normalizedOffset
+						}),
+						...paginatedData.length > 0 && normalizedOffset + paginatedData.length < root.total ? { nextCursor: paginatedData.at(-1)?.id } : {},
+						...paginatedData.length > 0 && normalizedOffset > 0 ? { previousCursor: paginatedData[0]?.id } : {}
+					}
+				};
+			}
+			if (cursor?.after) {
+				let pageIndex = root.pages.findIndex((page) => {
+					const containsCursor = cursor.after.localeCompare(page.firstId) <= 0 && cursor.after.localeCompare(page.lastId) >= 0;
+					const wholePageEligible = cursor.after.localeCompare(page.firstId) > 0;
+					return containsCursor || wholePageEligible;
+				});
+				if (pageIndex < 0) return {
+					data: [],
+					pagination: {
+						...calculatePagination(root.total, {
+							limit,
+							offset: root.total
+						}),
+						previousCursor: cursor.after
+					}
+				};
+				const data = [];
+				let startIndex = null;
+				while (pageIndex < root.pages.length && (limit <= 0 || data.length < limit)) {
+					const descriptor = root.pages[pageIndex];
+					const page = await loadManagementPage(descriptor, pageCache);
+					if (!page) return paginateBundles({
+						bundles: await loadAllBundlesForManagementFallback(),
+						limit,
+						cursor
+					});
+					const containsCursor = cursor.after.localeCompare(descriptor.firstId) <= 0 && cursor.after.localeCompare(descriptor.lastId) >= 0;
+					let eligiblePageBundles = page;
+					if (containsCursor) {
+						const startInPage = page.findIndex((bundle) => bundle.id.localeCompare(cursor.after) < 0);
+						if (startInPage < 0) eligiblePageBundles = [];
+						else {
+							eligiblePageBundles = page.slice(startInPage);
+							startIndex ??= (pageStartOffsets[pageIndex] ?? 0) + startInPage;
+						}
+					} else if (eligiblePageBundles.length > 0) startIndex ??= pageStartOffsets[pageIndex] ?? 0;
+					data.push(...eligiblePageBundles);
+					if (limit > 0 && data.length >= limit) break;
+					pageIndex += 1;
+				}
+				const paginatedData = limit > 0 ? data.slice(0, limit) : data;
+				const resolvedStartIndex = startIndex ?? root.total;
+				return {
+					data: paginatedData,
+					pagination: {
+						...calculatePagination(root.total, {
+							limit,
+							offset: resolvedStartIndex
+						}),
+						...paginatedData.length > 0 && resolvedStartIndex + paginatedData.length < root.total ? { nextCursor: paginatedData.at(-1)?.id } : {},
+						...paginatedData.length > 0 && resolvedStartIndex > 0 ? { previousCursor: paginatedData[0]?.id } : {}
+					}
+				};
+			}
+			if (cursor?.before) {
+				let pageIndex = -1;
+				for (let index = root.pages.length - 1; index >= 0; index--) {
+					const page = root.pages[index];
+					const containsCursor = cursor.before.localeCompare(page.firstId) <= 0 && cursor.before.localeCompare(page.lastId) >= 0;
+					const wholePageEligible = cursor.before.localeCompare(page.lastId) < 0;
+					if (containsCursor || wholePageEligible) {
+						pageIndex = index;
+						break;
+					}
+				}
+				if (pageIndex < 0) return createEmptyManagementResult(limit);
+				let startIndex = null;
+				let collected = [];
+				while (pageIndex >= 0 && (limit <= 0 || collected.length < limit)) {
+					const descriptor = root.pages[pageIndex];
+					const page = await loadManagementPage(descriptor, pageCache);
+					if (!page) return paginateBundles({
+						bundles: await loadAllBundlesForManagementFallback(),
+						limit,
+						cursor
+					});
+					const eligiblePageBundles = cursor.before.localeCompare(descriptor.firstId) <= 0 && cursor.before.localeCompare(descriptor.lastId) >= 0 ? page.filter((bundle) => bundle.id.localeCompare(cursor.before) > 0) : page;
+					collected = [...eligiblePageBundles, ...collected];
+					if (eligiblePageBundles.length > 0) startIndex = pageStartOffsets[pageIndex] ?? 0;
+					if (limit > 0 && collected.length >= limit) break;
+					pageIndex -= 1;
+				}
+				if (startIndex === null || collected.length === 0) return createEmptyManagementResult(limit);
+				let paginatedData = collected;
+				if (limit > 0 && collected.length > limit) {
+					const dropCount = collected.length - limit;
+					paginatedData = collected.slice(dropCount);
+					startIndex += dropCount;
+				}
+				const pagination = calculatePagination(root.total, {
+					limit,
+					offset: startIndex
+				});
+				return {
+					data: paginatedData,
+					pagination: {
+						...pagination,
+						...paginatedData.length > 0 && startIndex + paginatedData.length < root.total ? { nextCursor: paginatedData.at(-1)?.id } : {},
+						...paginatedData.length > 0 && startIndex > 0 ? { previousCursor: paginatedData[0]?.id } : {}
+					}
+				};
+			}
+			const pageIndex = 0;
+			const startInPage = 0;
+			const data = [];
+			for (let currentPageIndex = pageIndex; currentPageIndex < root.pages.length && (limit <= 0 || data.length < limit); currentPageIndex++) {
+				const descriptor = root.pages[currentPageIndex];
+				const page = await loadManagementPage(descriptor, pageCache);
+				if (!page) return paginateBundles({
+					bundles: await loadAllBundlesForManagementFallback(),
+					limit,
+					cursor
+				});
+				data.push(...currentPageIndex === pageIndex ? page.slice(startInPage) : page);
+			}
+			const paginatedData = limit > 0 ? data.slice(0, limit) : data;
+			return {
+				data: paginatedData,
+				pagination: {
+					...calculatePagination(root.total, {
+						limit,
+						offset: 0
+					}),
+					...paginatedData.length > 0 && paginatedData.length < root.total ? { nextCursor: paginatedData.at(-1)?.id } : {}
+				}
+			};
+		};
 		async function reloadBundles() {
 			bundlesMap.clear();
-			const platformPromises = PLATFORMS.map(async (platform) => {
-				const filePromises = (await listUpdateJsonKeys(platform)).map(async (key) => {
-					return (await loadObject(key) ?? []).map((bundle) => ({
-						...bundle,
-						_updateJsonKey: key
-					}));
-				});
-				return (await Promise.all(filePromises)).flat();
+			const filePromises = (await listObjects("")).filter((key) => /^[^/]+\/(?:ios|android)\/[^/]+\/update\.json$/.test(key)).map(async (key) => {
+				return (await loadObject(key) ?? []).map((bundle) => ({
+					...bundle,
+					_updateJsonKey: key
+				}));
 			});
-			const allBundles = (await Promise.all(platformPromises)).flat();
+			const allBundles = (await Promise.all(filePromises)).flat();
 			for (const bundle of allBundles) bundlesMap.set(bundle.id, bundle);
 			for (const [id, bundle] of pendingBundlesMap.entries()) bundlesMap.set(id, bundle);
 			return orderBy(allBundles, [(v) => v.id], ["desc"]);
@@ -103,17 +495,31 @@ const createBlobDatabasePlugin = ({ name, factory }) => {
 				if (JSON.stringify(oldTargetVersions) !== JSON.stringify(newTargetVersions)) await uploadObject(targetKey, newTargetVersions);
 			}
 		}
-		/**
-		* Lists update.json keys for a given platform.
-		*
-		* - If a channel is provided, only that channel's update.json files are listed.
-		* - Otherwise, all channels for the given platform are returned.
-		*/
-		async function listUpdateJsonKeys(platform, channel) {
-			const prefix = channel ? platform ? `${channel}/${platform}/` : `${channel}/` : "";
-			const pattern = channel ? platform ? new RegExp(`^${channel}/${platform}/[^/]+/update\\.json$`) : new RegExp(`^${channel}/[^/]+/[^/]+/update\\.json$`) : platform ? new RegExp(`^[^/]+/${platform}/[^/]+/update\\.json$`) : /^[^/]+\/[^/]+\/[^/]+\/update\.json$/;
-			return listObjects(prefix).then((keys) => keys.filter((key) => pattern.test(key)));
-		}
+		const getAppVersionUpdateInfo = async ({ appVersion, bundleId, channel = "production", cohort, minBundleId, platform }) => {
+			const matchingVersions = filterCompatibleAppVersions(await loadObject(`${channel}/${platform}/target-app-versions.json`) ?? [], appVersion);
+			return getUpdateInfo((await Promise.allSettled(matchingVersions.map(async (targetAppVersion) => {
+				return await loadObject(`${channel}/${platform}/${normalizeTargetAppVersion(targetAppVersion) ?? targetAppVersion}/update.json`) ?? [];
+			}))).filter((entry) => entry.status === "fulfilled").flatMap((entry) => entry.value), {
+				_updateStrategy: "appVersion",
+				appVersion,
+				bundleId,
+				channel,
+				cohort,
+				minBundleId,
+				platform
+			});
+		};
+		const getFingerprintUpdateInfo = async ({ bundleId, channel = "production", cohort, fingerprintHash, minBundleId, platform }) => {
+			return getUpdateInfo(await loadObject(`${channel}/${platform}/${fingerprintHash}/update.json`) ?? [], {
+				_updateStrategy: "fingerprint",
+				bundleId,
+				channel,
+				cohort,
+				fingerprintHash,
+				minBundleId,
+				platform
+			});
+		};
 		const addAppVersionInvalidationPaths = (pathsToInvalidate, { platform, channel, targetAppVersion }) => {
 			if (!isExactVersion(targetAppVersion)) {
 				pathsToInvalidate.add(`${apiBasePath}/app-version/${platform}/*`);
@@ -136,37 +542,56 @@ const createBlobDatabasePlugin = ({ name, factory }) => {
 		return createDatabasePlugin({
 			name,
 			factory: () => ({
+				supportsCursorPagination: true,
 				async getBundleById(bundleId) {
 					const pendingBundle = pendingBundlesMap.get(bundleId);
 					if (pendingBundle) return removeBundleInternalKeys(pendingBundle);
 					const bundle = bundlesMap.get(bundleId);
 					if (bundle) return removeBundleInternalKeys(bundle);
-					return (await reloadBundles()).find((bundle) => bundle.id === bundleId) ?? null;
+					const allRoot = await loadManagementScopeRoot({});
+					if (allRoot) {
+						const matchedBundle = await loadBundleFromManagementRoot(allRoot, bundleId);
+						if (matchedBundle) return removeBundleInternalKeys(createHydratedBundle(matchedBundle));
+						managementRootCache.delete(ALL_SCOPE_CACHE_KEY);
+						const refreshedAllRoot = await loadStoredManagementRoot({});
+						if (refreshedAllRoot) {
+							const refreshedBundle = await loadBundleFromManagementRoot(refreshedAllRoot, bundleId);
+							if (refreshedBundle) return removeBundleInternalKeys(createHydratedBundle(refreshedBundle));
+						}
+					}
+					const matchedBundle = (await reloadBundles()).find((item) => item.id === bundleId);
+					if (!matchedBundle) return null;
+					return removeBundleInternalKeys(matchedBundle);
+				},
+				async getUpdateInfo(args) {
+					if (args._updateStrategy === "appVersion") return getAppVersionUpdateInfo(args);
+					return getFingerprintUpdateInfo(args);
 				},
 				async getBundles(options) {
-					let allBundles = await reloadBundles();
-					const { where, limit, offset, orderBy } = options;
-					if (where) allBundles = allBundles.filter((bundle) => bundleMatchesQueryWhere(bundle, where));
-					const cleanBundles = sortBundles(allBundles.map(removeBundleInternalKeys), orderBy);
-					const total = cleanBundles.length;
-					let paginatedData = cleanBundles;
-					if (offset > 0) paginatedData = paginatedData.slice(offset);
-					if (limit) paginatedData = paginatedData.slice(0, limit);
-					return {
-						data: paginatedData,
-						pagination: calculatePagination(total, {
+					const { where, limit, offset, orderBy, cursor } = options;
+					const scope = getSupportedManagementScope(where, orderBy);
+					if (scope) {
+						const root = await loadManagementScopeRoot(scope);
+						if (!root) return createEmptyManagementResult(limit);
+						return readPagedBundles({
+							root,
 							limit,
-							offset
-						})
-					};
+							offset,
+							cursor
+						});
+					}
+					let allBundles = await loadAllBundlesForManagementFallback();
+					if (where) allBundles = allBundles.filter((bundle) => bundleMatchesQueryWhere(bundle, where));
+					return paginateBundles({
+						bundles: allBundles,
+						limit,
+						offset,
+						cursor,
+						orderBy
+					});
 				},
 				async getChannels() {
-					const total = (await reloadBundles()).length;
-					const result = await this.getBundles({
-						limit: total,
-						offset: 0
-					});
-					return [...new Set(result.data.map((bundle) => bundle.channel))];
+					return (await loadManagementScopeRoot({}))?.channels ?? [];
 				},
 				async commitBundle({ changedSets }) {
 					if (changedSets.length === 0) return;
@@ -263,6 +688,20 @@ const createBlobDatabasePlugin = ({ name, factory }) => {
 						await uploadObject(key, currentBundles);
 					})();
 					if (isTargetAppVersionChanged || isChannelChanged) for (const platform of PLATFORMS) await updateTargetVersionsForPlatform(platform);
+					const currentIndexBundles = await loadCurrentBundlesForIndexRebuild();
+					const nextIndexMap = new Map(currentIndexBundles.map((bundle) => [bundle.id, bundle]));
+					for (const { operation, data } of changedSets) {
+						if (operation === "delete") {
+							nextIndexMap.delete(data.id);
+							continue;
+						}
+						nextIndexMap.set(data.id, data);
+					}
+					const nextIndexBundles = sortManagedBundles(Array.from(nextIndexMap.values()));
+					const previousArtifacts = buildManagementIndexArtifacts(currentIndexBundles, managementIndexPageSize);
+					const nextArtifacts = buildManagementIndexArtifacts(nextIndexBundles, managementIndexPageSize);
+					await persistManagementIndexArtifacts(nextArtifacts, previousArtifacts);
+					replaceManagementRootCache(nextArtifacts);
 					const encondedPaths = /* @__PURE__ */ new Set();
 					for (const path of pathsToInvalidate) encondedPaths.add(encodeURI(path));
 					await invalidatePaths(Array.from(encondedPaths));