@hot-updater/plugin-core 0.32.0 → 0.33.1

package/dist/createBlobDatabasePlugin.mjs

@@ -1,12 +1,29 @@
-import { calculatePagination } from "./calculatePagination.mjs";
+import { bundleMatchesQueryWhere, sortBundles } from "./queryBundles.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 { resolveUpdateInfoFromBundles } from "./resolveUpdateInfoFromBundles.mjs";
 import { orderBy } from "es-toolkit";
 import semver from "semver";
 //#region src/createBlobDatabasePlugin.ts
+const STORAGE_OPERATION_CONCURRENCY = 8;
+async function mapWithConcurrency(items, concurrency, mapper) {
+	const results = [];
+	let nextIndex = 0;
+	const workerCount = Math.min(concurrency, items.length);
+	await Promise.all(Array.from({ length: workerCount }, async () => {
+		while (true) {
+			const index = nextIndex;
+			nextIndex += 1;
+			if (index >= items.length) break;
+			results[index] = await mapper(items[index], index);
+		}
+	}));
+	return results;
+}
+async function forEachWithConcurrency(items, concurrency, mapper) {
+	await mapWithConcurrency(items, concurrency, mapper);
+}
 function removeBundleInternalKeys(bundle) {
 	const { _updateJsonKey, _oldUpdateJsonKey, ...pureBundle } = bundle;
 	return pureBundle;
@@ -47,134 +64,43 @@ 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 targetVersionMutationKey(bundle) {
+	return `${bundle.channel}/${bundle.platform}`;
 }
-function getSupportedManagementScope(where, orderBy) {
-	if (!isDefaultManagementOrder(orderBy) || hasUnsupportedManagementFilters(where)) return null;
-	return {
-		channel: where?.channel,
-		platform: where?.platform
+function getTargetVersionMutation(mutations, bundle) {
+	const key = targetVersionMutationKey(bundle);
+	const existingMutation = mutations.get(key);
+	if (existingMutation) return existingMutation;
+	const mutation = {
+		additions: /* @__PURE__ */ new Set(),
+		channel: bundle.channel,
+		platform: bundle.platform,
+		removals: /* @__PURE__ */ new Set()
 	};
+	mutations.set(key, mutation);
+	return mutation;
 }
-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 addTargetVersionAddition(mutations, bundle) {
+	const targetAppVersion = normalizeTargetAppVersion(bundle.targetAppVersion);
+	if (targetAppVersion == null) return;
+	getTargetVersionMutation(mutations, bundle).additions.add(targetAppVersion);
 }
-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 addTargetVersionRemoval(mutations, bundle) {
+	const targetAppVersion = normalizeTargetAppVersion(bundle.targetAppVersion);
+	if (targetAppVersion == null) return;
+	getTargetVersionMutation(mutations, bundle).removals.add(targetAppVersion);
 }
-function createEmptyManagementResult(limit) {
-	return {
-		data: [],
-		pagination: calculatePagination(0, {
-			limit,
-			offset: 0
-		})
-	};
+function getManagementListPrefixes(where) {
+	if (where?.channel && where.platform) return [`${where.channel}/${where.platform}/`];
+	if (where?.channel) return [`${where.channel}/`];
+	return [""];
 }
-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
-	};
+const DEFAULT_DESC_ORDER = {
+	field: "id",
+	direction: "desc"
+};
+function sortManagedBundles(bundles, orderBy = DEFAULT_DESC_ORDER) {
+	return sortBundles(bundles, orderBy);
 }
 /**
 * Creates a blob storage-based database plugin with lazy initialization.
@@ -185,339 +111,90 @@ function buildManagementIndexArtifacts(allBundles, pageSize) {
 */
 const createBlobDatabasePlugin = ({ name, factory }) => {
 	return (config, hooks) => {
-		const managementIndexPageSize = resolveManagementIndexPageSize(config);
-		const { listObjects, loadObject, uploadObject, deleteObject, invalidatePaths, apiBasePath } = factory(config);
+		const { listObjects, loadObject, uploadObject, deleteObject, shouldSkipLoadObjectError, 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);
+		const locallyDeletedBundleIds = /* @__PURE__ */ new Set();
+		const loadOptionalObject = async (key) => {
+			try {
+				return await loadObject(key);
+			} catch (error) {
+				if (shouldSkipLoadObjectError?.(error, key)) return null;
+				throw error;
 			}
-			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 loadAllBundlesForManagementFallback = async (where) => {
+			return sortManagedBundles((await reloadBundles(getManagementListPrefixes(where))).map((bundle) => removeBundleInternalKeys(bundle)));
 		};
-		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
+		const cacheBundlesFromObject = (key, bundles) => {
+			for (const bundle of bundles) {
+				if (locallyDeletedBundleIds.has(bundle.id) || pendingBundlesMap.has(bundle.id)) continue;
+				bundlesMap.set(bundle.id, {
+					...bundle,
+					_updateJsonKey: key
 				});
-				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() {
+		const loadBundleObject = async (key) => {
+			const bundles = await loadOptionalObject(key) ?? [];
+			cacheBundlesFromObject(key, bundles);
+			return bundles;
+		};
+		async function reloadBundles(prefixes = [""]) {
 			bundlesMap.clear();
-			const filePromises = (await listObjects("")).filter((key) => /^[^/]+\/(?:ios|android)\/[^/]+\/update\.json$/.test(key)).map(async (key) => {
-				return (await loadObject(key) ?? []).map((bundle) => ({
+			pendingBundlesMap.clear();
+			locallyDeletedBundleIds.clear();
+			const allBundles = (await mapWithConcurrency((await mapWithConcurrency(prefixes, STORAGE_OPERATION_CONCURRENCY, (prefix) => listObjects(prefix))).flat().filter((key) => /^[^/]+\/(?:ios|android)\/[^/]+\/update\.json$/.test(key)), STORAGE_OPERATION_CONCURRENCY, async (key) => {
+				return (await loadBundleObject(key)).map((bundle) => ({
 					...bundle,
 					_updateJsonKey: key
 				}));
-			});
-			const allBundles = (await Promise.all(filePromises)).flat();
+			})).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"]);
+			return orderBy(Array.from(bundlesMap.values()), [(v) => v.id], ["desc"]);
 		}
-		/**
-		* Updates target-app-versions.json for each channel on the given platform.
-		* Returns true if the file was updated, false if no changes were made.
-		*/
-		async function updateTargetVersionsForPlatform(platform) {
-			const updateJsonPattern = new RegExp(`^[^/]+/${platform}/[^/]+/update\\.json$`);
-			const targetVersionsPattern = new RegExp(`^[^/]+/${platform}/target-app-versions\\.json$`);
-			const allKeys = await listObjects("");
-			const updateJsonKeys = allKeys.filter((key) => updateJsonPattern.test(key));
-			const targetVersionsKeys = allKeys.filter((key) => targetVersionsPattern.test(key));
-			const keysByChannel = updateJsonKeys.reduce((acc, key) => {
-				const channel = key.split("/")[0];
-				acc[channel] = acc[channel] || [];
-				acc[channel].push(key);
-				return acc;
-			}, {});
-			for (const key of targetVersionsKeys) {
-				const channel = key.split("/")[0];
-				if (!keysByChannel[channel]) keysByChannel[channel] = [];
-			}
-			for (const channel of Object.keys(keysByChannel)) {
-				const updateKeys = keysByChannel[channel];
+		async function applyTargetVersionMutations(mutations) {
+			await Promise.all(Array.from(mutations.values()).map(async ({ additions, channel, platform, removals }) => {
 				const targetKey = `${channel}/${platform}/target-app-versions.json`;
-				const currentVersions = updateKeys.map((key) => key.split("/")[2]);
-				const oldTargetVersions = await loadObject(targetKey) ?? [];
-				const newTargetVersions = oldTargetVersions.filter((v) => currentVersions.includes(v));
-				for (const v of currentVersions) if (!newTargetVersions.includes(v)) newTargetVersions.push(v);
+				const oldTargetVersions = await loadOptionalObject(targetKey) ?? [];
+				const newTargetVersions = oldTargetVersions.filter((version) => !removals.has(version) || additions.has(version));
+				for (const version of additions) if (!newTargetVersions.includes(version)) newTargetVersions.push(version);
 				if (JSON.stringify(oldTargetVersions) !== JSON.stringify(newTargetVersions)) await uploadObject(targetKey, newTargetVersions);
-			}
+			}));
 		}
-		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 getAppVersionUpdateInfo = async ({ appVersion, bundleId, channel = "production", cohort, minBundleId, platform }, context) => {
+			const bundles = (await mapWithConcurrency(filterCompatibleAppVersions(await loadOptionalObject(`${channel}/${platform}/target-app-versions.json`) ?? [], appVersion), STORAGE_OPERATION_CONCURRENCY, async (targetAppVersion) => {
+				return loadBundleObject(`${channel}/${platform}/${normalizeTargetAppVersion(targetAppVersion) ?? targetAppVersion}/update.json`);
+			})).flat();
+			return resolveUpdateInfoFromBundles({
+				args: {
+					_updateStrategy: "appVersion",
+					appVersion,
+					bundleId,
+					channel,
+					cohort,
+					minBundleId,
+					platform
+				},
+				bundles,
+				context
 			});
 		};
-		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 getFingerprintUpdateInfo = async ({ bundleId, channel = "production", cohort, fingerprintHash, minBundleId, platform }, context) => {
+			const bundles = await loadBundleObject(`${channel}/${platform}/${fingerprintHash}/update.json`);
+			return resolveUpdateInfoFromBundles({
+				args: {
+					_updateStrategy: "fingerprint",
+					bundleId,
+					channel,
+					cohort,
+					fingerprintHash,
+					minBundleId,
+					platform
+				},
+				bundles,
+				context
 			});
 		};
 		const addAppVersionInvalidationPaths = (pathsToInvalidate, { platform, channel, targetAppVersion }) => {
@@ -539,48 +216,27 @@ const createBlobDatabasePlugin = ({ name, factory }) => {
 				targetAppVersion
 			});
 		};
-		return createDatabasePlugin({
+		const createPlugin = createDatabasePlugin({
 			name,
 			factory: () => ({
 				supportsCursorPagination: true,
 				async getBundleById(bundleId) {
+					if (locallyDeletedBundleIds.has(bundleId)) return null;
 					const pendingBundle = pendingBundlesMap.get(bundleId);
 					if (pendingBundle) return removeBundleInternalKeys(pendingBundle);
 					const bundle = bundlesMap.get(bundleId);
 					if (bundle) return removeBundleInternalKeys(bundle);
-					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 getUpdateInfo(args, context) {
+					if (args._updateStrategy === "appVersion") return getAppVersionUpdateInfo(args, context);
+					return getFingerprintUpdateInfo(args, context);
 				},
 				async getBundles(options) {
 					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,
-							cursor
-						});
-					}
-					let allBundles = await loadAllBundlesForManagementFallback();
+					let allBundles = await loadAllBundlesForManagementFallback(where);
 					if (where) allBundles = allBundles.filter((bundle) => bundleMatchesQueryWhere(bundle, where));
 					return paginateBundles({
 						bundles: allBundles,
@@ -591,18 +247,16 @@ const createBlobDatabasePlugin = ({ name, factory }) => {
 					});
 				},
 				async getChannels() {
-					return (await loadManagementScopeRoot({}))?.channels ?? [];
+					return [...new Set((await loadAllBundlesForManagementFallback()).map((bundle) => bundle.channel))].sort();
 				},
 				async commitBundle({ changedSets }) {
 					if (changedSets.length === 0) return;
 					const changedBundlesByKey = {};
 					const removalsByKey = {};
+					const targetVersionRemovalsByKey = {};
 					const pathsToInvalidate = /* @__PURE__ */ new Set();
-					let isTargetAppVersionChanged = false;
-					let isChannelChanged = false;
+					const targetVersionMutations = /* @__PURE__ */ new Map();
 					for (const { operation, data } of changedSets) {
-						if (data.targetAppVersion !== void 0) isTargetAppVersionChanged = true;
-						if (operation === "update" && data.channel !== void 0) isChannelChanged = true;
 						if (operation === "insert") {
 							const target = resolveStorageTarget(data);
 							const key = `${data.channel}/${data.platform}/${target}/update.json`;
@@ -610,10 +264,12 @@ const createBlobDatabasePlugin = ({ name, factory }) => {
 								...data,
 								_updateJsonKey: key
 							};
+							locallyDeletedBundleIds.delete(data.id);
 							bundlesMap.set(data.id, bundleWithKey);
 							pendingBundlesMap.set(data.id, bundleWithKey);
 							changedBundlesByKey[key] = changedBundlesByKey[key] || [];
 							changedBundlesByKey[key].push(removeBundleInternalKeys(bundleWithKey));
+							addTargetVersionAddition(targetVersionMutations, data);
 							addLookupInvalidationPaths(pathsToInvalidate, data);
 							continue;
 						}
@@ -623,9 +279,12 @@ const createBlobDatabasePlugin = ({ name, factory }) => {
 							if (!bundle) throw new Error("Bundle to delete not found");
 							bundlesMap.delete(data.id);
 							pendingBundlesMap.delete(data.id);
+							locallyDeletedBundleIds.add(data.id);
 							const key = bundle._updateJsonKey;
 							removalsByKey[key] = removalsByKey[key] || [];
 							removalsByKey[key].push(bundle.id);
+							targetVersionRemovalsByKey[key] = targetVersionRemovalsByKey[key] || [];
+							targetVersionRemovalsByKey[key].push(bundle);
 							addLookupInvalidationPaths(pathsToInvalidate, bundle);
 							continue;
 						}
@@ -642,11 +301,14 @@ const createBlobDatabasePlugin = ({ name, factory }) => {
 								const oldKey = bundle._updateJsonKey;
 								removalsByKey[oldKey] = removalsByKey[oldKey] || [];
 								removalsByKey[oldKey].push(bundle.id);
+								targetVersionRemovalsByKey[oldKey] = targetVersionRemovalsByKey[oldKey] || [];
+								targetVersionRemovalsByKey[oldKey].push(bundle);
 								changedBundlesByKey[newKey] = changedBundlesByKey[newKey] || [];
 								updatedBundle._oldUpdateJsonKey = oldKey;
 								updatedBundle._updateJsonKey = newKey;
 								bundlesMap.set(data.id, updatedBundle);
 								pendingBundlesMap.set(data.id, updatedBundle);
+								locallyDeletedBundleIds.delete(data.id);
 								changedBundlesByKey[newKey].push(removeBundleInternalKeys(updatedBundle));
 								const oldChannel = bundle.channel;
 								const nextChannel = updatedBundle.channel;
@@ -657,6 +319,7 @@ const createBlobDatabasePlugin = ({ name, factory }) => {
 										channel: nextChannel
 									});
 								}
+								addTargetVersionAddition(targetVersionMutations, updatedBundle);
 								addLookupInvalidationPaths(pathsToInvalidate, updatedBundle);
 								if (bundle.targetAppVersion && bundle.targetAppVersion !== updatedBundle.targetAppVersion) addLookupInvalidationPaths(pathsToInvalidate, bundle);
 								continue;
@@ -664,20 +327,24 @@ const createBlobDatabasePlugin = ({ name, factory }) => {
 							const currentKey = bundle._updateJsonKey;
 							bundlesMap.set(data.id, updatedBundle);
 							pendingBundlesMap.set(data.id, updatedBundle);
+							locallyDeletedBundleIds.delete(data.id);
 							changedBundlesByKey[currentKey] = changedBundlesByKey[currentKey] || [];
 							changedBundlesByKey[currentKey].push(removeBundleInternalKeys(updatedBundle));
 							addLookupInvalidationPaths(pathsToInvalidate, updatedBundle);
+							addTargetVersionAddition(targetVersionMutations, updatedBundle);
 							if (bundle.targetAppVersion && bundle.targetAppVersion !== updatedBundle.targetAppVersion) addLookupInvalidationPaths(pathsToInvalidate, bundle);
 						}
 					}
-					for (const oldKey of Object.keys(removalsByKey)) await (async () => {
-						const updatedBundles = (await loadObject(oldKey) ?? []).filter((b) => !removalsByKey[oldKey].includes(b.id));
+					await forEachWithConcurrency(Object.keys(removalsByKey), STORAGE_OPERATION_CONCURRENCY, async (oldKey) => {
+						const updatedBundles = (await loadOptionalObject(oldKey) ?? []).filter((b) => !removalsByKey[oldKey].includes(b.id));
 						updatedBundles.sort((a, b) => b.id.localeCompare(a.id));
-						if (updatedBundles.length === 0) await deleteObject(oldKey);
-						else await uploadObject(oldKey, updatedBundles);
-					})();
-					for (const key of Object.keys(changedBundlesByKey)) await (async () => {
-						const currentBundles = await loadObject(key) ?? [];
+						if (updatedBundles.length === 0) {
+							await deleteObject(oldKey);
+							for (const removedBundle of targetVersionRemovalsByKey[oldKey] ?? []) addTargetVersionRemoval(targetVersionMutations, removedBundle);
+						} else await uploadObject(oldKey, updatedBundles);
+					});
+					await forEachWithConcurrency(Object.keys(changedBundlesByKey), STORAGE_OPERATION_CONCURRENCY, async (key) => {
+						const currentBundles = await loadOptionalObject(key) ?? [];
 						const pureBundles = changedBundlesByKey[key].map((bundle) => bundle);
 						for (const changedBundle of pureBundles) {
 							const index = currentBundles.findIndex((b) => b.id === changedBundle.id);
@@ -686,22 +353,8 @@ const createBlobDatabasePlugin = ({ name, factory }) => {
 						}
 						currentBundles.sort((a, b) => b.id.localeCompare(a.id));
 						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);
+					});
+					if (targetVersionMutations.size > 0) await applyTargetVersionMutations(targetVersionMutations);
 					const encondedPaths = /* @__PURE__ */ new Set();
 					for (const path of pathsToInvalidate) encondedPaths.add(encodeURI(path));
 					await invalidatePaths(Array.from(encondedPaths));
@@ -709,6 +362,9 @@ const createBlobDatabasePlugin = ({ name, factory }) => {
 				}
 			})
 		})({}, hooks);
+		return () => {
+			return createPlugin();
+		};
 	};
 };
 //#endregion