@hot-updater/server 0.36.7 → 1.0.0-rc.0

package/dist/db/updateArtifacts.mjs

@@ -1,7 +1,20 @@
-import { getManifestAssetDownloadPath, resolveManifestAssetStorageUri } from "@hot-updater/plugin-core";
-import { getAssetBaseStorageUri, getBundlePatch, getManifestFileHash, getManifestStorageUri, stripBundleArtifactMetadata } from "@hot-updater/core";
+import { getManifestAssetDownloadPath, isContentAddressedAssetFileHash, resolveManifestAssetStorageUri } from "@hot-updater/plugin-core";
+import { getAssetBaseStorageUri, getBundlePatch, getManifestFileHash, getManifestStorageUri } from "@hot-updater/core";
 //#region src/db/updateArtifacts.ts
 const HBC_ASSET_PATH_RE = /\.bundle$/;
+const asByteSize = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
+const sumByteSizes = (byteSizes) => {
+	let total = 0;
+	for (const byteSize of byteSizes) {
+		if (byteSize === null || total > Number.MAX_SAFE_INTEGER - byteSize) return null;
+		total += byteSize;
+	}
+	return total;
+};
+const shouldUseArchive = (targetBundle, downloadByteSize) => {
+	const archiveByteSize = asByteSize(targetBundle.archiveByteSize);
+	return archiveByteSize !== null && downloadByteSize !== null && downloadByteSize >= archiveByteSize;
+};
 const 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;
@@ -17,19 +30,8 @@ const isBundleManifest = (value) => {
 		return typeof manifestAsset.fileHash === "string" && (manifestAsset.signature === void 0 || typeof manifestAsset.signature === "string");
 	});
 };
