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

package/src/insights/queryInput.ts

@@ -0,0 +1,141 @@
+import type {
+  ActiveInstallationWindow,
+  InsightsBundleSelection,
+  InsightsScope,
+} from "./domain";
+import { InsightsBadRequestError } from "./errors";
+import type {
+  InsightsEventPageInput,
+  InsightsUserInstallationPageInput,
+} from "./types";
+
+const MAX_PAGE_LIMIT = 100;
+const MAX_IDENTITY_LENGTH = 255;
+const MAX_CURSOR_LENGTH = 8 * 1_024;
+
+const readSingle = (url: URL, key: string): string | undefined => {
+  const values = url.searchParams.getAll(key);
+  if (values.length > 1) {
+    throw new InsightsBadRequestError(`Duplicate '${key}' query parameter.`);
+  }
+  return values[0];
+};
+
+const readPageLimit = (url: URL): number | undefined => {
+  const value = readSingle(url, "limit");
+  if (value === undefined) return undefined;
+  const limit = Number(value);
+  if (!Number.isSafeInteger(limit) || limit < 1 || limit > MAX_PAGE_LIMIT) {
+    throw new InsightsBadRequestError("Invalid 'limit' query parameter.");
+  }
+  return limit;
+};
+
+const readCursor = (url: URL): string | undefined => {
+  const cursor = readSingle(url, "cursor");
+  if (
+    cursor !== undefined &&
+    (cursor.length === 0 || cursor.length > MAX_CURSOR_LENGTH)
+  ) {
+    throw new InsightsBadRequestError("Invalid 'cursor' query parameter.");
+  }
+  return cursor;
+};
+
+const readId = (
+  url: URL,
+  key: string,
+  maximumLength = MAX_IDENTITY_LENGTH,
+): string => {
+  const value = readSingle(url, key);
+  if (
+    value === undefined ||
+    value.length === 0 ||
+    value.length > maximumLength
+  ) {
+    throw new InsightsBadRequestError(`Invalid '${key}' query parameter.`);
+  }
+  return value;
+};
+
+const readTimestamp = (url: URL, key: string): number | undefined => {
+  const raw = readSingle(url, key);
+  if (raw === undefined) return undefined;
+  const value = Number(raw);
+  if (!raw.length || !Number.isSafeInteger(value) || value < 0) {
+    throw new InsightsBadRequestError(`Invalid '${key}' query parameter.`);
+  }
+  return value;
+};
+
+const readScope = (url: URL): InsightsScope => {
+  const platform = readSingle(url, "platform");
+  if (platform !== "ios" && platform !== "android") {
+    throw new InsightsBadRequestError("Invalid 'platform' query parameter.");
+  }
+  return { platform, channel: readId(url, "channel", 1_024) };
+};
+
+export const parseEventPageInput = (
+  request: Request,
+): InsightsEventPageInput => {
+  const url = new URL(request.url);
+  const bundleFields = ["bundleId", "outcome", "platform", "channel"];
+  let bundle: InsightsBundleSelection | undefined;
+  if (bundleFields.some((key) => url.searchParams.has(key))) {
+    const outcome = readSingle(url, "outcome");
+    if (
+      outcome !== "applied" &&
+      outcome !== "recovered" &&
+      outcome !== "adopted"
+    ) {
+      throw new InsightsBadRequestError("Invalid 'outcome' query parameter.");
+    }
+    bundle = {
+      ...readScope(url),
+      bundleId: readId(url, "bundleId", 1_024),
+      outcome,
+    };
+  }
+  return {
+    beforeReceivedAtMs: readTimestamp(url, "beforeReceivedAtMs"),
+    sinceMs: readTimestamp(url, "sinceMs"),
+    cursor: readCursor(url),
+    limit: readPageLimit(url),
+    ...(bundle === undefined ? {} : { bundle }),
+  };
+};
+
+export const parseUserInstallationPageInput = (
+  request: Request,
+): InsightsUserInstallationPageInput => {
+  const url = new URL(request.url);
+  const cursor = readCursor(url);
+  const limit = readPageLimit(url);
+  return {
+    userId: readId(url, "userId"),
+    ...(cursor === undefined ? {} : { cursor }),
+    ...(limit === undefined ? {} : { limit }),
+  };
+};
+
+export const parseReportingOverviewInput = (
+  request: Request,
+): InsightsScope & {
+  readonly window: ActiveInstallationWindow;
+  readonly bundleId?: string;
+} => {
+  const url = new URL(request.url);
+  const window = readSingle(url, "window") ?? "30d";
+  if (window !== "24h" && window !== "7d" && window !== "30d") {
+    throw new InsightsBadRequestError("Invalid 'window' query parameter.");
+  }
+  const bundleId = readSingle(url, "bundleId");
+  return {
+    ...readScope(url),
+    window,
+    ...(bundleId === undefined
+      ? {}
+      : { bundleId: readId(url, "bundleId", 1_024) }),
+  };
+};

