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

package/.output/server/_ssr/routes-Z7TwC6nC.mjs

@@ -0,0 +1,37 @@
+import { d as createFileRoute, u as lazyRouteComponent } from "../_libs/@tanstack/react-router+[...].mjs";
+//#region node_modules/.nitro/vite/services/ssr/assets/routes-Z7TwC6nC.js
+var optionalString = (value) => typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+function validateReleaseSearch(search) {
+	const parsedPage = typeof search.page === "number" ? search.page : typeof search.page === "string" ? Number(search.page) : void 0;
+	const beforeReleaseId = optionalString(search.beforeReleaseId);
+	const afterReleaseId = beforeReleaseId ? void 0 : optionalString(search.afterReleaseId);
+	const enabled = search.enabled === true || search.enabled === "true" ? true : search.enabled === false || search.enabled === "false" ? false : void 0;
+	return {
+		afterReleaseId,
+		beforeReleaseId,
+		bundleId: optionalString(search.bundleId),
+		channelId: optionalString(search.channelId),
+		enabled,
+		page: parsedPage !== void 0 && Number.isInteger(parsedPage) && parsedPage > 1 ? parsedPage : void 0,
+		platform: search.platform === "ios" || search.platform === "android" ? search.platform : void 0,
+		releaseId: optionalString(search.releaseId),
+		targetAppVersion: optionalString(search.targetAppVersion)
+	};
+}
+function updateReleaseFilters(current, filters) {
+	return {
+		...current,
+		...filters,
+		afterReleaseId: void 0,
+		beforeReleaseId: void 0,
+		page: void 0,
+		releaseId: void 0
+	};
+}
+var $$splitComponentImporter = () => import("./routes-BM4ht9jb.mjs");
+var Route = createFileRoute("/")({
+	component: lazyRouteComponent($$splitComponentImporter, "component"),
+	validateSearch: validateReleaseSearch
+});
+//#endregion
+export { updateReleaseFilters as n, Route as t };

package/.output/server/_ssr/runtime.server-awTLiiXW.mjs