-const parseBundleMetadata = (value) => {
-	if (!value) return;
-	let parsedValue = value;
-	if (typeof parsedValue === "string") try {
-		parsedValue = JSON.parse(parsedValue);
-	} catch {
-		return;
-	}
-	if (!parsedValue || typeof parsedValue !== "object" || Array.isArray(parsedValue)) return;
-	return stripBundleArtifactMetadata(parsedValue);
-};
-async function fetchBundleManifest(storageUri, readStorageText, resolveFileUrl, context) {
-	const [storageText, fileUrl] = await Promise.all([readStorageText(storageUri, context), resolveFileUrl(storageUri, context)]);
+async function fetchBundleManifest(storageUri, readStorageText) {
+	const storageText = await readStorageText(storageUri);
 	if (storageText === null) return null;
 	let payload;
 	try {
@@ -38,88 +40,141 @@ async function fetchBundleManifest(storageUri, readStorageText, resolveFileUrl,
 		return null;
 	}
 	if (!isBundleManifest(payload)) return null;
-	if (!fileUrl) return null;
 	return {
-		fileUrl,
+		byteSize: asByteSize(new TextEncoder().encode(storageText).byteLength),
 		manifest: payload
 	};
 }
-async function resolveChangedAssets({ assetBaseStorageUri, currentManifest, currentBundle, resolveFileUrl, targetBundle, targetManifest, context }) {
-	const patchDescriptor = await resolveHbcPatchDescriptor({
+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, currentManifest, currentBundle, targetBundle, targetManifest, targetManifestByteSize }) {
+	const patchCandidate = resolveHbcPatchPlan({
 		currentBundle,
-		resolveFileUrl,
 		targetBundle,
-		targetManifest,
-		context
+		targetManifest
 	});
-	const changedEntries = await Promise.all(Object.entries(targetManifest.assets).map(async ([assetPath, asset]) => {
-		if ((currentManifest?.assets[assetPath])?.fileHash === asset.fileHash) return null;
+	const changedAssets = Object.entries(targetManifest.assets).flatMap(([assetPath, asset]) => {
+		if ((currentManifest?.assets[assetPath])?.fileHash === asset.fileHash) return [];
+		const downloadByteSize = asByteSize(asset.downloadByteSize);
 		const downloadPath = getManifestAssetDownloadPath(assetPath);
-		const usesBrotliAsset = downloadPath !== assetPath;
-		const storageUri = resolveManifestAssetStorageUri({
-			assetBaseStorageUri,
-			assetPath: downloadPath,
-			fileHash: asset.fileHash
-		});
-		const patch = patchDescriptor?.assetPath === assetPath ? patchDescriptor.patch : null;
+		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
+		}];
+	});
+	const allPossibleByteSizesKnown = targetManifestByteSize !== null && changedAssets.every((asset) => asset.file.byteSize !== null && (asset.patch === null || asset.patch.byteSize !== null));
+	const primaryByteSizes = changedAssets.map((asset) => {
+		if (!asset.patch) return asset.file.byteSize;
+		if (asset.patch.byteSize === null || asset.file.byteSize === null) return null;
+		return Math.min(asset.patch.byteSize, asset.file.byteSize);
+	});
+	return {
+		allPossibleByteSizesKnown,
+		changedAssets,
+		manifestByteSize: targetManifestByteSize,
+		minimumDownloadByteSize: allPossibleByteSizesKnown ? sumByteSizes([targetManifestByteSize, ...primaryByteSizes]) : null
+	};
+}
+async function resolveChangedAssets(plan, resolveFileUrl) {
+	const patchAsset = plan.changedAssets.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
+			}
+		};
+	}
+	const changedEntries = await Promise.all(plan.changedAssets.map(async (asset) => {
+		let patch = resolvedPatch?.assetPath === asset.assetPath ? resolvedPatch.patch : null;
 		let fileUrl = null;
 		try {
-			fileUrl = await resolveFileUrl(storageUri, context);
+			fileUrl = await resolveFileUrl(asset.file.storageUri);
 		} catch (error) {
 			if (!patch) throw error;
 		}
-		if (!fileUrl && !patch) return false;
+		if (fileUrl && patch && asset.file.byteSize !== null && asset.patch !== null && asset.patch.byteSize !== null && asset.patch.byteSize >= asset.file.byteSize) patch = null;
+		if (!fileUrl && !patch) return null;
 		const changedAsset = { fileHash: asset.fileHash };
 		if (fileUrl) {
 			changedAsset.file = { url: fileUrl };
-			if (usesBrotliAsset) changedAsset.file.compression = "br";
+			if (asset.file.compression) changedAsset.file.compression = asset.file.compression;
 		}
 		if (patch) changedAsset.patch = patch;
-		return [assetPath, changedAsset];
+		return {
+			asset: [asset.assetPath, changedAsset],
+			primaryByteSize: patch ? asset.patch?.byteSize ?? null : asset.file.byteSize
+		};
 	}));
-	if (changedEntries.some((entry) => entry === false)) return null;
-	return Object.fromEntries(changedEntries.filter((entry) => entry !== null));
-}
-async function resolveHbcPatchDescriptor({ currentBundle, resolveFileUrl, targetBundle, targetManifest, context }) {
-	const matchingPatch = targetBundle && currentBundle ? getBundlePatch(targetBundle, currentBundle.id) : null;
-	const patchAssetPath = resolveUniqueHbcAssetPath(targetManifest);
-	if (!currentBundle || !matchingPatch || !patchAssetPath || !matchingPatch.patchStorageUri || !matchingPatch.patchFileHash || !matchingPatch.baseFileHash) return null;
-	const patchUrl = await resolveFileUrl(matchingPatch.patchStorageUri, context);
-	if (!patchUrl) return null;
+	if (changedEntries.some((entry) => entry === null)) return null;
+	const resolvedEntries = changedEntries.filter((entry) => entry !== null);
 	return {
-		assetPath: patchAssetPath,
-		patch: {
-			algorithm: "bsdiff",
-			baseBundleId: matchingPatch.baseBundleId,
-			baseFileHash: matchingPatch.baseFileHash,
-			patchFileHash: matchingPatch.patchFileHash,
-			patchUrl
-		}
+		changedAssets: Object.fromEntries(resolvedEntries.map((entry) => entry.asset)),
+		primaryByteSizes: resolvedEntries.map((entry) => entry.primaryByteSize)
 	};
 }
-async function resolveManifestArtifacts({ currentBundle, resolveFileUrl, readStorageText, targetBundle, context }) {
+async function resolveManifestArtifacts({ archiveUrlUsable, currentBundle, resolveFileUrl, readStorageText, targetBundle }) {
 	const manifestStorageUri = targetBundle ? getManifestStorageUri(targetBundle) : null;
 	const manifestFileHash = targetBundle ? getManifestFileHash(targetBundle) : null;
 	const assetBaseStorageUri = targetBundle ? getAssetBaseStorageUri(targetBundle) : null;
-	if (!manifestStorageUri || !manifestFileHash || !assetBaseStorageUri) return null;
+	if (!targetBundle || !manifestStorageUri || !manifestFileHash || !assetBaseStorageUri) return null;
 	const currentManifestStorageUri = currentBundle ? getManifestStorageUri(currentBundle) : null;
-	const [targetManifestResult, currentManifestResult] = await Promise.all([fetchBundleManifest(manifestStorageUri, readStorageText, resolveFileUrl, context), currentManifestStorageUri ? fetchBundleManifest(currentManifestStorageUri, readStorageText, resolveFileUrl, context) : null]);
+	const [targetManifestResult, currentManifestResult] = await Promise.all([fetchBundleManifest(manifestStorageUri, readStorageText), currentManifestStorageUri ? fetchBundleManifest(currentManifestStorageUri, readStorageText) : null]);
 	if (!targetManifestResult) return null;
-	const changedAssets = await resolveChangedAssets({
+	const plan = createManifestArtifactPlan({
 		assetBaseStorageUri,
 		currentManifest: currentManifestResult?.manifest ?? null,
 		currentBundle,
-		resolveFileUrl,
 		targetBundle,
 		targetManifest: targetManifestResult.manifest,
-		context
+		targetManifestByteSize: targetManifestResult.byteSize
 	});
-	if (!changedAssets) return null;
+	if (archiveUrlUsable && plan.allPossibleByteSizesKnown && shouldUseArchive(targetBundle, plan.minimumDownloadByteSize)) return null;
+	const manifestUrl = await resolveFileUrl(manifestStorageUri);
+	if (!manifestUrl) return null;
+	const resolved = await resolveChangedAssets(plan, resolveFileUrl);
+	if (!resolved) return null;
+	const resolvedDownloadByteSize = sumByteSizes([plan.manifestByteSize, ...resolved.primaryByteSizes]);
+	if (archiveUrlUsable && shouldUseArchive(targetBundle, resolvedDownloadByteSize)) return null;
 	return {
-		changedAssets,
+		changedAssets: resolved.changedAssets,
 		manifestFileHash,
-		manifestUrl: targetManifestResult.fileUrl
+		manifestUrl
 	};
 }
 //#endregion
-export { parseBundleMetadata, resolveManifestArtifacts };
+export { resolveManifestArtifacts };

package/dist/handler.cjs

@@ -1,294 +1,120 @@
-require("./_virtual/_rolldown/runtime.cjs");
+const require_routes = require("./analytics/routes.cjs");
+const require_handlerErrors = require("./handlerErrors.cjs");
+const require_handlerBundleRoutes = require("./handlerBundleRoutes.cjs");
+const require_handlerReleaseCatalogRoutes = require("./handlerReleaseCatalogRoutes.cjs");
+const require_handlerReleaseManagementRoutes = require("./handlerReleaseManagementRoutes.cjs");
+const require_handlerVersionRoutes = require("./handlerVersionRoutes.cjs");
 const require_internalRouter = require("./internalRouter.cjs");
-const require_version = require("./version.cjs");
-let verkit = require("verkit");
 //#region src/handler.ts
-var HandlerBadRequestError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "HandlerBadRequestError";
-	}
-};
-const SDK_VERSION_HEADER = "Hot-Updater-SDK-Version";
-const EXPLICIT_NO_UPDATE_MIN_SDK_VERSION = "0.31.0";
-const DEFAULT_BUNDLE_LIST_LIMIT = 50;
-const MAX_BUNDLE_LIST_LIMIT = 100;
-const supportsExplicitNoUpdateResponse = (request) => {
-	const sdkVersion = request.headers.get(SDK_VERSION_HEADER)?.trim();
-	if (!sdkVersion) return false;
-	const normalizedSdkVersion = (0, verkit.normalize)(sdkVersion);
-	return normalizedSdkVersion !== null && (0, verkit.isGreaterOrEqual)(normalizedSdkVersion, EXPLICIT_NO_UPDATE_MIN_SDK_VERSION);
-};
-const serializeUpdateInfo = (updateInfo, request) => {
-	if (updateInfo) return JSON.stringify(updateInfo);
-	if (supportsExplicitNoUpdateResponse(request)) return JSON.stringify({ status: "UP_TO_DATE" });
-	return JSON.stringify(null);
-};
-const handleVersion = async () => {
-	return new Response(JSON.stringify({ version: require_version.HOT_UPDATER_SERVER_VERSION }), {
-		status: 200,
-		headers: { "Content-Type": "application/json" }
+const withPrivateNoStore = (response) => {
+	const headers = new Headers(response.headers);
+	headers.set("cache-control", "private, no-store");
+	return new Response(response.body, {
+		headers,
+		status: response.status,
+		statusText: response.statusText
 	});
 };
-const decodeMaybe = (value) => {
-	if (value === void 0) return void 0;
+const errorResponse = (error, status) => Response.json({ error }, {
+	headers: { "cache-control": "private, no-store" },
+	status
+});
+const requiresApiKey = (handlerName) => handlerName === "appVersionReleaseCatalog" || handlerName === "fingerprintReleaseCatalog" || handlerName === "artifact" || handlerName === "appendBundleEvent";
+const createRequestHandler = ({ api, apiKeyAuth, privateResponses = false, routeHandlers, router }) => async (request) => {
 	try {
-		return decodeURIComponent(value);
-	} catch {
-		return value;
+		const match = require_internalRouter.findRoute(router, request.method, new URL(request.url).pathname);
+		if (!match) return errorResponse("Not found", 404);
+		if (apiKeyAuth !== void 0 && requiresApiKey(match.data)) {
+			let authenticated;
+			try {
+				authenticated = await apiKeyAuth.authenticate(request);
+			} catch {
+				return errorResponse("Service unavailable", 503);
+			}
+			if (!authenticated) return errorResponse("Unauthorized", 401);
+		}
+		const handler = routeHandlers[match.data];
+		if (!handler) return errorResponse("Handler not found", 500);
+		const response = await handler(match.params, request, api);
+		return privateResponses ? withPrivateNoStore(response) : response;
+	} catch (error) {
+		if (error instanceof require_handlerErrors.HandlerBadRequestError) return errorResponse(error.message, 400);
+		console.error("Hot Updater handler error:", error);
+		return Response.json({ error: "Internal server error" }, {
+			headers: { "cache-control": "private, no-store" },
+			status: 500
+		});
 	}
 };
-const isPlatform = (value) => {
-	return value === "ios" || value === "android";
-};
-const requireRouteParam = (params, key) => {
-	const value = params[key];
-	if (!value) throw new HandlerBadRequestError(`Missing route parameter: ${key}`);
-	return value;
-};
-const parseBooleanSearchParam = (url, key) => {
-	const value = url.searchParams.get(key);
-	if (value === null) return;
-	if (value === "true") return true;
-	if (value === "false") return false;
-	throw new HandlerBadRequestError(`The '${key}' query parameter must be 'true' or 'false'.`);
-};
-const parseNullableStringSearchParam = (url, key) => {
-	const value = url.searchParams.get(key);
-	if (value === null) return;
-	return value === "null" ? null : value;
-};
-const parseStringArraySearchParam = (url, key) => {
-	const values = url.searchParams.getAll(key);
-	return values.length > 0 ? values : void 0;
-};
-const parsePositiveIntegerSearchParam = (url, key, defaultValue, maxValue) => {
-	const value = url.searchParams.get(key);
-	if (value === null) return defaultValue;
-	const parsed = Number(value);
-	if (!Number.isInteger(parsed) || parsed < 1 || parsed > maxValue) throw new HandlerBadRequestError(`The '${key}' query parameter must be a positive integer between 1 and ${maxValue}.`);
-	return parsed;
-};
-const requirePlatformParam = (params) => {
-	const platform = requireRouteParam(params, "platform");
-	if (!isPlatform(platform)) throw new HandlerBadRequestError(`Invalid platform: ${platform}. Expected 'ios' or 'android'.`);
-	return platform;
-};
-const requireBundlePatchPayload = (payload, bundleId) => {
-	if (!payload || typeof payload !== "object" || Array.isArray(payload)) throw new HandlerBadRequestError("Invalid bundle payload");
-	const bundlePatch = payload;
-	if (bundlePatch.id !== void 0 && bundlePatch.id !== bundleId) throw new HandlerBadRequestError("Bundle id mismatch");
-	const { id: _ignoredId, ...rest } = bundlePatch;
-	return rest;
-};
-const handleFingerprintUpdateWithCohort = async (params, request, api, context) => {
-	const platform = requirePlatformParam(params);
-	const fingerprintHash = requireRouteParam(params, "fingerprintHash");
-	const channel = requireRouteParam(params, "channel");
-	const minBundleId = requireRouteParam(params, "minBundleId");
-	const bundleId = requireRouteParam(params, "bundleId");
-	const updateInfo = await api.getAppUpdateInfo({
-		_updateStrategy: "fingerprint",
-		platform,
-		fingerprintHash,
-		channel,
-		minBundleId,
-		bundleId,
-		cohort: decodeMaybe(params.cohort)
-	}, context);
-	return new Response(serializeUpdateInfo(updateInfo, request), {
-		status: 200,
-		headers: { "Content-Type": "application/json" }
-	});
-};
-const handleAppVersionUpdateWithCohort = async (params, request, api, context) => {
-	const platform = requirePlatformParam(params);
-	const appVersion = requireRouteParam(params, "appVersion");
-	const channel = requireRouteParam(params, "channel");
-	const minBundleId = requireRouteParam(params, "minBundleId");
-	const bundleId = requireRouteParam(params, "bundleId");
-	const updateInfo = await api.getAppUpdateInfo({
-		_updateStrategy: "appVersion",
-		platform,
-		appVersion,
-		channel,
-		minBundleId,
-		bundleId,
-		cohort: decodeMaybe(params.cohort)
-	}, context);
-	return new Response(serializeUpdateInfo(updateInfo, request), {
-		status: 200,
-		headers: { "Content-Type": "application/json" }
-	});
-};
-const handleGetBundle = async (params, _request, api, context) => {
-	const bundleId = requireRouteParam(params, "id");
-	const bundle = await api.getBundleById(bundleId, context);
-	if (!bundle) return new Response(JSON.stringify({ error: "Bundle not found" }), {
-		status: 404,
-		headers: { "Content-Type": "application/json" }
-	});
-	return new Response(JSON.stringify(bundle), {
-		status: 200,
-		headers: { "Content-Type": "application/json" }
+const createDownloadStorageRouteHandler = (downloadStorageObject) => async (params) => {
+	const token = params.token;
+	const signature = params.signature;
+	if (!token || !signature) return errorResponse("Not found", 404);
+	const response = await downloadStorageObject(token, signature);
+	if (!response) return errorResponse("Not found", 404);
+	const headers = new Headers(response.headers);
+	if (!headers.has("cache-control")) headers.set("cache-control", "public, max-age=31536000, immutable");
+	return new Response(response.body, {
+		headers,
+		status: response.status,
+		statusText: response.statusText
 	});
 };
-const handleGetBundles = async (_params, request, api, context) => {
-	const url = new URL(request.url);
-	const channel = url.searchParams.get("channel") ?? void 0;
-	const platform = url.searchParams.get("platform");
-	const limit = parsePositiveIntegerSearchParam(url, "limit", DEFAULT_BUNDLE_LIST_LIMIT, MAX_BUNDLE_LIST_LIMIT);
-	const pageParam = url.searchParams.get("page");
-	const offset = url.searchParams.get("offset");
-	const after = url.searchParams.get("after") ?? void 0;
-	const before = url.searchParams.get("before") ?? void 0;
-	const enabled = parseBooleanSearchParam(url, "enabled");
-	const targetAppVersion = parseNullableStringSearchParam(url, "targetAppVersion");
-	const targetAppVersionIn = parseStringArraySearchParam(url, "targetAppVersionIn");
-	const targetAppVersionNotNull = parseBooleanSearchParam(url, "targetAppVersionNotNull");
-	const fingerprintHash = parseNullableStringSearchParam(url, "fingerprintHash");
-	const idEq = url.searchParams.get("idEq") ?? void 0;
-	const idGt = url.searchParams.get("idGt") ?? void 0;
-	const idGte = url.searchParams.get("idGte") ?? void 0;
-	const idLt = url.searchParams.get("idLt") ?? void 0;
-	const idLte = url.searchParams.get("idLte") ?? void 0;
-	const idIn = parseStringArraySearchParam(url, "idIn");
-	const page = pageParam === null ? void 0 : Number.isInteger(Number(pageParam)) && Number(pageParam) > 0 ? Number(pageParam) : null;
-	if (offset !== null) throw new HandlerBadRequestError("The 'offset' query parameter has been removed. Use 'after' or 'before' cursor pagination instead.");
-	if (page === null) throw new HandlerBadRequestError("The 'page' query parameter must be a positive integer.");
-	if (platform !== null && !isPlatform(platform)) throw new HandlerBadRequestError(`Invalid platform: ${platform}. Expected 'ios' or 'android'.`);
-	const result = await api.getBundles({
-		where: {
-			...channel && { channel },
-			...platform && { platform },
-			...enabled !== void 0 && { enabled },
-			...idEq || idGt || idGte || idLt || idLte || idIn && idIn.length > 0 ? { id: {
-				...idEq && { eq: idEq },
-				...idGt && { gt: idGt },
-				...idGte && { gte: idGte },
-				...idLt && { lt: idLt },
-				...idLte && { lte: idLte },
-				...idIn && idIn.length > 0 && { in: idIn }
-			} } : {},
-			...targetAppVersion !== void 0 && { targetAppVersion },
-			...targetAppVersionIn && { targetAppVersionIn },
-			...targetAppVersionNotNull !== void 0 && { targetAppVersionNotNull },
-			...fingerprintHash !== void 0 && { fingerprintHash }
-		},
-		limit,
-		page,
-		cursor: after || before ? {
-			after,
-			before
-		} : void 0
-	}, context);
-	return new Response(JSON.stringify(result), {
-		status: 200,
-		headers: { "Content-Type": "application/json" }
-	});
-};
-const handleCreateBundles = async (_params, request, api, context) => {
-	const body = await request.json();
-	const bundles = Array.isArray(body) ? body : [body];
-	for (const bundle of bundles) await api.insertBundle(bundle, context);
-	return new Response(JSON.stringify({ success: true }), {
-		status: 201,
-		headers: { "Content-Type": "application/json" }
-	});
-};
-const handleUpdateBundle = async (params, request, api, context) => {
-	const bundleId = requireRouteParam(params, "id");
-	const body = await request.json();
-	const bundlePatch = requireBundlePatchPayload(Array.isArray(body) ? body[0] : body, bundleId);
-	await api.updateBundleById(bundleId, bundlePatch, context);
-	return new Response(JSON.stringify({ success: true }), {
-		status: 200,
-		headers: { "Content-Type": "application/json" }
-	});
-};
-const handleDeleteBundle = async (params, _request, api, context) => {
-	const bundleId = requireRouteParam(params, "id");
-	await api.deleteBundleById(bundleId, context);
-	return new Response(JSON.stringify({ success: true }), {
-		status: 200,
-		headers: { "Content-Type": "application/json" }
-	});
-};
-const handleGetChannels = async (_params, _request, api, context) => {
-	const response = { data: { channels: await api.getChannels(context) } };
-	return new Response(JSON.stringify(response), {
-		status: 200,
-		headers: { "Content-Type": "application/json" }
-	});
-};
-const routes = {
-	version: handleVersion,
-	fingerprintUpdateWithCohort: handleFingerprintUpdateWithCohort,
-	appVersionUpdateWithCohort: handleAppVersionUpdateWithCohort,
-	getBundle: handleGetBundle,
-	getBundles: handleGetBundles,
-	createBundles: handleCreateBundles,
-	updateBundle: handleUpdateBundle,
-	deleteBundle: handleDeleteBundle,
-	getChannels: handleGetChannels
-};
-/**
-* Creates a Web Standard Request handler for Hot Updater API
-* This handler is framework-agnostic and works with any runtime that
-* supports standard Request/Response objects.
-*/
-function createHandler(api, options = {}) {
-	const basePath = options.basePath ?? "/api";
-	const routeOptions = {
-		updateCheck: options.routes?.updateCheck ?? true,
-		bundles: options.routes?.bundles ?? false
-	};
-	const router = require_internalRouter.createRouter();
-	require_internalRouter.addRoute(router, "GET", "/version", "version");
-	if (routeOptions.updateCheck) {
-		require_internalRouter.addRoute(router, "GET", "/fingerprint/:platform/:fingerprintHash/:channel/:minBundleId/:bundleId", "fingerprintUpdateWithCohort");
-		require_internalRouter.addRoute(router, "GET", "/fingerprint/:platform/:fingerprintHash/:channel/:minBundleId/:bundleId/:cohort", "fingerprintUpdateWithCohort");
-		require_internalRouter.addRoute(router, "GET", "/app-version/:platform/:appVersion/:channel/:minBundleId/:bundleId", "appVersionUpdateWithCohort");
-		require_internalRouter.addRoute(router, "GET", "/app-version/:platform/:appVersion/:channel/:minBundleId/:bundleId/:cohort", "appVersionUpdateWithCohort");
-	}
-	if (routeOptions.bundles) {
-		require_internalRouter.addRoute(router, "GET", "/api/bundles/channels", "getChannels");
-		require_internalRouter.addRoute(router, "GET", "/api/bundles/:id", "getBundle");
-		require_internalRouter.addRoute(router, "GET", "/api/bundles", "getBundles");
-		require_internalRouter.addRoute(router, "POST", "/api/bundles", "createBundles");
-		require_internalRouter.addRoute(router, "PATCH", "/api/bundles/:id", "updateBundle");
-		require_internalRouter.addRoute(router, "DELETE", "/api/bundles/:id", "deleteBundle");
-	}
-	return async (request, context) => {
-		try {
-			const path = new URL(request.url).pathname;
-			const method = request.method;
-			const match = require_internalRouter.findRoute(router, method, path.startsWith(basePath) ? path.slice(basePath.length) : path);
-			if (!match) return new Response(JSON.stringify({ error: "Not found" }), {
-				status: 404,
-				headers: { "Content-Type": "application/json" }
-			});
-			const handler = routes[match.data];
-			if (!handler) return new Response(JSON.stringify({ error: "Handler not found" }), {
-				status: 500,
-				headers: { "Content-Type": "application/json" }
-			});
-			return await handler(match.params || {}, request, api, context);
-		} catch (error) {
-			if (error instanceof HandlerBadRequestError) return new Response(JSON.stringify({ error: error.message }), {
-				status: 400,
-				headers: { "Content-Type": "application/json" }
-			});
-			console.error("Hot Updater handler error:", error);
-			return new Response(JSON.stringify({
-				error: "Internal server error",
-				message: error instanceof Error ? error.message : "Unknown error"
-			}), {
-				status: 500,
-				headers: { "Content-Type": "application/json" }
-			});
-		}
+function createHandlers(api) {
+	return createHotUpdaterHandlers(api);
+}
+function createHotUpdaterHandlers(api, analytics, apiKeyAuth, downloadStorageObject) {
+	const routeHandlers = {
+		...require_handlerVersionRoutes.createVersionRouteHandlers(),
+		...require_handlerReleaseCatalogRoutes.createReleaseCatalogRouteHandlers(apiKeyAuth?.headerName),
+		...require_handlerReleaseManagementRoutes.createReleaseManagementRouteHandlers(),
+		...require_handlerBundleRoutes.createBundleRouteHandlers(),
+		...analytics === void 0 ? {} : require_routes.createAnalyticsRouteHandlers(analytics),
+		...downloadStorageObject === void 0 ? {} : { downloadStorageObject: createDownloadStorageRouteHandler(downloadStorageObject) }
 	};
+	const clientRouter = require_internalRouter.createRouter();
+	const addClientRoute = (method, path, handler) => require_internalRouter.addRoute(clientRouter, method, path, handler);
+	addClientRoute("GET", "/version", "version");
+	if (downloadStorageObject !== void 0) addClientRoute("GET", "/storage/:token/:signature", "downloadStorageObject");
+	addClientRoute("GET", "/release-catalogs/app-version/:platform/:channelKey/:appVersion", "appVersionReleaseCatalog");
+	addClientRoute("GET", "/release-catalogs/fingerprint/:platform/:channelKey/:fingerprintHash", "fingerprintReleaseCatalog");
+	addClientRoute("GET", "/artifacts/:targetBundleId/from/:currentBundleId", "artifact");
+	if (analytics !== void 0) require_routes.registerAnalyticsClientRoutes(addClientRoute);
+	const adminRouter = require_internalRouter.createRouter();
+	const addAdminRoute = (method, path, handler) => require_internalRouter.addRoute(adminRouter, method, path, handler);
+	addAdminRoute("GET", "/releases/:id", "getRelease");
+	addAdminRoute("GET", "/releases", "getReleases");
+	addAdminRoute("PATCH", "/releases/:id", "updateRelease");
+	addAdminRoute("POST", "/releases/:id/preflight", "preflightRelease");
+	addAdminRoute("DELETE", "/releases/:id", "deleteRelease");
+	addAdminRoute("GET", "/release-catalogs/:scopeKey", "getReleaseCatalogRow");
+	addAdminRoute("GET", "/release-catalogs", "getReleaseCatalogs");
+	addAdminRoute("POST", "/release-catalogs/:scopeKey/rebuild", "rebuildReleaseCatalog");
+	addAdminRoute("POST", "/database/commit", "commitDatabase");
+	addAdminRoute("GET", "/channels", "getChannels");
+	addAdminRoute("POST", "/channels", "createChannel");
+	addAdminRoute("DELETE", "/channels/:id", "deleteChannel");
+	addAdminRoute("GET", "/bundles/:id", "getBundle");
+	addAdminRoute("GET", "/bundles", "getBundles");
+	addAdminRoute("POST", "/bundles", "createBundles");
+	addAdminRoute("PATCH", "/bundles/:id", "updateBundle");
+	addAdminRoute("DELETE", "/bundles/:id", "deleteBundle");
+	if (analytics !== void 0) require_routes.registerAnalyticsAdminRoutes(addAdminRoute);
+	return Object.freeze({
+		client: createRequestHandler({
+			api,
+			apiKeyAuth,
+			routeHandlers,
+			router: clientRouter
+		}),
+		admin: createRequestHandler({
+			api,
+			privateResponses: true,
+			routeHandlers,
+			router: adminRouter
+		})
+	});
 }
 //#endregion
-exports.createHandler = createHandler;
+exports.createHandlers = createHandlers;
+exports.createHotUpdaterHandlers = createHotUpdaterHandlers;