package/src/insights/routes.ts

@@ -0,0 +1,104 @@
+import type { RouteHandler } from "../handlerTypes";
+import {
+  InsightsBadRequestError,
+  InsightsPayloadTooLargeError,
+} from "./errors";
+import { parseBundleEventRequest } from "./eventInput";
+import {
+  parseReportingOverviewInput,
+  parseEventPageInput,
+  parseUserInstallationPageInput,
+} from "./queryInput";
+import type { InsightsProvider } from "./types";
+
+const json = (body: unknown, status: number): Response =>
+  Response.json(body, {
+    headers: { "cache-control": "private, no-store" },
+    status,
+  });
+
+const requireParam = (
+  params: Readonly<Record<string, string>>,
+  key: string,
+): string => {
+  const value = params[key];
+  if (value === undefined || value.length === 0) {
+    throw new InsightsBadRequestError(`Missing route parameter: ${key}`);
+  }
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    throw new InsightsBadRequestError(`Invalid route parameter: ${key}`);
+  }
+};
+
+const run = async (operation: () => Promise<Response>): Promise<Response> => {
+  try {
+    return await operation();
+  } catch (error) {
+    if (error instanceof InsightsBadRequestError) {
+      return json({ error: error.message }, 400);
+    }
+    if (error instanceof InsightsPayloadTooLargeError) {
+      return json({ error: error.message }, 413);
+    }
+    throw error;
+  }
+};
+
+const query = (operation: () => Promise<unknown>): Promise<Response> =>
+  run(async () => json(await operation(), 200));
+
+export const createInsightsRouteHandlers = (
+  provider: InsightsProvider,
+): Record<string, RouteHandler> => ({
+  appendBundleEvent: async (_params, request) =>
+    run(async () => {
+      await provider.appendBundleEvent(await parseBundleEventRequest(request));
+      return new Response(null, { status: 204 });
+    }),
+  getReportingOverview: (_params, request) =>
+    query(() =>
+      provider.getReportingOverview(parseReportingOverviewInput(request)),
+    ),
+  getInstallation: (params) =>
+    run(async () => {
+      const installation = await provider.getInstallation({
+        installId: requireParam(params, "installId"),
+      });
+      return installation === null
+        ? json({ error: "Installation not found" }, 404)
+        : json(installation, 200);
+    }),
+  listEvents: (_params, request) =>
+    query(() => provider.listEvents(parseEventPageInput(request))),
+  listInstallationEvents: (params, request) =>
+    query(() =>
+      provider.listInstallationEvents({
+        ...parseEventPageInput(request),
+        installId: requireParam(params, "installId"),
+      }),
+    ),
+  pageInstallationsByCurrentUserId: (_params, request) =>
+    query(() =>
+      provider.pageInstallationsByCurrentUserId(
+        parseUserInstallationPageInput(request),
+      ),
+    ),
+});
+
+export const registerInsightsClientRoutes = (
+  add: (method: string, path: string, handler: string) => void,
+): void => {
+  add("POST", "/events", "appendBundleEvent");
+};
+
+export const registerInsightsAdminRoutes = (
+  add: (method: string, path: string, handler: string) => void,
+): void => {
+  add("GET", "/events", "listEvents");
+  add("GET", "/overview", "getReportingOverview");
+  add("GET", "/installations", "pageInstallationsByCurrentUserId");
+  add("GET", "/installations/:installId/events", "listInstallationEvents");
+  add("GET", "/installations/:installId", "getInstallation");
+};

