@iann29/rastro 0.1.0-alpha.5 → 0.1.0-alpha.7

package/src/component/ingest.ts

@@ -24,6 +24,7 @@ import {
   REPORT_ROLLUP_SHARDS,
   SECONDARY_AGGREGATE_SHARDS,
   SITE_INGEST_SHARDS,
+  VITAL_PAGE_SLOTS,
 } from "./constants.js";
 import {
   addVisitor,
@@ -31,6 +32,15 @@ import {
   unionVisitorSketches,
   type VisitorSketch,
 } from "./cardinality.js";
+import {
+  addToVitalHistogram,
+  emptyVitalHistogram,
+  mergeVitalHistograms,
+  vitalDevice,
+  VITAL_ALL,
+  VITAL_OTHER_PAGES,
+  type VitalMetric,
+} from "./vitals.js";
 import { fail } from "./errors.js";
 import { ensureAnalyticsControl } from "./coverage.js";
 import {
@@ -111,11 +121,14 @@ type FunnelRollupDelta = {
   funnelId: Id<"funnels">;
   bucketStart: number;
   shard: number;
-  steps: Map<number, {
-    step: number;
-    entrants: number;
-    completions: number;
-  }>;
+  steps: Map<
+    number,
+    {
+      step: number;
+      entrants: number;
+      completions: number;
+    }
+  >;
 };
 type AffiliateRollupDelta = {
   siteId: Id<"sites">;
@@ -129,10 +142,22 @@ type AffiliateRollupDelta = {
   revenueCents: number;
   commissionCents: number;
 };
+type VitalRollupDelta = {
+  siteId: Id<"sites">;
+  bucketStart: number;
+  device: string;
+  page: string;
+  shard: number;
+  metrics: Map<
+    VitalMetric,
+    { count: number; sum: number; histogram: number[] }
+  >;
+};
 type ReportRollupDeltas = {
   goals: Map<string, GoalRollupDelta>;
   funnels: Map<string, FunnelRollupDelta>;
   affiliates: Map<string, AffiliateRollupDelta>;
+  vitals: Map<string, VitalRollupDelta>;
 };
 type AttributionSnapshot = {
   affiliateId: Id<"affiliates">;
@@ -175,8 +200,9 @@ type CachedRow<T> = {
   dirty: boolean;
 };
 
-type CachedDocument<TableName extends keyof import("./_generated/dataModel.js").DataModel> =
-  Omit<Doc<TableName>, "_creationTime"> & { _creationTime?: number };
+type CachedDocument<
+  TableName extends keyof import("./_generated/dataModel.js").DataModel,
+> = Omit<Doc<TableName>, "_creationTime"> & { _creationTime?: number };
 
 type BatchState = {
   sessions: Map<string, CachedRow<CachedDocument<"sessions">>>;
@@ -207,13 +233,20 @@ export const ingestBatch = mutation({
       });
     }
     if (args.events.length < 1 || args.events.length > MAX_BATCH_EVENTS) {
-      fail("BATCH_TOO_LARGE", `events must contain 1-${MAX_BATCH_EVENTS} items`, {
-        limit: MAX_BATCH_EVENTS,
-      });
+      fail(
+        "BATCH_TOO_LARGE",
+        `events must contain 1-${MAX_BATCH_EVENTS} items`,
+        {
+          limit: MAX_BATCH_EVENTS,
+        },
+      );
     }
     let eventByteCounts: number[];
     try {
-      ({ eventByteCounts } = measureBatchBytes(String(args.siteId), args.events));
+      ({ eventByteCounts } = measureBatchBytes(
+        String(args.siteId),
+        args.events,
+      ));
     } catch {
       fail("BATCH_TOO_LARGE", "batch exceeds 64 KiB", { limitBytes: 65_536 });
     }
@@ -264,7 +297,7 @@ export const ingestBatch = mutation({
       const bucketStart = eventBucketStart(event.timestamp);
       const groupKey = eventBatchKey(event.sessionId, bucketStart);
       requestGroups.add(groupKey);
-      if (event.type === "heartbeat") continue;
+      if (event.type === "heartbeat" || event.type === "vital") continue;
       const eventIds = eventIdsByGroup.get(groupKey) ?? new Set<string>();
       if (eventIds.has(event.eventId)) {
         duplicateInBatch.add(eventIndex);
@@ -295,8 +328,8 @@ export const ingestBatch = mutation({
           sessionId: group.sessionId,
           bucketStart: group.bucketStart,
         });
-        const newCount = [...group.eventIds].filter((eventId) =>
-          !eventIds.has(eventId)
+        const newCount = [...group.eventIds].filter(
+          (eventId) => !eventIds.has(eventId),
         ).length;
         if (
           newCount > 0 &&
@@ -335,12 +368,7 @@ export const ingestBatch = mutation({
           continue;
         }
         const liveSession = (
-          await loadLiveSession(
-            ctx,
-            args.siteId,
-            event.sessionId,
-            batchState,
-          )
+          await loadLiveSession(ctx, args.siteId, event.sessionId, batchState)
         ).current;
         if (
           liveSession &&
@@ -376,10 +404,42 @@ export const ingestBatch = mutation({
         continue;
       }
 
+      if (event.type === "vital") {
+        // A vital annotates telemetry its session already produced; it never
+        // creates sessions, live presence, event batches, or aggregate counts.
+        if (!existingSession) {
+          rejected += 1;
+          continue;
+        }
+        if (
+          !(await consumeRateLimit(
+            ctx,
+            args.siteId,
+            event.sessionId,
+            eventByteCounts[eventIndex],
+            now,
+            sessionRateWindows,
+          ))
+        ) {
+          rejected += 1;
+          continue;
+        }
+        foldVitalRollups(
+          reportRollupDeltas,
+          args.siteId,
+          event,
+          vitalDevice(context.device),
+        );
+        accepted += 1;
+        continue;
+      }
+
       if (
         duplicateInBatch.has(eventIndex) ||
         persistedEventIds
-          .get(eventBatchKey(event.sessionId, eventBucketStart(event.timestamp)))
+          .get(
+            eventBatchKey(event.sessionId, eventBucketStart(event.timestamp)),
+          )
           ?.has(event.eventId)
       ) {
         duplicates += 1;
@@ -418,8 +478,8 @@ export const ingestBatch = mutation({
         event,
         context,
         existingSession,
-        goals: canMatchDefinition ? goals ?? [] : [],
-        funnels: canMatchDefinition ? funnels ?? [] : [],
+        goals: canMatchDefinition ? (goals ?? []) : [],
+        funnels: canMatchDefinition ? (funnels ?? []) : [],
         aggregateDeltas,
         reportRollupDeltas,
         recordTelemetry: true,
@@ -451,7 +511,10 @@ export const trackConversion = mutation({
     const site = await ctx.db.get("sites", args.siteId);
     if (!site) fail("NOT_FOUND", "site not found");
     if (!isValidMoney(args.revenueCents)) {
-      fail("INVALID_ARGUMENT", "revenueCents must be an integer between 0 and 1000000000");
+      fail(
+        "INVALID_ARGUMENT",
+        "revenueCents must be an integer between 0 and 1000000000",
+      );
     }
     let event: TrackerEvent;
     let trustedGoalKey: string | undefined;
@@ -476,7 +539,10 @@ export const trackConversion = mutation({
         Date.now(),
       );
     } catch (error) {
-      fail("INVALID_ARGUMENT", error instanceof Error ? error.message : "invalid conversion");
+      fail(
+        "INVALID_ARGUMENT",
+        error instanceof Error ? error.message : "invalid conversion",
+      );
     }
 
     const siteCurrency = site.currency ?? "USD";
@@ -496,10 +562,14 @@ export const trackConversion = mutation({
       return { accepted: 0, duplicates: 1, rejected: 0 };
     }
     if (event.currency !== siteCurrency) {
-      fail("CURRENCY_MISMATCH", "conversion currency does not match site currency", {
-        siteCurrency,
-        conversionCurrency: event.currency ?? "USD",
-      });
+      fail(
+        "CURRENCY_MISMATCH",
+        "conversion currency does not match site currency",
+        {
+          siteCurrency,
+          conversionCurrency: event.currency ?? "USD",
+        },
+      );
     }
 
     const telemetry = await findTelemetry(ctx, args.siteId, event);
@@ -659,11 +729,7 @@ async function flushBatchState(ctx: MutationCtx, batchState: BatchState) {
 function withoutSystemFields<
   T extends { _id: unknown; _creationTime?: number },
 >(document: T): Omit<T, "_id" | "_creationTime"> {
-  const {
-    _id,
-    _creationTime,
-    ...fields
-  } = document;
+  const { _id, _creationTime, ...fields } = document;
   void _id;
   void _creationTime;
   return fields;
@@ -702,8 +768,8 @@ async function accountEvent(
     : await accountTrustedSession(ctx, input.existingSession, event);
 
   const matchedGoalKeys: string[] = [];
-  const matchingGoals = input.goals.filter((goal) =>
-    goal.active && goalMatches(goal, event)
+  const matchingGoals = input.goals.filter(
+    (goal) => goal.active && goalMatches(goal, event),
   );
   if (matchingGoals.length > 1) {
     fail("LIMIT_EXCEEDED", "active goals must use unique matchers");
@@ -714,33 +780,36 @@ async function accountEvent(
       eventBucketStart(event.timestamp),
       event.eventId,
     ]);
-    const scopedPrior = (await ctx.db
-      .query("goalCompletions")
-      .withIndex("by_siteId_and_goalId_and_eventId", (range) =>
-        range
-          .eq("siteId", input.siteId)
-          .eq("goalId", goal._id)
-          .eq("eventId", completionEventId),
-      )
-      .take(2))
-      .find((completion) => completion.idempotencyVersion === 2);
+    const scopedPrior = (
+      await ctx.db
+        .query("goalCompletions")
+        .withIndex("by_siteId_and_goalId_and_eventId", (range) =>
+          range
+            .eq("siteId", input.siteId)
+            .eq("goalId", goal._id)
+            .eq("eventId", completionEventId),
+        )
+        .take(2)
+    ).find((completion) => completion.idempotencyVersion === 2);
     const legacyPrior = scopedPrior
       ? undefined
-      : (await ctx.db
-          .query("goalCompletions")
-          .withIndex("by_siteId_and_goalId_and_eventId", (range) =>
-            range
-              .eq("siteId", input.siteId)
-              .eq("goalId", goal._id)
-              .eq("eventId", event.eventId),
-          )
-          .take(2))
-          .find((completion) =>
+      : (
+          await ctx.db
+            .query("goalCompletions")
+            .withIndex("by_siteId_and_goalId_and_eventId", (range) =>
+              range
+                .eq("siteId", input.siteId)
+                .eq("goalId", goal._id)
+                .eq("eventId", event.eventId),
+            )
+            .take(2)
+        ).find(
+          (completion) =>
             completion.idempotencyVersion === undefined &&
             completion.sessionId === event.sessionId &&
             eventBucketStart(completion.timestamp) ===
-              eventBucketStart(event.timestamp)
-          );
+              eventBucketStart(event.timestamp),
+        );
     if (scopedPrior || legacyPrior) continue;
     await ctx.db.insert("goalCompletions", {
       siteId: input.siteId,
@@ -753,12 +822,7 @@ async function accountEvent(
       timestamp: event.timestamp,
       valueCents: goal.valueCents ?? 0,
     });
-    foldGoalRollup(
-      input.reportRollupDeltas,
-      input.siteId,
-      event,
-      goal,
-    );
+    foldGoalRollup(input.reportRollupDeltas, input.siteId, event, goal);
     matchedGoalKeys.push(goal.key);
   }
 
@@ -798,7 +862,7 @@ async function accountEvent(
     { type: "browser", value: input.context.browser ?? "Other" },
     {
       type: "event",
-      value: event.type === "custom" ? event.name ?? "custom" : event.type,
+      value: event.type === "custom" ? (event.name ?? "custom") : event.type,
     },
     ...matchedGoalKeys.map((value): Dimension => ({ type: "goal", value })),
   ];
@@ -908,15 +972,18 @@ async function upsertSession(
     const updates = {
       startedAt,
       lastSeenAt,
-      entryPath: event.timestamp < existing.startedAt ? event.path : existing.entryPath,
-      exitPath: event.timestamp >= existing.lastSeenAt ? event.path : existing.exitPath,
+      entryPath:
+        event.timestamp < existing.startedAt ? event.path : existing.entryPath,
+      exitPath:
+        event.timestamp >= existing.lastSeenAt ? event.path : existing.exitPath,
       eventCount: existing.eventCount + 1,
-      pageviewCount: existing.pageviewCount + (event.type === "pageview" ? 1 : 0),
+      pageviewCount:
+        existing.pageviewCount + (event.type === "pageview" ? 1 : 0),
       durationMs: Math.max(0, lastSeenAt - startedAt),
       conversionCount: existing.conversionCount + Number(financialConversion),
       revenueCents:
         existing.revenueCents +
-        (financialConversion ? event.revenueCents ?? 0 : 0),
+        (financialConversion ? (event.revenueCents ?? 0) : 0),
       ...(financialConversion && event.currency
         ? { currency: event.currency }
         : {}),
@@ -927,7 +994,9 @@ async function upsertSession(
       ...(context.country ? { country: context.country } : {}),
       ...(context.city ? { city: context.city } : {}),
       ...(context.latitude !== undefined ? { latitude: context.latitude } : {}),
-      ...(context.longitude !== undefined ? { longitude: context.longitude } : {}),
+      ...(context.longitude !== undefined
+        ? { longitude: context.longitude }
+        : {}),
       browser: context.browser ?? existing.browser,
       os: context.os ?? existing.os,
       device: context.device ?? existing.device,
@@ -1000,7 +1069,9 @@ async function upsertSession(
     ...(context.country ? { country: context.country } : {}),
     ...(context.city ? { city: context.city } : {}),
     ...(context.latitude !== undefined ? { latitude: context.latitude } : {}),
-    ...(context.longitude !== undefined ? { longitude: context.longitude } : {}),
+    ...(context.longitude !== undefined
+      ? { longitude: context.longitude }
+      : {}),
     browser: context.browser ?? "Other",
     os: context.os ?? "Other",
     device: context.device ?? "unknown",
@@ -1008,7 +1079,7 @@ async function upsertSession(
     pageviewCount: event.type === "pageview" ? 1 : 0,
     durationMs: 0,
     conversionCount: Number(financialConversion),
-    revenueCents: financialConversion ? event.revenueCents ?? 0 : 0,
+    revenueCents: financialConversion ? (event.revenueCents ?? 0) : 0,
     ...(financialConversion && event.currency
       ? { currency: event.currency }
       : {}),
@@ -1056,14 +1127,12 @@ async function upsertSession(
   };
 }
 
-function attributionSnapshot(
-  value: {
-    affiliateId?: Id<"affiliates">;
-    affiliateSlug?: string;
-    affiliateAttributedAt?: number;
-    affiliateExpiresAt?: number;
-  },
-): AttributionSnapshot | undefined {
+function attributionSnapshot(value: {
+  affiliateId?: Id<"affiliates">;
+  affiliateSlug?: string;
+  affiliateAttributedAt?: number;
+  affiliateExpiresAt?: number;
+}): AttributionSnapshot | undefined {
   if (
     !value.affiliateId ||
     !value.affiliateSlug ||
@@ -1080,7 +1149,6 @@ function attributionSnapshot(
   };
 }
 
-
 function attributionApplies(
   attribution: AttributionSnapshot,
   timestamp: number,
@@ -1211,14 +1279,15 @@ async function accountHeartbeat(
   const updates = {
     startedAt,
     lastSeenAt,
-    exitPath: event.timestamp >= session.lastSeenAt
-      ? event.path
-      : session.exitPath,
+    exitPath:
+      event.timestamp >= session.lastSeenAt ? event.path : session.exitPath,
     durationMs: Math.max(0, lastSeenAt - startedAt),
     ...(context.country ? { country: context.country } : {}),
     ...(context.city ? { city: context.city } : {}),
     ...(context.latitude !== undefined ? { latitude: context.latitude } : {}),
-    ...(context.longitude !== undefined ? { longitude: context.longitude } : {}),
+    ...(context.longitude !== undefined
+      ? { longitude: context.longitude }
+      : {}),
     browser: context.browser ?? session.browser,
     os: context.os ?? session.os,
     device: context.device ?? session.device,
@@ -1265,7 +1334,10 @@ async function consumeSiteRateLimit(
 ): Promise<void> {
   const windowStart =
     Math.floor(now / RATE_LIMIT_WINDOW_MS) * RATE_LIMIT_WINDOW_MS;
-  const increments = new Map<number, { eventCount: number; byteCount: number }>();
+  const increments = new Map<
+    number,
+    { eventCount: number; byteCount: number }
+  >();
   for (let index = 0; index < events.length; index += 1) {
     const event = events[index];
     const byteCount = eventByteCounts[index];
@@ -1290,9 +1362,8 @@ async function consumeSiteRateLimit(
       .order("desc")
       .take(1);
     const storedWindow = rows[0] ?? null;
-    const window = storedWindow?.windowStart === windowStart
-      ? storedWindow
-      : null;
+    const window =
+      storedWindow?.windowStart === windowStart ? storedWindow : null;
     if (
       (window?.eventCount ?? 0) + increment.eventCount >
         MAX_SITE_EVENTS_PER_SHARD_WINDOW ||
@@ -1304,10 +1375,8 @@ async function consumeSiteRateLimit(
         windowMs: RATE_LIMIT_WINDOW_MS,
         eventLimitPerShard: MAX_SITE_EVENTS_PER_SHARD_WINDOW,
         byteLimitPerShard: MAX_SITE_BYTES_PER_SHARD_WINDOW,
-        siteEventLimit:
-          SITE_INGEST_SHARDS * MAX_SITE_EVENTS_PER_SHARD_WINDOW,
-        siteByteLimit:
-          SITE_INGEST_SHARDS * MAX_SITE_BYTES_PER_SHARD_WINDOW,
+        siteEventLimit: SITE_INGEST_SHARDS * MAX_SITE_EVENTS_PER_SHARD_WINDOW,
+        siteByteLimit: SITE_INGEST_SHARDS * MAX_SITE_BYTES_PER_SHARD_WINDOW,
       });
     }
     windows.push({ shard, increment, window: storedWindow });
@@ -1348,7 +1417,8 @@ async function consumeRateLimit(
   now: number,
   states: Map<string, SessionRateWindowState>,
 ): Promise<boolean> {
-  const windowStart = Math.floor(now / RATE_LIMIT_WINDOW_MS) * RATE_LIMIT_WINDOW_MS;
+  const windowStart =
+    Math.floor(now / RATE_LIMIT_WINDOW_MS) * RATE_LIMIT_WINDOW_MS;
   let state = states.get(sessionId);
   if (!state) {
     const rows = await ctx.db
@@ -1386,7 +1456,8 @@ async function flushSessionRateLimits(
   states: Map<string, SessionRateWindowState>,
   now: number,
 ) {
-  const windowStart = Math.floor(now / RATE_LIMIT_WINDOW_MS) * RATE_LIMIT_WINDOW_MS;
+  const windowStart =
+    Math.floor(now / RATE_LIMIT_WINDOW_MS) * RATE_LIMIT_WINDOW_MS;
   for (const state of states.values()) {
     if (!state.dirty) continue;
     if (state.window) {
@@ -1436,15 +1507,16 @@ async function updateLiveSession(
   const latitude = context.latitude ?? session.latitude;
   const longitude = context.longitude ?? session.longitude;
   if (existing) {
-    const recentHeartbeatEventIds = event.type === "heartbeat"
-      ? [
-          ...(existing.recentHeartbeatEventIds ??
-            (existing.lastHeartbeatEventId
-              ? [existing.lastHeartbeatEventId]
-              : [])),
-          event.eventId,
-        ].slice(-8)
-      : undefined;
+    const recentHeartbeatEventIds =
+      event.type === "heartbeat"
+        ? [
+            ...(existing.recentHeartbeatEventIds ??
+              (existing.lastHeartbeatEventId
+                ? [existing.lastHeartbeatEventId]
+                : [])),
+            event.eventId,
+          ].slice(-8)
+        : undefined;
     const updates = {
       visitorId: event.visitorId,
       path: event.path,
@@ -1601,7 +1673,11 @@ async function advanceFunnel(
     foldFunnelRollup(reportRollupDeltas, siteId, funnel._id, event, 0, false);
     return;
   }
-  if (progress.completedAt !== undefined || event.timestamp < progress.lastStepAt) return;
+  if (
+    progress.completedAt !== undefined ||
+    event.timestamp < progress.lastStepAt
+  )
+    return;
   if (event.timestamp - progress.startedAt > funnel.conversionWindowMs) {
     if (!matchesFirst) return;
     const updated = {
@@ -1799,6 +1875,7 @@ function createReportRollupDeltas(): ReportRollupDeltas {
     goals: new Map(),
     funnels: new Map(),
     affiliates: new Map(),
+    vitals: new Map(),
   };
 }
 
@@ -1938,6 +2015,120 @@ function foldAffiliateConversionRollup(
   deltas.affiliates.set(coordinates.key, current);
 }
 
+function foldVitalRollups(
+  deltas: ReportRollupDeltas,
+  siteId: Id<"sites">,
+  event: TrackerEvent,
+  device: string,
+) {
+  const metric = event.name as VitalMetric;
+  const value = event.value ?? 0;
+  const bucketStart = Math.floor(event.timestamp / DAY_MS) * DAY_MS;
+  const shard = stableHash(event.sessionId) % REPORT_ROLLUP_SHARDS;
+  // Each measurement lands twice: on its page (across devices) and on its
+  // device class (across pages), so both breakdowns stay exact and bounded.
+  for (const target of [
+    { device: VITAL_ALL, page: event.path },
+    { device, page: VITAL_ALL },
+  ]) {
+    const key = JSON.stringify([
+      siteId,
+      bucketStart,
+      target.device,
+      target.page,
+      shard,
+    ]);
+    const row = deltas.vitals.get(key) ?? {
+      siteId,
+      bucketStart,
+      device: target.device,
+      page: target.page,
+      shard,
+      metrics: new Map<
+        VitalMetric,
+        { count: number; sum: number; histogram: number[] }
+      >(),
+    };
+    const entry = row.metrics.get(metric) ?? {
+      count: 0,
+      sum: 0,
+      histogram: emptyVitalHistogram(),
+    };
+    entry.count += 1;
+    entry.sum += value;
+    entry.histogram = addToVitalHistogram(entry.histogram, value);
+    row.metrics.set(metric, entry);
+    deltas.vitals.set(key, row);
+  }
+}
+
+async function upsertVitalRollup(ctx: MutationCtx, delta: VitalRollupDelta) {
+  const existing = await ctx.db
+    .query("vitalRollups")
+    .withIndex("by_key", (range) =>
+      range
+        .eq("siteId", delta.siteId)
+        .eq("bucketStart", delta.bucketStart)
+        .eq("device", delta.device)
+        .eq("page", delta.page)
+        .eq("shard", delta.shard),
+    )
+    .unique();
+  if (
+    !existing &&
+    delta.device === VITAL_ALL &&
+    delta.page !== VITAL_OTHER_PAGES
+  ) {
+    // A new page row spends one bounded read to respect the daily page slots;
+    // past the cap, the day's remaining pages fold into "(other)".
+    const pageRows = await ctx.db
+      .query("vitalRollups")
+      .withIndex("by_key", (range) =>
+        range
+          .eq("siteId", delta.siteId)
+          .eq("bucketStart", delta.bucketStart)
+          .eq("device", VITAL_ALL),
+      )
+      .take(VITAL_PAGE_SLOTS * REPORT_ROLLUP_SHARDS + 1);
+    if (pageRows.length > VITAL_PAGE_SLOTS * REPORT_ROLLUP_SHARDS) {
+      await upsertVitalRollup(ctx, { ...delta, page: VITAL_OTHER_PAGES });
+      return;
+    }
+  }
+  const metrics = existing?.metrics.map((entry) => ({ ...entry })) ?? [];
+  for (const [metric, addition] of delta.metrics) {
+    const entry = metrics.find((candidate) => candidate.metric === metric);
+    if (entry) {
+      entry.count += addition.count;
+      entry.sum += addition.sum;
+      entry.histogram = mergeVitalHistograms(
+        entry.histogram,
+        addition.histogram,
+      );
+    } else {
+      metrics.push({
+        metric,
+        count: addition.count,
+        sum: addition.sum,
+        histogram: [...addition.histogram],
+      });
+    }
+  }
+  const fields = {
+    siteId: delta.siteId,
+    bucketStart: delta.bucketStart,
+    device: delta.device,
+    page: delta.page,
+    shard: delta.shard,
+    metrics,
+  };
+  if (existing) {
+    await ctx.db.replace("vitalRollups", existing._id, fields);
+  } else {
+    await ctx.db.insert("vitalRollups", fields);
+  }
+}
+
 async function flushReportRollups(
   ctx: MutationCtx,
   deltas: ReportRollupDeltas,
@@ -2010,12 +2201,14 @@ async function flushReportRollups(
   for (const delta of deltas.affiliates.values()) {
     const existing = await ctx.db
       .query("affiliateDailyRollups")
-      .withIndex("by_siteId_and_affiliateId_and_bucketStart_and_shard", (range) =>
-        range
-          .eq("siteId", delta.siteId)
-          .eq("affiliateId", delta.affiliateId)
-          .eq("bucketStart", delta.bucketStart)
-          .eq("shard", delta.shard),
+      .withIndex(
+        "by_siteId_and_affiliateId_and_bucketStart_and_shard",
+        (range) =>
+          range
+            .eq("siteId", delta.siteId)
+            .eq("affiliateId", delta.affiliateId)
+            .eq("bucketStart", delta.bucketStart)
+            .eq("shard", delta.shard),
       )
       .unique();
     const fields = {
@@ -2032,8 +2225,7 @@ async function flushReportRollups(
       ),
       conversions: (existing?.conversions ?? 0) + delta.conversions,
       revenueCents: (existing?.revenueCents ?? 0) + delta.revenueCents,
-      commissionCents:
-        (existing?.commissionCents ?? 0) + delta.commissionCents,
+      commissionCents: (existing?.commissionCents ?? 0) + delta.commissionCents,
     };
     if (existing) {
       await ctx.db.replace("affiliateDailyRollups", existing._id, fields);
@@ -2041,6 +2233,9 @@ async function flushReportRollups(
       await ctx.db.insert("affiliateDailyRollups", fields);
     }
   }
+  for (const delta of deltas.vitals.values()) {
+    await upsertVitalRollup(ctx, delta);
+  }
 }
 
 function foldAggregates(
@@ -2052,16 +2247,15 @@ function foldAggregates(
   recordTelemetry: boolean,
   financialConversion: boolean,
 ) {
-  const revenueCents = financialConversion ? event.revenueCents ?? 0 : 0;
-  const dimensionDeltas = dimensions.map(
-    (dimension): DimensionDelta => ({
-      ...dimension,
-      count: Number(recordTelemetry),
-      revenueCents,
-    }),
-  );
+  const revenueCents = financialConversion ? (event.revenueCents ?? 0) : 0;
+  const dimensionDeltas = dimensions.map((dimension): DimensionDelta => ({
+    ...dimension,
+    count: Number(recordTelemetry),
+    revenueCents,
+  }));
   for (const granularity of ["hour", "day"] as const) {
-    const shard = stableHash(event.sessionId) %
+    const shard =
+      stableHash(event.sessionId) %
       (granularity === "hour" ? HOURLY_AGGREGATE_SHARDS : AGGREGATE_SHARDS);
     const interval = granularity === "hour" ? HOUR_MS : DAY_MS;
     const bucketStart = Math.floor(event.timestamp / interval) * interval;
@@ -2196,10 +2390,7 @@ function mergeDimensions(
       (candidate) => candidate.type === addition.type,
     );
     if (typeSlots.length < DIMENSION_SLOTS - 1) {
-      const occupied = Array.from(
-        { length: DIMENSION_SLOTS },
-        () => false,
-      );
+      const occupied = Array.from({ length: DIMENSION_SLOTS }, () => false);
       for (const candidate of typeSlots) occupied[candidate.slot] = true;
       let slot = stableHash(addition.value) % DIMENSION_SLOTS;
       while (occupied[slot]) slot = (slot + 1) % DIMENSION_SLOTS;
@@ -2251,5 +2442,7 @@ function stringProperty(
   key: string,
 ): string | undefined {
   const value = properties?.[key];
-  return typeof value === "string" ? cleanString(value, 120) || undefined : undefined;
+  return typeof value === "string"
+    ? cleanString(value, 120) || undefined
+    : undefined;
 }