@@ -0,0 +1,527 @@
+import { a as parseSearchInstallationsInput, i as parseInstallationHistoryInput, n as parseBundleEventAnalyticsInput, r as parseBundleEventSummaryInput, t as parseActiveInstallationInput } from "./analytics-input-fRRRn0uA.mjs";
+import { t as createUUIDv7 } from "./uuidv7-BbJ-9D_I.mjs";
+//#region node_modules/.nitro/vite/services/ssr/assets/runtime.server-awTLiiXW.js
+var AnalyticsScanLimitExceededError = class extends Error {
+	constructor(limit) {
+		super(`Analytics event scan exceeded ${limit} rows.`);
+		this.limit = limit;
+		this.name = "AnalyticsScanLimitExceededError";
+	}
+};
+var HOUR_MS = 3600 * 1e3;
+var DAY_MS = 24 * HOUR_MS;
+var ACTIVE_BUNDLE_EVENT_TYPES = [
+	"UPDATE_APPLIED",
+	"RECOVERED",
+	"RELEASE_ADOPTED",
+	"UNCHANGED"
+];
+var activeWindowDefinitions = {
+	"24h": {
+		bucketCount: 24,
+		bucketSizeMs: HOUR_MS
+	},
+	"7d": {
+		bucketCount: 7,
+		bucketSizeMs: DAY_MS
+	},
+	"30d": {
+		bucketCount: 30,
+		bucketSizeMs: DAY_MS
+	}
+};
+function getActiveWindowDefinition(window) {
+	return activeWindowDefinitions[window];
+}
+function compareCodePoints$1(left, right) {
+	if (left < right) return -1;
+	if (left > right) return 1;
+	return 0;
+}
+function isNewer(candidate, current) {
+	return candidate.received_at_ms > current.received_at_ms || candidate.received_at_ms === current.received_at_ms && compareCodePoints$1(candidate.id, current.id) > 0;
+}
+function collectActiveInstallationOverview(request) {
+	const definition = getActiveWindowDefinition(request.window);
+	const windowStartMs = request.asOfMs - definition.bucketCount * definition.bucketSizeMs;
+	const rows = request.rows.filter((row) => row.received_at_ms >= windowStartMs && row.received_at_ms < request.asOfMs);
+	const latestByInstall = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const current = latestByInstall.get(row.install_id);
+		if (current === void 0 || isNewer(row, current)) latestByInstall.set(row.install_id, row);
+	}
+	const selectedRows = [...latestByInstall.values()].filter((row) => request.userId === void 0 || row.user_id === request.userId);
+	const selectedInstallIds = new Set(selectedRows.map((row) => row.install_id));
+	const bundleCounts = /* @__PURE__ */ new Map();
+	for (const row of selectedRows) bundleCounts.set(row.to_bundle_id, (bundleCounts.get(row.to_bundle_id) ?? 0) + 1);
+	const latestByBucket = Array.from({ length: definition.bucketCount }, () => /* @__PURE__ */ new Map());
+	for (const row of rows) {
+		if (!selectedInstallIds.has(row.install_id)) continue;
+		const bucket = latestByBucket[Math.floor((row.received_at_ms - windowStartMs) / definition.bucketSizeMs)];
+		if (bucket === void 0) continue;
+		const current = bucket.get(row.install_id);
+		if (current === void 0 || isNewer(row, current)) bucket.set(row.install_id, row);
+	}
+	const bundleCountsByBucket = latestByBucket.map((bucket) => {
+		const counts = /* @__PURE__ */ new Map();
+		for (const row of bucket.values()) counts.set(row.to_bundle_id, (counts.get(row.to_bundle_id) ?? 0) + 1);
+		return counts;
+	});
+	const bundleObservationTotals = /* @__PURE__ */ new Map();
+	for (const counts of bundleCountsByBucket) for (const [bundleId, count] of counts) bundleObservationTotals.set(bundleId, (bundleObservationTotals.get(bundleId) ?? 0) + count);
+	return {
+		asOfMs: request.asOfMs,
+		window: request.window,
+		activeInstallations: selectedInstallIds.size,
+		series: latestByBucket.map((bucket, index) => ({
+			bucketStartMs: windowStartMs + index * definition.bucketSizeMs,
+			value: bucket.size
+		})),
+		bundleSeries: [...bundleObservationTotals].sort(([leftId, leftTotal], [rightId, rightTotal]) => rightTotal - leftTotal || compareCodePoints$1(leftId, rightId)).map(([bundleId]) => ({
+			bundleId,
+			series: bundleCountsByBucket.map((counts, index) => ({
+				bucketStartMs: windowStartMs + index * definition.bucketSizeMs,
+				value: counts.get(bundleId) ?? 0
+			}))
+		})),
+		bundles: [...bundleCounts].map(([bundleId, installations]) => ({
+			bundleId,
+			installations
+		})).sort((left, right) => right.installations - left.installations || compareCodePoints$1(left.bundleId, right.bundleId))
+	};
+}
+var ANALYTICS_SCAN_MAX_ROWS = 5e4;
+var ANALYTICS_MATERIALIZATION_LIMIT = ANALYTICS_SCAN_MAX_ROWS + 1;
+var ANALYTICS_SCAN_PAGE_SIZE = 1e3;
+var ANALYTICS_LOWER_BOUND_ID = "00000000-0000-0000-0000-000000000000";
+var compareCodePoints = (left, right) => {
+	if (left < right) return -1;
+	if (left > right) return 1;
+	return 0;
+};
+var compareEventNewest = (left, right) => right.received_at_ms - left.received_at_ms || compareCodePoints(right.id, left.id);
+var compareEventOldest = (left, right) => left.received_at_ms - right.received_at_ms || compareCodePoints(left.id, right.id);
+var materializeEventRows = async (scope) => {
+	const rows = [];
+	const seenIds = /* @__PURE__ */ new Set();
+	let after = scope.lowerBoundMs === void 0 ? void 0 : {
+		receivedAtMs: scope.lowerBoundMs,
+		id: ANALYTICS_LOWER_BOUND_ID
+	};
+	while (rows.length < ANALYTICS_MATERIALIZATION_LIMIT) {
+		const limit = Math.min(ANALYTICS_SCAN_PAGE_SIZE, ANALYTICS_MATERIALIZATION_LIMIT - rows.length);
+		const page = await scope.persistence.scan({
+			beforeReceivedAtMs: scope.cutoffMs,
+			...after === void 0 ? {} : { after },
+			limit
+		});
+		if (page.length === 0) break;
+		if (page.length > limit) throw new AnalyticsPersistenceOrderError();
+		let previous = after === void 0 ? void 0 : {
+			received_at_ms: after.receivedAtMs,
+			id: after.id
+		};
+		for (const row of page) {
+			if (row.received_at_ms >= scope.cutoffMs || previous !== void 0 && compareEventOldest(previous, row) >= 0 || seenIds.has(row.id)) throw new AnalyticsPersistenceOrderError();
+			seenIds.add(row.id);
+			rows.push(row);
+			previous = row;
+		}
+		const last = page.at(-1);
+		if (last !== void 0) after = {
+			receivedAtMs: last.received_at_ms,
+			id: last.id
+		};
+		if (rows.length > 5e4) throw new AnalyticsScanLimitExceededError(ANALYTICS_SCAN_MAX_ROWS);
+	}
+	return rows;
+};
+var AnalyticsPersistenceOrderError = class extends Error {
+	name = "AnalyticsPersistenceOrderError";
+	constructor() {
+		super("Analytics persistence did not advance its scan cursor.");
+	}
+};
+var materializeActiveRows = async (scope, window) => {
+	const definition = getActiveWindowDefinition(window);
+	const durationMs = definition.bucketCount * definition.bucketSizeMs;
+	return (await materializeEventRows({
+		...scope,
+		lowerBoundMs: scope.cutoffMs - durationMs
+	})).filter((row) => row.received_at_ms >= scope.cutoffMs - durationMs && ACTIVE_BUNDLE_EVENT_TYPES.includes(row.type));
+};
+var startOfUtcHour = (value) => {
+	const date = new Date(value);
+	return Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), date.getUTCHours());
+};
+var startOfUtcDay = (value) => {
+	const date = new Date(value);
+	return Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
+};
+var getWindowRange = (window, now) => {
+	if (window === "24h") return {
+		sizeMs: 3600 * 1e3,
+		rangeStart: startOfUtcHour(now) - 1380 * 60 * 1e3
+	};
+	const days = window === "7d" ? 7 : 30;
+	return {
+		sizeMs: 1440 * 60 * 1e3,
+		rangeStart: startOfUtcDay(now) - (days - 1) * 24 * 60 * 60 * 1e3
+	};
+};
+var materializeRowsForWindow = async (scope, window) => {
+	if (window === "all") return materializeEventRows(scope);
+	const range = getWindowRange(window, scope.cutoffMs);
+	return (await materializeEventRows({
+		...scope,
+		lowerBoundMs: range.rangeStart
+	})).filter(({ received_at_ms }) => received_at_ms >= range.rangeStart);
+};
+var bucketStart = (receivedAtMs, sizeMs) => sizeMs === 3600 * 1e3 ? startOfUtcHour(receivedAtMs) : startOfUtcDay(receivedAtMs);
+var createSeries = (request) => {
+	const range = request.window === "all" ? void 0 : getWindowRange(request.window, request.cutoffMs);
+	const sizeMs = range?.sizeMs ?? 1440 * 60 * 1e3;
+	const installIdsByBucket = /* @__PURE__ */ new Map();
+	let oldestMs = request.cutoffMs;
+	for (const row of request.rows) {
+		oldestMs = Math.min(oldestMs, row.received_at_ms);
+		const start = bucketStart(row.received_at_ms, sizeMs);
+		const installIds = installIdsByBucket.get(start) ?? /* @__PURE__ */ new Set();
+		installIds.add(row.install_id);
+		installIdsByBucket.set(start, installIds);
+	}
+	const first = range?.rangeStart ?? startOfUtcDay(oldestMs);
+	const last = bucketStart(request.cutoffMs, sizeMs);
+	return Array.from({ length: Math.floor((last - first) / sizeMs) + 1 }, (_, index) => {
+		const start = first + index * sizeMs;
+		return {
+			bucketStartMs: start,
+			value: installIdsByBucket.get(start)?.size ?? 0
+		};
+	});
+};
+var collectEventActivity = (request) => {
+	const range = request.window === "all" ? void 0 : getWindowRange(request.window, request.cutoffMs);
+	const rows = range === void 0 ? request.rows : request.rows.filter(({ received_at_ms }) => received_at_ms >= range.rangeStart && received_at_ms < request.cutoffMs);
+	const installs = /* @__PURE__ */ new Set();
+	const installsByCohort = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		installs.add(row.install_id);
+		const cohort = installsByCohort.get(row.cohort) ?? /* @__PURE__ */ new Set();
+		cohort.add(row.install_id);
+		installsByCohort.set(row.cohort, cohort);
+	}
+	return {
+		summary: installs.size,
+		cohorts: [...installsByCohort].sort(([left], [right]) => compareCodePoints(left, right)).map(([cohort, installIds]) => ({
+			cohort,
+			value: installIds.size
+		})),
+		series: createSeries({
+			...request,
+			rows
+		})
+	};
+};
+function toSearchRow(row) {
+	return {
+		installId: row.install_id,
+		username: row.username,
+		userId: row.user_id,
+		lastKnownBundleId: row.to_bundle_id,
+		latestStatus: row.type,
+		platform: row.platform,
+		appVersion: row.app_version,
+		channel: row.channel,
+		cohort: row.cohort,
+		receivedAtMs: row.received_at_ms
+	};
+}
+function matchesIdentity(row, query) {
+	return row.install_id.toLowerCase().includes(query) || row.user_id?.toLowerCase().includes(query) === true || row.username?.toLowerCase().includes(query) === true;
+}
+function searchEventInstallations(request) {
+	const query = request.query.toLowerCase();
+	const matchingInstallIds = /* @__PURE__ */ new Set();
+	for (const row of request.rows) if (query.length === 0 || matchesIdentity(row, query)) matchingInstallIds.add(row.install_id);
+	const latestByInstall = /* @__PURE__ */ new Map();
+	for (const row of request.rows) {
+		if (!matchingInstallIds.has(row.install_id)) continue;
+		const current = latestByInstall.get(row.install_id);
+		if (current === void 0 || compareEventNewest(row, current) < 0) latestByInstall.set(row.install_id, row);
+	}
+	const matchingRows = [...latestByInstall.values()].sort((left, right) => compareCodePoints(left.install_id, right.install_id));
+	const pageSize = Math.min(Math.max(request.limit, 0), 100);
+	return {
+		data: matchingRows.slice(request.offset, request.offset + pageSize).map(toSearchRow),
+		pagination: {
+			total: matchingRows.length,
+			limit: request.limit,
+			offset: request.offset
+		}
+	};
+}
+function createBundleEventRow(input) {
+	const base = {
+		id: createUUIDv7(),
+		install_id: input.installId,
+		user_id: input.userId ?? null,
+		username: input.username ?? null,
+		from_release_id: input.fromReleaseId,
+		to_release_id: input.toReleaseId,
+		to_bundle_id: input.toBundleId,
+		platform: input.platform,
+		app_version: input.appVersion,
+		channel: input.channel,
+		cohort: input.cohort,
+		fingerprint_hash: input.fingerprintHash,
+		sdk_version: input.sdkVersion ?? null,
+		received_at_ms: Date.now()
+	};
+	switch (input.type) {
+		case "UPDATE_APPLIED":
+		case "RECOVERED":
+		case "RELEASE_ADOPTED": return {
+			...base,
+			type: input.type,
+			from_bundle_id: input.fromBundleId,
+			update_strategy: input.updateStrategy
+		};
+		case "UNCHANGED": return {
+			...base,
+			type: input.type,
+			from_bundle_id: null,
+			update_strategy: null
+		};
+	}
+}
+var isTransitionEventRow = (row) => row.type === "UPDATE_APPLIED" || row.type === "RECOVERED";
+var toHistoryRow = (row) => ({
+	id: row.id,
+	type: row.type,
+	fromBundleId: row.from_bundle_id,
+	toBundleId: row.to_bundle_id,
+	username: row.username,
+	userId: row.user_id,
+	platform: row.platform,
+	appVersion: row.app_version,
+	channel: row.channel,
+	cohort: row.cohort,
+	receivedAtMs: row.received_at_ms
+});
+var isInstalledForBundle = (row, bundleId) => row.type === "UPDATE_APPLIED" && row.to_bundle_id === bundleId;
+var isRecoveredFromBundle = (row, bundleId) => row.type === "RECOVERED" && row.from_bundle_id === bundleId;
+var countDistinctInstallations = (rows) => new Set(rows.map(({ install_id }) => install_id)).size;
+var getAnalyticsResult = async (persistence, bundleId, window, limit, offset) => {
+	const scope = {
+		persistence,
+		cutoffMs: Date.now()
+	};
+	const rows = (await materializeRowsForWindow(scope, window)).filter(isTransitionEventRow);
+	const installedRows = rows.filter((row) => isInstalledForBundle(row, bundleId));
+	const recoveredRows = rows.filter((row) => isRecoveredFromBundle(row, bundleId));
+	const installed = collectEventActivity({
+		rows: installedRows,
+		window,
+		cutoffMs: scope.cutoffMs
+	});
+	const recovered = collectEventActivity({
+		rows: recoveredRows,
+		window,
+		cutoffMs: scope.cutoffMs
+	});
+	const recentRows = [...installedRows, ...recoveredRows].sort(compareEventNewest);
+	return {
+		summary: {
+			installed: installed.summary,
+			recovered: recovered.summary
+		},
+		series: {
+			installed: installed.series,
+			recovered: recovered.series
+		},
+		cohorts: {
+			installed: installed.cohorts,
+			recovered: recovered.cohorts
+		},
+		recentEvents: {
+			data: recentRows.slice(offset, offset + limit).map(toHistoryRow),
+			pagination: {
+				total: recentRows.length,
+				limit,
+				offset
+			}
+		}
+	};
+};
+var getAnalyticsSummaries = async (persistence, bundleIds, window) => {
+	const normalizedBundleIds = [...new Set(bundleIds)];
+	if (normalizedBundleIds.length === 0) return [];
+	const requestedBundleIds = new Set(normalizedBundleIds);
+	const installedByBundleId = /* @__PURE__ */ new Map();
+	const recoveredByBundleId = /* @__PURE__ */ new Map();
+	const rows = (await materializeRowsForWindow({
+		persistence,
+		cutoffMs: Date.now()
+	}, window)).filter(isTransitionEventRow);
+	for (const row of rows) {
+		const bundleId = row.type === "UPDATE_APPLIED" ? row.to_bundle_id : row.from_bundle_id;
+		if (!requestedBundleIds.has(bundleId)) continue;
+		const counts = row.type === "UPDATE_APPLIED" ? installedByBundleId : recoveredByBundleId;
+		const installIds = counts.get(bundleId) ?? /* @__PURE__ */ new Set();
+		installIds.add(row.install_id);
+		counts.set(bundleId, installIds);
+	}
+	return normalizedBundleIds.map((bundleId) => ({
+		bundleId,
+		installed: installedByBundleId.get(bundleId)?.size ?? 0,
+		recovered: recoveredByBundleId.get(bundleId)?.size ?? 0
+	}));
+};
+var createAnalyticsProvider = (persistence) => Object.freeze({
+	mode: "bounded",
+	maxMatchingRows: ANALYTICS_SCAN_MAX_ROWS,
+	async appendBundleEvent(input) {
+		await persistence.append(createBundleEventRow(input));
+	},
+	async getBundleEventSummary(bundleId) {
+		const rows = (await materializeEventRows({
+			persistence,
+			cutoffMs: Date.now()
+		})).filter(isTransitionEventRow);
+		return {
+			installed: countDistinctInstallations(rows.filter((row) => isInstalledForBundle(row, bundleId))),
+			recovered: countDistinctInstallations(rows.filter((row) => isRecoveredFromBundle(row, bundleId)))
+		};
+	},
+	getBundleEventSummaries(bundleIds, window) {
+		return getAnalyticsSummaries(persistence, bundleIds, window);
+	},
+	getBundleEventAnalytics(bundleId, window, limit, offset) {
+		return getAnalyticsResult(persistence, bundleId, window, limit, offset);
+	},
+	async getBundleEventOverview() {
+		const rows = await materializeEventRows({
+			persistence,
+			cutoffMs: Date.now()
+		});
+		const latestByInstall = /* @__PURE__ */ new Map();
+		for (const row of rows) {
+			const current = latestByInstall.get(row.install_id);
+			if (current === void 0 || compareEventNewest(row, current) < 0) latestByInstall.set(row.install_id, row);
+		}
+		const counts = /* @__PURE__ */ new Map();
+		for (const row of latestByInstall.values()) counts.set(row.to_bundle_id, (counts.get(row.to_bundle_id) ?? 0) + 1);
+		return {
+			trackedInstallations: latestByInstall.size,
+			bundles: [...counts].map(([bundleId, installations]) => ({
+				bundleId,
+				installations
+			})).sort((left, right) => right.installations - left.installations || compareCodePoints(left.bundleId, right.bundleId))
+		};
+	},
+	async getActiveInstallationOverview(input) {
+		const asOfMs = Date.now();
+		return collectActiveInstallationOverview({
+			rows: await materializeActiveRows({
+				persistence,
+				cutoffMs: asOfMs
+			}, input.window),
+			asOfMs,
+			window: input.window,
+			...input.userId === void 0 ? {} : { userId: input.userId }
+		});
+	},
+	async searchInstallations(query, limit, offset) {
+		return searchEventInstallations({
+			rows: await materializeEventRows({
+				persistence,
+				cutoffMs: Date.now()
+			}),
+			query,
+			limit,
+			offset
+		});
+	},
+	async getInstallationHistory(installId, limit, offset) {
+		const ordered = (await materializeEventRows({
+			persistence,
+			cutoffMs: Date.now()
+		})).filter((row) => row.install_id === installId && isTransitionEventRow(row)).toSorted(compareEventNewest);
+		return {
+			data: ordered.slice(offset, offset + limit).map(toHistoryRow),
+			pagination: {
+				total: ordered.length,
+				limit,
+				offset
+			}
+		};
+	}
+});
+function createRuntimeHotUpdater(config) {
+	const models = Reflect.get(config.database, "models");
+	const analytics = typeof models === "object" && models !== null ? Reflect.get(models, "analytics") : void 0;
+	if (typeof analytics !== "object" || analytics === null || typeof Reflect.get(analytics, "append") !== "function" || typeof Reflect.get(analytics, "scan") !== "function") return null;
+	return createAnalyticsProvider(analytics);
+}
+function createApiKeyStore(config) {
+	const models = Reflect.get(config.database, "models");
+	const apiKeys = typeof models === "object" && models !== null ? Reflect.get(models, "apiKeys") : void 0;
+	if (typeof apiKeys !== "object" || apiKeys === null || typeof Reflect.get(apiKeys, "create") !== "function" || typeof Reflect.get(apiKeys, "findByHash") !== "function" || typeof Reflect.get(apiKeys, "list") !== "function" || typeof Reflect.get(apiKeys, "revoke") !== "function") return null;
+	return apiKeys;
+}
+var providerMethods = [
+	"appendBundleEvent",
+	"getBundleEventSummary",
+	"getBundleEventSummaries",
+	"getBundleEventAnalytics",
+	"getBundleEventOverview",
+	"getActiveInstallationOverview",
+	"searchInstallations",
+	"getInstallationHistory"
+];
+var parseAnalyticsProvider = (value) => {
+	if (typeof value !== "object" || value === null || Reflect.get(value, "mode") !== "bounded" || typeof Reflect.get(value, "maxMatchingRows") !== "number" || !providerMethods.every((method) => typeof Reflect.get(value, method) === "function")) return null;
+	return value;
+};
+var getAnalyticsCapability = async (provider) => {
+	const parsed = parseAnalyticsProvider(provider);
+	return parsed === null ? {
+		analytics: false,
+		analyticsQueries: false,
+		eventIngestion: false
+	} : {
+		analytics: true,
+		analyticsQueries: true,
+		eventIngestion: true,
+		maxMatchingRows: parsed.maxMatchingRows,
+		mode: "bounded"
+	};
+};
+var requireAnalyticsSupport = async (provider) => {
+	const parsedProvider = parseAnalyticsProvider(provider);
+	if (parsedProvider === null) throw new Error("Analytics are not supported by the configured database plugin.");
+	return parsedProvider;
+};
+async function getBundleEventSummary(provider, input) {
+	const { bundleId } = parseBundleEventSummaryInput(input);
+	return (await requireAnalyticsSupport(provider)).getBundleEventSummary(bundleId);
+}
+async function getActiveInstallationOverview(provider, input) {
+	const parsed = parseActiveInstallationInput(input);
+	return (await requireAnalyticsSupport(provider)).getActiveInstallationOverview(parsed);
+}
+async function getBundleEventAnalytics(provider, input) {
+	const parsed = parseBundleEventAnalyticsInput(input);
+	return (await requireAnalyticsSupport(provider)).getBundleEventAnalytics(parsed.bundleId, parsed.window, parsed.limit ?? 50, parsed.offset ?? 0);
+}
+async function searchInstallations(provider, input) {
+	const parsed = parseSearchInstallationsInput(input);
+	return (await requireAnalyticsSupport(provider)).searchInstallations(parsed.query, parsed.limit ?? 50, parsed.offset ?? 0);
+}
+async function getInstallationHistory(provider, input) {
+	const parsed = parseInstallationHistoryInput(input);
+	return (await requireAnalyticsSupport(provider)).getInstallationHistory(parsed.installId, parsed.limit ?? 50, parsed.offset ?? 0);
+}
+//#endregion
+export { createApiKeyStore, createRuntimeHotUpdater, getActiveInstallationOverview, getAnalyticsCapability, getBundleEventAnalytics, getBundleEventSummary, getInstallationHistory, searchInstallations };