package/src/insights/types.ts

@@ -0,0 +1,55 @@
+import type {
+  ReportingOverview,
+  InsightsBundleSelection,
+  InsightsScope,
+  ActiveInstallationWindow,
+  CreateBundleEventRequest,
+  CursorPage,
+  EventCursorPage,
+  EventHistoryRow,
+  InstallationHistoryRow,
+  InstallationRow,
+} from "./domain";
+
+export type InsightsEventPageInput = {
+  readonly beforeReceivedAtMs?: number;
+  readonly sinceMs?: number;
+  readonly bundle?: InsightsBundleSelection;
+  readonly cursor?: string;
+  readonly limit?: number;
+};
+
+export type InsightsInstallationEventPageInput = Omit<
+  InsightsEventPageInput,
+  "bundle"
+> & {
+  readonly installId: string;
+};
+
+export type InsightsUserInstallationPageInput = {
+  readonly userId: string;
+  readonly cursor?: string;
+  readonly limit?: number;
+};
+
+export type InsightsProvider = {
+  appendBundleEvent(input: CreateBundleEventRequest): Promise<void>;
+  listEvents(
+    input: InsightsEventPageInput,
+  ): Promise<EventCursorPage<EventHistoryRow>>;
+  listInstallationEvents(
+    input: InsightsInstallationEventPageInput,
+  ): Promise<EventCursorPage<InstallationHistoryRow>>;
+  getInstallation(input: {
+    readonly installId: string;
+  }): Promise<InstallationRow | null>;
+  pageInstallationsByCurrentUserId(
+    input: InsightsUserInstallationPageInput,
+  ): Promise<CursorPage<InstallationRow>>;
+  getReportingOverview(
+    input: InsightsScope & {
+      readonly window: ActiveInstallationWindow;
+      readonly bundleId?: string;
+    },
+  ): Promise<ReportingOverview>;
+};

package/src/schema/dsl-all-versions.spec.ts

@@ -4,6 +4,7 @@ import { hotUpdaterSchemaVersions } from "./index";
 import { createSettingsTable } from "./settings";
 import {
   bundlePatchesV100,
+  bundleInstallationsV100,
   bundlesV100,
   channelsV100,
   releaseCatalogsV100,
@@ -17,6 +18,7 @@ describe("versioned schema DSL", () => {
     expect(channelsV100.dsl).toBe("table");
     expect(bundlesV100.dsl).toBe("table");
     expect(bundlePatchesV100.dsl).toBe("table");
+    expect(bundleInstallationsV100.dsl).toBe("table");
     expect(releasesV100.dsl).toBe("table");
     expect(releaseCatalogsV100.dsl).toBe("table");
     expect(createSettingsTable("1.0.0").dsl).toBe("table");
@@ -27,7 +29,7 @@ describe("versioned schema DSL", () => {
     }
   });
 
-  it("registers only schema 1.0.0", () => {
+  it("registers only the initial schema 1.0.0", () => {
     expect(hotUpdaterSchemaVersions.map((item) => item.version)).toEqual([
       "1.0.0",
     ]);

package/src/schema/v1_0_0.spec.ts

@@ -7,6 +7,7 @@ import {
 } from "../db/schemaGenerators";
 import {
   bundleEventsV100,
+  bundleInstallationsV100,
   bundlePatchesV100,
   bundlesV100,
   releaseCatalogsV100,
@@ -57,7 +58,7 @@ describe("v1.0.0 Release Catalog schema", () => {
     const patchSize = bundlePatchesV100.columns.find(
       ({ ormName }) => ormName === "byte_size",
     );
-    const sql = createTableSql("postgresql").join("\n");
+    const sql = createTableSql("postgresql", "foreign-keys", v1_0_0).join("\n");
     const prisma = generatePrismaSchema("postgresql", v1_0_0);
     const drizzle = generateDrizzleSchema("postgresql", v1_0_0);
 
@@ -96,6 +97,79 @@ describe("v1.0.0 Release Catalog schema", () => {
     ).toBeUndefined();
   });
 
+  it("stores one current row per installation with the required lookup indexes", () => {
+    expect(
+      bundleInstallationsV100.columns.find(
+        ({ ormName }) => ormName === "install_id",
+      )?.primaryKey,
+    ).toBe(true);
+    expect(bundleInstallationsV100.indexes).toEqual(
+      expect.arrayContaining([
+        {
+          columns: ["user_id", "install_id"],
+          name: "bundle_installations_user_id_idx",
+        },
+        {
+          columns: ["received_at_ms"],
+          name: "bundle_installations_received_at_idx",
+        },
+      ]),
+    );
+
+    const sql = createTableSql("postgresql", "foreign-keys", v1_0_0).join("\n");
+    const prisma = generatePrismaSchema("postgresql", v1_0_0);
+    const drizzle = generateDrizzleSchema("postgresql", v1_0_0);
+    expect(sql).toContain("create table bundle_installations");
+    expect(sql).toContain(
+      'install_id varchar(255) collate "C" primary key not null',
+    );
+    expect(sql).toContain(
+      "create index bundle_installations_user_id_idx on bundle_installations(user_id, install_id)",
+    );
+    expect(sql).toContain(
+      "create index bundle_installations_received_at_idx on bundle_installations(received_at_ms)",
+    );
+    expect(sql).toContain(
+      "create index bundle_installations_bundle_idx on bundle_installations(platform, channel, to_bundle_id, received_at_ms)",
+    );
+    expect(sql).toContain(
+      "create index bundle_events_from_bundle_idx on bundle_events(type, platform, channel, from_bundle_id, received_at_ms, id)",
+    );
+    expect(prisma).toContain("initial Prisma SQL migration");
+    expect(prisma).toContain(
+      'alter table bundle_installations alter column install_id type varchar(255) collate "C"',
+    );
+    expect(prisma).toContain("model bundle_installations {");
+    expect(prisma).toContain("install_id String @db.VarChar(255) @id");
+    expect(drizzle).toContain("export const bundle_installations = pgTable(");
+    expect(drizzle).toContain(
+      'index("bundle_installations_user_id_idx").on(table.user_id, table.install_id)',
+    );
+  });
+
+  it("keeps identity indexes valid on MySQL and MSSQL", () => {
+    const mysql = createTableSql("mysql", "foreign-keys", v1_0_0).join("\n");
+    const mssql = createTableSql("mssql", "foreign-keys", v1_0_0).join("\n");
+
+    expect(mysql).toContain(
+      "install_id varchar(255) character set utf8mb4 collate utf8mb4_0900_bin not null",
+    );
+    expect(mysql).toContain("user_id varchar(255)");
+    expect(mssql).toContain("install_id nvarchar(255) not null");
+    expect(mssql).toContain("user_id nvarchar(255)");
+
+    for (const sql of [mysql, mssql]) {
+      expect(sql).toContain(
+        "create index bundle_events_install_idx on bundle_events(install_id, type, received_at_ms, id)",
+      );
+      expect(sql).toContain(
+        "create index bundle_installations_user_id_idx on bundle_installations(user_id, install_id)",
+      );
+    }
+    expect(mssql).not.toContain("install_id nvarchar(max)");
+    expect(mssql).not.toContain("user_id nvarchar(max)");
+  });
+
   it("generates nullable source and artifact relations with the intended deletion rules", () => {
     const prisma = generatePrismaSchema("postgresql", v1_0_0);
     const drizzle = generateDrizzleSchema("postgresql", v1_0_0);
@@ -111,7 +185,7 @@ describe("v1.0.0 Release Catalog schema", () => {
   });
 
   it("creates both projection tables and their constraints from empty", () => {
-    const sql = createTableSql("postgresql").join("\n");
+    const sql = createTableSql("postgresql", "foreign-keys", v1_0_0).join("\n");
 
     expect(sql).toContain("create table releases");
     expect(sql).toContain("create table release_catalogs");
@@ -124,7 +198,7 @@ describe("v1.0.0 Release Catalog schema", () => {
   });
 
   it("uses byte-bounded MySQL catalog keys", () => {
-    const sql = createTableSql("mysql").join("\n");
+    const sql = createTableSql("mysql", "foreign-keys", v1_0_0).join("\n");
 
     expect(sql).toContain(
       "scope_key varchar(2048) character set ascii collate ascii_bin",

package/src/schema/v1_0_0.ts

@@ -366,21 +366,37 @@ export const releaseCatalogsV100 = table(
   },
 );
 
+const insightsTextCollations = {
+  postgresql: '"C"',
+  mysql: "utf8mb4_0900_bin",
+} as const;
+const insightsProviders = [
+  "postgresql",
+  "mysql",
+  "sqlite",
+  "cockroachdb",
+  "mongodb",
+] as const;
+
 export const bundleEventsV100 = table(
   "bundle_events",
   {
     id: idColumn("id", "uuid"),
-    type: stringColumn("type"),
-    install_id: stringColumn("install_id"),
-    user_id: stringColumn("user_id").nullable(),
+    type: column("type", varchar(32)),
+    install_id: column("install_id", varchar(255)).collate(
+      insightsTextCollations,
+    ),
+    user_id: column("user_id", varchar(255))
+      .collate(insightsTextCollations)
+      .nullable(),
     username: stringColumn("username").nullable(),
     from_release_id: uuid("from_release_id").nullable(),
     from_bundle_id: uuid("from_bundle_id").nullable(),
     to_release_id: uuid("to_release_id").nullable(),
     to_bundle_id: uuid("to_bundle_id"),
-    platform: stringColumn("platform"),
+    platform: stringColumn("platform").collate(insightsTextCollations),
     app_version: stringColumn("app_version"),
-    channel: stringColumn("channel"),
+    channel: stringColumn("channel").collate(insightsTextCollations),
     cohort: stringColumn("cohort"),
     update_strategy: stringColumn("update_strategy").nullable(),
     fingerprint_hash: stringColumn("fingerprint_hash").nullable(),
@@ -392,35 +408,27 @@ export const bundleEventsV100 = table(
       index("bundle_events_received_at_idx", ["received_at_ms", "id"]),
       index("bundle_events_install_idx", [
         "install_id",
-        "received_at_ms",
-        "id",
-      ]),
-      index("bundle_events_user_id_idx", ["user_id", "received_at_ms", "id"]),
-      index("bundle_events_username_idx", ["username", "received_at_ms", "id"]),
-      index("bundle_events_to_bundle_idx", [
-        "type",
-        "to_bundle_id",
-        "received_at_ms",
-        "id",
-      ]),
-      index("bundle_events_from_bundle_idx", [
-        "type",
-        "from_bundle_id",
-        "received_at_ms",
-        "id",
-      ]),
-      index("bundle_events_to_release_idx", [
         "type",
-        "to_release_id",
-        "received_at_ms",
-        "id",
-      ]),
-      index("bundle_events_from_release_idx", [
-        "type",
-        "from_release_id",
         "received_at_ms",
         "id",
       ]),
+      index(
+        "bundle_events_from_bundle_idx",
+        [
+          "type",
+          "platform",
+          "channel",
+          "from_bundle_id",
+          "received_at_ms",
+          "id",
+        ],
+        insightsProviders,
+      ),
+      index(
+        "bundle_events_to_bundle_idx",
+        ["type", "platform", "channel", "to_bundle_id", "received_at_ms", "id"],
+        insightsProviders,
+      ),
     ],
     checks: [
       check({
@@ -449,6 +457,61 @@ export const bundleEventsV100 = table(
   },
 );
 
+export const bundleInstallationsV100 = table(
+  "bundle_installations",
+  {
+    install_id: idColumn("install_id", varchar(255)).collate(
+      insightsTextCollations,
+    ),
+    id: uuid("id"),
+    user_id: column("user_id", varchar(255))
+      .collate(insightsTextCollations)
+      .nullable(),
+    username: stringColumn("username").nullable(),
+    to_bundle_id: uuid("to_bundle_id"),
+    type: column("type", varchar(32)),
+    platform: stringColumn("platform").collate(insightsTextCollations),
+    app_version: stringColumn("app_version"),
+    channel: stringColumn("channel").collate(insightsTextCollations),
+    cohort: stringColumn("cohort"),
+    received_at_ms: float("received_at_ms"),
+  },
+  {
+    indexes: [
+      index("bundle_installations_user_id_idx", ["user_id", "install_id"]),
+      index("bundle_installations_received_at_idx", ["received_at_ms"]),
+      index(
+        "bundle_installations_scope_idx",
+        ["platform", "channel", "received_at_ms"],
+        insightsProviders,
+      ),
+      index(
+        "bundle_installations_bundle_idx",
+        ["platform", "channel", "to_bundle_id", "received_at_ms"],
+        insightsProviders,
+      ),
+    ],
+    checks: [
+      check({
+        name: "bundle_installations_type_check",
+        expression:
+          "type in ('UPDATE_APPLIED', 'RECOVERED', 'RELEASE_ADOPTED', 'UNCHANGED')",
+        sqliteInline: true,
+      }),
+      check({
+        name: "bundle_installations_platform_check",
+        expression: "platform in ('ios', 'android')",
+        sqliteInline: true,
+      }),
+      check({
+        name: "bundle_installations_received_at_check",
+        expression: "received_at_ms >= 0",
+        sqliteInline: true,
+      }),
+    ],
+  },
+);
+
 export const v1_0_0 = schema({
   version: "1.0.0",
   settingsTable: HOT_UPDATER_SETTINGS_TABLE,
@@ -459,6 +522,7 @@ export const v1_0_0 = schema({
     releasesV100,
     releaseCatalogsV100,
     bundleEventsV100,
+    bundleInstallationsV100,
     apiKeysV100,
     createSettingsTable("1.0.0"),
   ],

package/dist/analytics/bounded/activeOverview.cjs

@@ -1,87 +0,0 @@
-//#region src/analytics/bounded/activeOverview.ts
-const HOUR_MS = 3600 * 1e3;
-const DAY_MS = 24 * HOUR_MS;
-const ACTIVE_BUNDLE_EVENT_TYPES = [
-	"UPDATE_APPLIED",
-	"RECOVERED",
-	"RELEASE_ADOPTED",
-	"UNCHANGED"
-];
-const 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(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(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(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(left.bundleId, right.bundleId))
-	};
-}
-//#endregion
-exports.ACTIVE_BUNDLE_EVENT_TYPES = ACTIVE_BUNDLE_EVENT_TYPES;
-exports.collectActiveInstallationOverview = collectActiveInstallationOverview;
-exports.getActiveWindowDefinition = getActiveWindowDefinition;