@iann29/rastro 0.1.0-alpha.1 → 0.1.0-alpha.11

package/src/component/ingest.ts

@@ -10,6 +10,7 @@ import {
   HOURLY_AGGREGATE_SHARDS,
   DIMENSION_SLOTS,
   HOUR_MS,
+  LIVE_LEAVE_GRACE_MS,
   LIVE_SESSION_TTL_MS,
   LIVE_SWEEP_INTERVAL_MS,
   MAX_BATCH_EVENTS,
@@ -20,10 +21,25 @@ import {
   MAX_FUNNELS_PER_SITE,
   MAX_GOALS_PER_SITE,
   RATE_LIMIT_WINDOW_MS,
+  REPORT_ROLLUP_SHARDS,
   SECONDARY_AGGREGATE_SHARDS,
   SITE_INGEST_SHARDS,
 } from "./constants.js";
+import {
+  addVisitor,
+  createVisitorSketch,
+  unionVisitorSketches,
+  type VisitorSketch,
+} from "./cardinality.js";
+import {
+  addToVitalHistogram,
+  emptyVitalHistogram,
+  vitalDevice,
+  VITAL_ALL,
+  type VitalMetric,
+} from "./vitals.js";
 import { fail } from "./errors.js";
+import { ensureAnalyticsControl } from "./coverage.js";
 import {
   bufferEventBatch,
   eventBatchKey,
@@ -36,8 +52,9 @@ import {
 } from "./eventStore.js";
 import {
   cleanString,
-  ensureBatchBytes,
   isValidMoney,
+  measureBatchBytes,
+  normalizeRoute,
   originAllowed,
   sanitizeContext,
   sanitizeCurrency,
@@ -57,9 +74,18 @@ import {
   type IngestContext,
   type TrackerEvent,
 } from "./validators.js";
+import {
+  createReportRollupDeltas,
+  enqueueReportRollups,
+  reportRollupCoordinates,
+  type ReportRollupDeltas,
+  type RouteRollupDelta,
+} from "./rollupStore.js";
+import { localDayStart, localDayTimezone } from "./localTime.js";
 
 type DimensionType =
   | "source"
+  | "campaign"
   | "page"
   | "country"
   | "device"
@@ -68,10 +94,15 @@ type DimensionType =
   | "goal";
 
 type Dimension = { type: DimensionType; value: string };
-type DimensionDelta = Dimension & { count: number; revenueCents: number };
+type DimensionDelta = Dimension & {
+  count: number;
+  revenueCents: number;
+  pageviews: number;
+  sessions: number;
+};
 type AggregateDelta = {
   siteId: Id<"sites">;
-  granularity: "hour" | "day";
+  granularity: "hour" | "day" | "localDay";
   bucketStart: number;
   shard: number;
   events: number;
@@ -81,9 +112,13 @@ type AggregateDelta = {
   outboundClicks: number;
   sessions: number;
   visitors: number;
+  visitorSketch: VisitorSketch;
   conversions: number;
   revenueCents: number;
   dimensions: Doc<"aggregateBuckets">["dimensions"];
+  durationMs: number;
+  continuedSessions: number;
+  newVisitors: number;
 };
 type AggregateDeltas = Map<string, AggregateDelta>;
 type AttributionSnapshot = {
@@ -97,8 +132,20 @@ type SessionState = {
   isNewSession: boolean;
   isNewVisitorHour: boolean;
   isNewVisitorDay: boolean;
+  /** The session is new and its visitor has no earlier session or alias. */
+  isNewVisitor: boolean;
+  /** How much this event grew the session's duration. */
+  durationDeltaMs: number;
+  /** This event is the session's second pageview: it did not bounce. */
+  continued: boolean;
   startedAt: number;
   source: string;
+  visitorKey: string;
+  utmCampaign?: string;
+  country?: string;
+  city?: string;
+  latitude?: number;
+  longitude?: number;
   pageviewCount: number;
   eventCount: number;
   affiliateId?: Id<"affiliates">;
@@ -121,8 +168,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">>>;
@@ -153,25 +201,37 @@ 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 {
-      ensureBatchBytes({ siteId: String(args.siteId), events: args.events });
+      ({ eventByteCounts } = measureBatchBytes(
+        String(args.siteId),
+        args.events,
+      ));
     } catch {
       fail("BATCH_TOO_LARGE", "batch exceeds 64 KiB", { limitBytes: 65_536 });
     }
 
     const now = Date.now();
-    const eventByteCounts = await consumeSiteRateLimit(
+    await ensureAnalyticsControl(ctx, args.siteId, now);
+    await consumeSiteRateLimit(
       ctx,
       args.siteId,
       args.events,
+      eventByteCounts,
       now,
     );
     const context = sanitizeContext(args.context);
+    const timezone = localDayTimezone(site.timezone);
     const aggregateDeltas: AggregateDeltas = new Map();
+    const reportRollupDeltas = createReportRollupDeltas();
     const sessionRateWindows = new Map<string, SessionRateWindowState>();
     const batchState: BatchState = {
       sessions: new Map(),
@@ -206,7 +266,12 @@ 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" ||
+        event.type === "leave"
+      )
+        continue;
       const eventIds = eventIdsByGroup.get(groupKey) ?? new Set<string>();
       if (eventIds.has(event.eventId)) {
         duplicateInBatch.add(eventIndex);
@@ -236,10 +301,9 @@ export const ingestBatch = mutation({
           siteId: args.siteId,
           sessionId: group.sessionId,
           bucketStart: group.bucketStart,
-          candidateEventIds: group.eventIds,
         });
-        const newCount = [...group.eventIds].filter((eventId) =>
-          !eventIds.has(eventId)
+        const newCount = [...group.eventIds].filter(
+          (eventId) => !eventIds.has(eventId),
         ).length;
         if (
           newCount > 0 &&
@@ -278,12 +342,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 &&
@@ -306,7 +365,7 @@ export const ingestBatch = mutation({
           rejected += 1;
           continue;
         }
-        await accountHeartbeat(
+        const durationDeltaMs = await accountHeartbeat(
           ctx,
           args.siteId,
           existingSession,
@@ -315,6 +374,90 @@ export const ingestBatch = mutation({
           now,
           batchState,
         );
+        // A heartbeat is presence, not telemetry, but it is what keeps a
+        // session's duration honest while the visitor reads: the growth is
+        // folded into the buckets the heartbeat landed in.
+        foldSessionDuration(
+          aggregateDeltas,
+          args.siteId,
+          event,
+          durationDeltaMs,
+          timezone,
+        );
+        accepted += 1;
+        continue;
+      }
+
+      if (event.type === "leave") {
+        // A departure only shortens live presence: it stores no telemetry,
+        // touches no aggregates, and never extends anything, so a replayed
+        // or late leave is inert. The read side filters by expiresAt and the
+        // sweep deletes the row, so the dashboard sees the exit in seconds.
+        if (!existingSession) {
+          rejected += 1;
+          continue;
+        }
+        if (
+          !(await consumeRateLimit(
+            ctx,
+            args.siteId,
+            event.sessionId,
+            eventByteCounts[eventIndex],
+            now,
+            sessionRateWindows,
+          ))
+        ) {
+          rejected += 1;
+          continue;
+        }
+        const liveState = await loadLiveSession(
+          ctx,
+          args.siteId,
+          event.sessionId,
+          batchState,
+        );
+        const liveSession = liveState.current;
+        if (liveSession) {
+          const expiresAt = Math.min(
+            liveSession.expiresAt,
+            now + LIVE_LEAVE_GRACE_MS,
+          );
+          if (expiresAt < liveSession.expiresAt) {
+            await ctx.db.patch("liveSessions", liveSession._id, { expiresAt });
+            liveState.current = { ...liveSession, expiresAt };
+          }
+          await ensureLiveSweep(ctx, args.siteId, now, batchState);
+        }
+        accepted += 1;
+        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;
       }
@@ -322,7 +465,9 @@ export const ingestBatch = mutation({
       if (
         duplicateInBatch.has(eventIndex) ||
         persistedEventIds
-          .get(eventBatchKey(event.sessionId, eventBucketStart(event.timestamp)))
+          .get(
+            eventBatchKey(event.sessionId, eventBucketStart(event.timestamp)),
+          )
           ?.has(event.eventId)
       ) {
         duplicates += 1;
@@ -356,26 +501,34 @@ export const ingestBatch = mutation({
           .withIndex("by_siteId", (range) => range.eq("siteId", args.siteId))
           .take(MAX_FUNNELS_PER_SITE);
       }
-      await accountEvent(ctx, {
+      const session = await accountEvent(ctx, {
         siteId: args.siteId,
         event,
         context,
         existingSession,
-        goals: canMatchDefinition ? goals ?? [] : [],
-        funnels: canMatchDefinition ? funnels ?? [] : [],
+        goals: canMatchDefinition ? (goals ?? []) : [],
+        funnels: canMatchDefinition ? (funnels ?? []) : [],
         aggregateDeltas,
+        reportRollupDeltas,
         recordTelemetry: true,
+        timezone,
         financialConversion: false,
         trustedGoalKey: undefined,
         now,
         batchState,
       });
-      bufferEventBatch(args.siteId, event, batchState.eventBatches);
+      bufferEventBatch(
+        args.siteId,
+        event,
+        batchState.eventBatches,
+        session.country ?? "unknown",
+      );
       accepted += 1;
     }
     await flushBatchState(ctx, batchState);
     await flushSessionRateLimits(ctx, sessionRateWindows, now);
     await flushAggregates(ctx, aggregateDeltas);
+    await enqueueReportRollups(ctx, args.siteId, reportRollupDeltas, now);
     return { accepted, duplicates, rejected };
   },
 });
@@ -387,7 +540,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;
@@ -412,7 +568,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";
@@ -432,10 +591,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);
@@ -467,7 +630,8 @@ export const trackConversion = mutation({
     };
 
     const aggregateDeltas: AggregateDeltas = new Map();
-    await accountEvent(ctx, {
+    const reportRollupDeltas = createReportRollupDeltas();
+    const session = await accountEvent(ctx, {
       siteId: args.siteId,
       event,
       context: conversionContext,
@@ -475,15 +639,25 @@ export const trackConversion = mutation({
       goals: [],
       funnels: [],
       aggregateDeltas,
+      reportRollupDeltas,
       recordTelemetry: existingTelemetry === null && !telemetry.saturated,
+      timezone: localDayTimezone(site.timezone),
       financialConversion: true,
       trustedGoalKey,
       now: Date.now(),
     });
     if (!existingTelemetry && !telemetry.saturated) {
-      await insertEventBatch(ctx, args.siteId, event);
+      await insertEventBatch(
+        ctx,
+        args.siteId,
+        event,
+        session.country ?? "unknown",
+      );
     }
     await flushAggregates(ctx, aggregateDeltas);
+    const now = Date.now();
+    await enqueueReportRollups(ctx, args.siteId, reportRollupDeltas, now);
+    await ensureAnalyticsControl(ctx, args.siteId, now);
     return { accepted: 1, duplicates: 0, rejected: 0 };
   },
 });
@@ -586,11 +760,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;
@@ -606,13 +776,16 @@ async function accountEvent(
     goals: Doc<"goals">[];
     funnels: Doc<"funnels">[];
     aggregateDeltas: AggregateDeltas;
+    reportRollupDeltas: ReportRollupDeltas;
     recordTelemetry: boolean;
+    /** The site's timezone when it keeps local-day buckets. */
+    timezone?: string;
     financialConversion: boolean;
     trustedGoalKey: string | undefined;
     now: number;
     batchState?: BatchState;
   },
-) {
+): Promise<SessionState> {
   const { event } = input;
   const session = input.recordTelemetry
     ? await upsertSession(
@@ -622,13 +795,25 @@ async function accountEvent(
         input.context,
         input.existingSession,
         input.financialConversion,
+        input.reportRollupDeltas,
         input.batchState,
       )
     : await accountTrustedSession(ctx, input.existingSession, event);
+  if (input.recordTelemetry && event.type === "pageview") {
+    // `existingSession` is the snapshot from before `upsertSession`, so it
+    // still carries the route the visitor is leaving.
+    foldRouteRollups(
+      input.reportRollupDeltas,
+      input.siteId,
+      event,
+      session,
+      input.existingSession,
+    );
+  }
 
   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");
@@ -639,33 +824,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,
@@ -678,12 +866,20 @@ async function accountEvent(
       timestamp: event.timestamp,
       valueCents: goal.valueCents ?? 0,
     });
+    foldGoalRollup(input.reportRollupDeltas, input.siteId, event, goal);
     matchedGoalKeys.push(goal.key);
   }
 
   for (const funnel of input.funnels) {
     if (funnel.active) {
-      await advanceFunnel(ctx, input.siteId, funnel, event, input.batchState);
+      await advanceFunnel(
+        ctx,
+        input.siteId,
+        funnel,
+        event,
+        input.reportRollupDeltas,
+        input.batchState,
+      );
     }
   }
 
@@ -694,18 +890,23 @@ async function accountEvent(
       session,
       event,
       input.trustedGoalKey,
+      input.reportRollupDeltas,
     );
   }
 
+  const campaignDimensions: Dimension[] = session.utmCampaign
+    ? [{ type: "campaign", value: session.utmCampaign }]
+    : [];
   const dimensions: Dimension[] = [
     { type: "source", value: session.source },
+    ...campaignDimensions,
     { type: "page", value: event.path },
-    { type: "country", value: input.context.country ?? "unknown" },
+    { type: "country", value: session.country ?? "unknown" },
     { type: "device", value: input.context.device ?? "unknown" },
     { 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 })),
   ];
@@ -717,6 +918,7 @@ async function accountEvent(
     dimensions,
     input.recordTelemetry,
     input.financialConversion,
+    input.timezone,
   );
 
   if (
@@ -733,6 +935,7 @@ async function accountEvent(
       input.batchState,
     );
   }
+  return session;
 }
 
 async function accountTrustedSession(
@@ -753,8 +956,17 @@ async function accountTrustedSession(
     isNewSession: false,
     isNewVisitorHour: false,
     isNewVisitorDay: false,
+    isNewVisitor: false,
+    durationDeltaMs: 0,
+    continued: false,
     startedAt: existing.startedAt,
     source: existing.source,
+    utmCampaign: existing.utmCampaign,
+    visitorKey: existing.visitorKey ?? existing.visitorId,
+    country: existing.country,
+    city: existing.city,
+    latitude: existing.latitude,
+    longitude: existing.longitude,
     pageviewCount: existing.pageviewCount,
     eventCount: existing.eventCount,
     affiliateId: existing.affiliateId,
@@ -771,10 +983,19 @@ async function upsertSession(
   context: IngestContext,
   existing: CachedDocument<"sessions"> | null,
   financialConversion: boolean,
+  reportRollupDeltas: ReportRollupDeltas,
   batchState?: BatchState,
 ): Promise<SessionState> {
-  const source = sourceFromReferrer(event.referrer);
+  // A host-supplied id is the identity; anonymous sessions count through the
+  // daily key derived by the HTTP action, or once per session without one.
+  const visitorKey =
+    existing?.visitorKey ??
+    (event.visitorId !== event.sessionId
+      ? event.visitorId
+      : (context.visitorKey ?? event.sessionId));
   const utmSource = stringProperty(event.properties, "utm_source");
+  // Campaign traffic names its own source; the referrer host is the fallback.
+  const source = utmSource?.toLowerCase() ?? sourceFromReferrer(event.referrer);
   const utmMedium = stringProperty(event.properties, "utm_medium");
   const utmCampaign = stringProperty(event.properties, "utm_campaign");
   const attribution = await attributionForEvent(
@@ -785,20 +1006,40 @@ async function upsertSession(
     batchState,
   );
   if (existing) {
+    if (attribution && existing.affiliateId !== attribution.affiliateId) {
+      foldAffiliateVisitRollup(
+        reportRollupDeltas,
+        siteId,
+        event,
+        attribution,
+        visitorKey,
+      );
+    }
     const startedAt = Math.min(existing.startedAt, event.timestamp);
     const lastSeenAt = Math.max(existing.lastSeenAt, event.timestamp);
     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),
+      ...(event.type === "pageview"
+        ? {
+            lastPageviewAt: Math.max(
+              existing.lastPageviewAt ?? 0,
+              event.timestamp,
+            ),
+          }
+        : {}),
       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 }
         : {}),
@@ -809,7 +1050,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,
@@ -830,8 +1073,17 @@ async function upsertSession(
       isNewVisitorDay:
         Math.floor(existing.lastSeenAt / DAY_MS) <
         Math.floor(event.timestamp / DAY_MS),
+      isNewVisitor: false,
+      durationDeltaMs: Math.max(0, updates.durationMs - existing.durationMs),
+      continued: event.type === "pageview" && existing.pageviewCount === 1,
       startedAt,
       source: existing.source,
+      utmCampaign: existing.utmCampaign,
+      visitorKey,
+      country: context.country ?? existing.country,
+      city: context.city ?? existing.city,
+      latitude: context.latitude ?? existing.latitude,
+      longitude: context.longitude ?? existing.longitude,
       pageviewCount:
         existing.pageviewCount + (event.type === "pageview" ? 1 : 0),
       eventCount: existing.eventCount + 1,
@@ -859,10 +1111,24 @@ async function upsertSession(
       }
     }
   }
+  // A visitor is new when nothing was ever recorded under their id. A host
+  // id whose anonymous history was linked at sign-up is a return, not a new
+  // person; a browser without a persistent id is new every session.
+  let isNewVisitor = priorVisit === null;
+  if (isNewVisitor && event.visitorId !== event.sessionId) {
+    const alias = await ctx.db
+      .query("visitorAliases")
+      .withIndex("by_siteId_and_visitorId", (range) =>
+        range.eq("siteId", siteId).eq("visitorId", event.visitorId),
+      )
+      .first();
+    if (alias) isNewVisitor = false;
+  }
   const fields: Omit<Doc<"sessions">, "_id" | "_creationTime"> = {
     siteId,
     sessionId: event.sessionId,
     visitorId: event.visitorId,
+    visitorKey,
     startedAt: event.timestamp,
     lastSeenAt: event.timestamp,
     entryPath: event.path,
@@ -875,21 +1141,33 @@ 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",
     eventCount: 1,
     pageviewCount: event.type === "pageview" ? 1 : 0,
+    ...(event.type === "pageview" ? { lastPageviewAt: event.timestamp } : {}),
     durationMs: 0,
     conversionCount: Number(financialConversion),
-    revenueCents: financialConversion ? event.revenueCents ?? 0 : 0,
+    revenueCents: financialConversion ? (event.revenueCents ?? 0) : 0,
     ...(financialConversion && event.currency
       ? { currency: event.currency }
       : {}),
     ...(attribution ?? {}),
   };
   const sessionId = await ctx.db.insert("sessions", fields);
+  if (attribution) {
+    foldAffiliateVisitRollup(
+      reportRollupDeltas,
+      siteId,
+      event,
+      attribution,
+      visitorKey,
+    );
+  }
   if (batchState) {
     const state = batchState.sessions.get(event.sessionId);
     if (!state) throw new Error("session cache was not initialized");
@@ -908,22 +1186,29 @@ async function upsertSession(
       priorVisit === null ||
       Math.floor(priorVisit.lastSeenAt / DAY_MS) <
         Math.floor(event.timestamp / DAY_MS),
+    isNewVisitor,
+    durationDeltaMs: 0,
+    continued: false,
     startedAt: event.timestamp,
     source,
+    utmCampaign,
+    visitorKey,
+    country: context.country,
+    city: context.city,
+    latitude: context.latitude,
+    longitude: context.longitude,
     pageviewCount: event.type === "pageview" ? 1 : 0,
     eventCount: 1,
     ...(attribution ?? {}),
   };
 }
 
-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 ||
@@ -940,7 +1225,6 @@ function attributionSnapshot(
   };
 }
 
-
 function attributionApplies(
   attribution: AttributionSnapshot,
   timestamp: number,
@@ -1065,20 +1349,21 @@ async function accountHeartbeat(
   context: IngestContext,
   now: number,
   batchState?: BatchState,
-) {
+): Promise<number> {
   const startedAt = Math.min(session.startedAt, event.timestamp);
   const lastSeenAt = Math.max(session.lastSeenAt, event.timestamp);
   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,
@@ -1091,6 +1376,7 @@ async function accountHeartbeat(
   } else {
     await ctx.db.patch("sessions", session._id, updates);
   }
+  const durationDeltaMs = Math.max(0, updates.durationMs - session.durationMs);
   await updateLiveSession(
     ctx,
     siteId,
@@ -1100,8 +1386,16 @@ async function accountHeartbeat(
       isNewSession: false,
       isNewVisitorHour: false,
       isNewVisitorDay: false,
+      isNewVisitor: false,
+      durationDeltaMs: 0,
+      continued: false,
       startedAt,
       source: session.source,
+      visitorKey: session.visitorKey ?? session.visitorId,
+      country: context.country ?? session.country,
+      city: context.city ?? session.city,
+      latitude: context.latitude ?? session.latitude,
+      longitude: context.longitude ?? session.longitude,
       pageviewCount: session.pageviewCount,
       eventCount: session.eventCount,
       affiliateSlug: session.affiliateSlug,
@@ -1109,23 +1403,25 @@ async function accountHeartbeat(
     now,
     batchState,
   );
+  return durationDeltaMs;
 }
 
 async function consumeSiteRateLimit(
   ctx: MutationCtx,
   siteId: Id<"sites">,
   events: TrackerEvent[],
+  eventByteCounts: number[],
   now: number,
-): Promise<number[]> {
+): 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 eventByteCounts: number[] = [];
-  const encoder = new TextEncoder();
+  const increments = new Map<
+    number,
+    { eventCount: number; byteCount: number }
+  >();
   for (let index = 0; index < events.length; index += 1) {
     const event = events[index];
-    const byteCount = encoder.encode(JSON.stringify(event)).byteLength;
-    eventByteCounts.push(byteCount);
+    const byteCount = eventByteCounts[index];
     const shard = stableHash(event.sessionId) % SITE_INGEST_SHARDS;
     const current = increments.get(shard) ?? { eventCount: 0, byteCount: 0 };
     current.eventCount += 1;
@@ -1147,9 +1443,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 ||
@@ -1161,10 +1456,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 });
@@ -1195,7 +1488,6 @@ async function consumeSiteRateLimit(
       });
     }
   }
-  return eventByteCounts;
 }
 
 async function consumeRateLimit(
@@ -1206,7 +1498,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
@@ -1244,7 +1537,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) {
@@ -1289,31 +1583,41 @@ async function updateLiveSession(
         )
         .unique();
   const deadline = now + LIVE_SESSION_TTL_MS;
+  const country = context.country ?? session.country;
+  const city = context.city ?? session.city;
+  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,
       lastSeenAt: Math.max(existing.lastSeenAt, event.timestamp),
       expiresAt: deadline,
-      ...(context.country ? { country: context.country } : {}),
-      ...(context.city ? { city: context.city } : {}),
-      ...(context.latitude !== undefined ? { latitude: context.latitude } : {}),
-      ...(context.longitude !== undefined ? { longitude: context.longitude } : {}),
+      ...(country ? { country } : {}),
+      ...(city ? { city } : {}),
+      ...(latitude !== undefined ? { latitude } : {}),
+      ...(longitude !== undefined ? { longitude } : {}),
       browser: context.browser ?? existing.browser,
       os: context.os ?? existing.os,
       source: session.source,
       device: context.device ?? existing.device,
       pageviewCount: session.pageviewCount,
       eventCount: session.eventCount,
+      // The live map animates a visitor from the route they left to the one
+      // they reached; a heartbeat or click on the same page is not a move.
+      ...(event.type === "pageview" && event.path !== existing.path
+        ? { previousPath: existing.path, movedAt: event.timestamp }
+        : {}),
       ...(event.type === "heartbeat"
         ? {
             lastHeartbeatEventId: event.eventId,
@@ -1338,10 +1642,10 @@ async function updateLiveSession(
     startedAt: event.timestamp,
     lastSeenAt: event.timestamp,
     expiresAt: deadline,
-    ...(context.country ? { country: context.country } : {}),
-    ...(context.city ? { city: context.city } : {}),
-    ...(context.latitude !== undefined ? { latitude: context.latitude } : {}),
-    ...(context.longitude !== undefined ? { longitude: context.longitude } : {}),
+    ...(country ? { country } : {}),
+    ...(city ? { city } : {}),
+    ...(latitude !== undefined ? { latitude } : {}),
+    ...(longitude !== undefined ? { longitude } : {}),
     browser: context.browser ?? "Other",
     os: context.os ?? "Other",
     source: session.source,
@@ -1376,9 +1680,13 @@ async function ensureLiveSweep(
     .query("liveSweepStates")
     .withIndex("by_siteId", (range) => range.eq("siteId", siteId))
     .unique();
-  if (!existing) {
+  if (!existing || existing.scheduledAt <= now) {
     const scheduledAt = now + LIVE_SWEEP_INTERVAL_MS;
-    await ctx.db.insert("liveSweepStates", { siteId, scheduledAt });
+    if (existing) {
+      await ctx.db.patch("liveSweepStates", existing._id, { scheduledAt });
+    } else {
+      await ctx.db.insert("liveSweepStates", { siteId, scheduledAt });
+    }
     await ctx.scheduler.runAt(scheduledAt, internal.live.sweep, {
       siteId,
       scheduledAt,
@@ -1399,6 +1707,7 @@ async function advanceFunnel(
   siteId: Id<"sites">,
   funnel: Doc<"funnels">,
   event: TrackerEvent,
+  reportRollupDeltas: ReportRollupDeltas,
   batchState?: BatchState,
 ) {
   const cacheKey = JSON.stringify([funnel._id, event.visitorId]);
@@ -1446,10 +1755,22 @@ async function advanceFunnel(
         _id: progressId,
       };
     }
-    await incrementFunnelStep(ctx, siteId, funnel._id, event, 0, false);
+    foldFunnelStepDelta(
+      reportRollupDeltas,
+      siteId,
+      funnel._id,
+      event,
+      0,
+      false,
+    );
+    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 = {
@@ -1472,7 +1793,15 @@ async function advanceFunnel(
         completedAt: undefined,
       });
     }
-    await incrementFunnelStep(ctx, siteId, funnel._id, event, 0, false);
+    foldFunnelStepDelta(
+      reportRollupDeltas,
+      siteId,
+      funnel._id,
+      event,
+      0,
+      false,
+    );
+    foldFunnelRollup(reportRollupDeltas, siteId, funnel._id, event, 0, false);
     return;
   }
   const nextStep = funnel.steps[progress.currentStep];
@@ -1491,8 +1820,16 @@ async function advanceFunnel(
   } else {
     await ctx.db.patch("funnelProgress", progress._id, updates);
   }
-  await incrementFunnelStep(
-    ctx,
+  foldFunnelStepDelta(
+    reportRollupDeltas,
+    siteId,
+    funnel._id,
+    event,
+    progress.currentStep,
+    completed,
+  );
+  foldFunnelRollup(
+    reportRollupDeltas,
     siteId,
     funnel._id,
     event,
@@ -1510,53 +1847,13 @@ function stepMatches(
     : event.type === "custom" && event.name === step.value;
 }
 
-async function incrementFunnelStep(
-  ctx: MutationCtx,
-  siteId: Id<"sites">,
-  funnelId: Id<"funnels">,
-  event: TrackerEvent,
-  step: number,
-  completed: boolean,
-) {
-  const bucketStart = Math.floor(event.timestamp / DAY_MS) * DAY_MS;
-  const shard = stableHash(event.visitorId) % SECONDARY_AGGREGATE_SHARDS;
-  const bucket = await ctx.db
-    .query("funnelStepBuckets")
-    .withIndex(
-      "by_siteId_and_funnelId_and_bucketStart_and_step_and_shard",
-      (range) =>
-        range
-          .eq("siteId", siteId)
-          .eq("funnelId", funnelId)
-          .eq("bucketStart", bucketStart)
-          .eq("step", step)
-          .eq("shard", shard),
-    )
-    .unique();
-  if (bucket) {
-    await ctx.db.patch("funnelStepBuckets", bucket._id, {
-      entrants: bucket.entrants + 1,
-      completions: bucket.completions + (completed ? 1 : 0),
-    });
-  } else {
-    await ctx.db.insert("funnelStepBuckets", {
-      siteId,
-      funnelId,
-      bucketStart,
-      step,
-      shard,
-      entrants: 1,
-      completions: completed ? 1 : 0,
-    });
-  }
-}
-
 async function accountConversion(
   ctx: MutationCtx,
   siteId: Id<"sites">,
   session: SessionState,
   event: TrackerEvent,
   trustedGoalKey: string | undefined,
+  reportRollupDeltas: ReportRollupDeltas,
 ) {
   const revenueCents = event.revenueCents ?? 0;
   const currency = event.currency ?? "USD";
@@ -1588,6 +1885,15 @@ async function accountConversion(
     commissionCents,
   });
   if (commissionAffiliate && attribution) {
+    foldAffiliateConversionRollup(
+      reportRollupDeltas,
+      siteId,
+      event,
+      commissionAffiliate,
+      attribution.affiliateSlug,
+      revenueCents,
+      commissionCents,
+    );
     const bucketStart = Math.floor(event.timestamp / DAY_MS) * DAY_MS;
     const shard = stableHash(event.sessionId) % SECONDARY_AGGREGATE_SHARDS;
     const stats = await ctx.db
@@ -1623,6 +1929,292 @@ async function accountConversion(
   }
 }
 
+function foldGoalRollup(
+  deltas: ReportRollupDeltas,
+  siteId: Id<"sites">,
+  event: TrackerEvent,
+  goal: Doc<"goals">,
+) {
+  const coordinates = reportRollupCoordinates(
+    siteId,
+    String(goal._id),
+    event.timestamp,
+    event.visitorId,
+  );
+  const current = deltas.goals.get(coordinates.key) ?? {
+    siteId,
+    goalId: goal._id,
+    bucketStart: coordinates.bucketStart,
+    shard: coordinates.shard,
+    goalKey: goal.key,
+    completions: 0,
+    valueCents: 0,
+  };
+  current.completions += 1;
+  current.valueCents += goal.valueCents ?? 0;
+  deltas.goals.set(coordinates.key, current);
+}
+
+function foldFunnelRollup(
+  deltas: ReportRollupDeltas,
+  siteId: Id<"sites">,
+  funnelId: Id<"funnels">,
+  event: TrackerEvent,
+  step: number,
+  completed: boolean,
+) {
+  const coordinates = reportRollupCoordinates(
+    siteId,
+    String(funnelId),
+    event.timestamp,
+    event.visitorId,
+  );
+  const rollup = deltas.funnels.get(coordinates.key) ?? {
+    siteId,
+    funnelId,
+    bucketStart: coordinates.bucketStart,
+    shard: coordinates.shard,
+    steps: new Map(),
+  };
+  const current = rollup.steps.get(step) ?? {
+    step,
+    entrants: 0,
+    completions: 0,
+  };
+  current.entrants += 1;
+  current.completions += Number(completed);
+  rollup.steps.set(step, current);
+  deltas.funnels.set(coordinates.key, rollup);
+}
+
+function foldFunnelStepDelta(
+  deltas: ReportRollupDeltas,
+  siteId: Id<"sites">,
+  funnelId: Id<"funnels">,
+  event: TrackerEvent,
+  step: number,
+  completed: boolean,
+) {
+  const bucketStart = Math.floor(event.timestamp / DAY_MS) * DAY_MS;
+  const shard = stableHash(event.visitorId) % SECONDARY_AGGREGATE_SHARDS;
+  const key = `${siteId}:${funnelId}:${bucketStart}:${step}:${shard}`;
+  const current = deltas.funnelSteps.get(key) ?? {
+    siteId,
+    funnelId,
+    bucketStart,
+    step,
+    shard,
+    entrants: 0,
+    completions: 0,
+  };
+  current.entrants += 1;
+  current.completions += Number(completed);
+  deltas.funnelSteps.set(key, current);
+}
+
+function foldAffiliateVisitRollup(
+  deltas: ReportRollupDeltas,
+  siteId: Id<"sites">,
+  event: TrackerEvent,
+  attribution: AttributionSnapshot,
+  visitorKey: string,
+) {
+  const coordinates = reportRollupCoordinates(
+    siteId,
+    String(attribution.affiliateId),
+    event.timestamp,
+    event.visitorId,
+  );
+  const current = deltas.affiliates.get(coordinates.key) ?? {
+    siteId,
+    affiliateId: attribution.affiliateId,
+    bucketStart: coordinates.bucketStart,
+    shard: coordinates.shard,
+    affiliateSlug: attribution.affiliateSlug,
+    visits: 0,
+    visitorKeys: new Set<string>(),
+    conversions: 0,
+    revenueCents: 0,
+    commissionCents: 0,
+  };
+  current.visits += 1;
+  current.visitorKeys.add(visitorKey);
+  deltas.affiliates.set(coordinates.key, current);
+}
+
+function foldAffiliateConversionRollup(
+  deltas: ReportRollupDeltas,
+  siteId: Id<"sites">,
+  event: TrackerEvent,
+  affiliate: Doc<"affiliates">,
+  affiliateSlug: string,
+  revenueCents: number,
+  commissionCents: number,
+) {
+  const coordinates = reportRollupCoordinates(
+    siteId,
+    String(affiliate._id),
+    event.timestamp,
+    event.visitorId,
+  );
+  const current = deltas.affiliates.get(coordinates.key) ?? {
+    siteId,
+    affiliateId: affiliate._id,
+    bucketStart: coordinates.bucketStart,
+    shard: coordinates.shard,
+    affiliateSlug,
+    visits: 0,
+    visitorKeys: new Set<string>(),
+    conversions: 0,
+    revenueCents: 0,
+    commissionCents: 0,
+  };
+  current.conversions += 1;
+  current.revenueCents += revenueCents;
+  current.commissionCents += commissionCents;
+  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);
+  }
+}
+
+function foldRouteDelta(
+  deltas: ReportRollupDeltas,
+  siteId: Id<"sites">,
+  route: string,
+  timestamp: number,
+  visitorId: string,
+  apply: (delta: RouteRollupDelta) => void,
+) {
+  const coordinates = reportRollupCoordinates(
+    siteId,
+    `route:${route}`,
+    timestamp,
+    visitorId,
+  );
+  const current = deltas.routes.get(coordinates.key) ?? {
+    siteId,
+    bucketStart: coordinates.bucketStart,
+    shard: coordinates.shard,
+    route,
+    pageviews: 0,
+    entries: 0,
+    continued: 0,
+    dwellMs: 0,
+    dwellSamples: 0,
+    visitorKeys: new Set<string>(),
+    outgoing: new Map<string, number>(),
+  };
+  apply(current);
+  deltas.routes.set(coordinates.key, current);
+}
+
+/**
+ * One pageview feeds the site map three ways: the route it lands on gains a
+ * view (and an entry when it opens the session), the route it leaves gains
+ * the transition and the time spent there, and the session's entry route is
+ * marked as continued the first time its visitor moves on — which is what
+ * lets the report derive bounces and exits without a session-end hook.
+ */
+function foldRouteRollups(
+  deltas: ReportRollupDeltas,
+  siteId: Id<"sites">,
+  event: TrackerEvent,
+  session: SessionState,
+  existing: CachedDocument<"sessions"> | null,
+) {
+  const route = normalizeRoute(event.path);
+  const priorPageviews = existing?.pageviewCount ?? 0;
+  const firstPageview = existing === null || priorPageviews === 0;
+  foldRouteDelta(
+    deltas,
+    siteId,
+    route,
+    event.timestamp,
+    event.visitorId,
+    (delta) => {
+      delta.pageviews += 1;
+      if (firstPageview) delta.entries += 1;
+      delta.visitorKeys.add(session.visitorKey);
+    },
+  );
+  // Out-of-order telemetry keeps its view but cannot say where it came from.
+  if (existing === null || firstPageview) return;
+  if (event.timestamp < existing.lastSeenAt) return;
+  const previous = normalizeRoute(existing.exitPath);
+  const lastPageviewAt = existing.lastPageviewAt;
+  foldRouteDelta(
+    deltas,
+    siteId,
+    previous,
+    event.timestamp,
+    event.visitorId,
+    (delta) => {
+      delta.outgoing.set(route, (delta.outgoing.get(route) ?? 0) + 1);
+      if (lastPageviewAt !== undefined && event.timestamp >= lastPageviewAt) {
+        delta.dwellMs += event.timestamp - lastPageviewAt;
+        delta.dwellSamples += 1;
+      }
+    },
+  );
+  if (priorPageviews === 1) {
+    foldRouteDelta(
+      deltas,
+      siteId,
+      normalizeRoute(existing.entryPath),
+      existing.startedAt,
+      event.visitorId,
+      (delta) => {
+        delta.continued += 1;
+      },
+    );
+  }
+}
+
 function foldAggregates(
   aggregateDeltas: AggregateDeltas,
   siteId: Id<"sites">,
@@ -1631,20 +2223,25 @@ function foldAggregates(
   dimensions: Dimension[],
   recordTelemetry: boolean,
   financialConversion: boolean,
+  timezone?: string,
 ) {
-  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 revenueCents = financialConversion ? (event.revenueCents ?? 0) : 0;
+  const dimensionDeltas = dimensions.map((dimension): DimensionDelta => ({
+    ...dimension,
+    count: Number(recordTelemetry),
+    revenueCents,
+    pageviews: Number(recordTelemetry && event.type === "pageview"),
+    sessions: Number(recordTelemetry && session.isNewSession),
+  }));
+  for (const granularity of aggregateGranularities(timezone)) {
+    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;
+    const bucketStart = aggregateBucketStart(
+      granularity,
+      event.timestamp,
+      timezone,
+    );
     const key = `${siteId}:${granularity}:${bucketStart}:${shard}`;
     let delta = aggregateDeltas.get(key);
     if (!delta) {
@@ -1660,9 +2257,13 @@ function foldAggregates(
         outboundClicks: 0,
         sessions: 0,
         visitors: 0,
+        visitorSketch: createVisitorSketch(),
         conversions: 0,
         revenueCents: 0,
         dimensions: [],
+        durationMs: 0,
+        continuedSessions: 0,
+        newVisitors: 0,
       };
       aggregateDeltas.set(key, delta);
     }
@@ -1680,9 +2281,83 @@ function foldAggregates(
         ? Number(session.isNewVisitorHour)
         : Number(session.isNewVisitorDay)
       : 0;
+    if (recordTelemetry) {
+      delta.visitorSketch = addVisitor(delta.visitorSketch, session.visitorKey);
+    }
     delta.conversions += Number(financialConversion);
     delta.revenueCents += revenueCents;
     delta.dimensions = mergeDimensions(delta.dimensions, dimensionDeltas);
+    if (recordTelemetry) {
+      delta.durationMs += session.durationDeltaMs;
+      delta.continuedSessions += Number(session.continued);
+      delta.newVisitors += Number(session.isNewSession && session.isNewVisitor);
+    }
+  }
+}
+
+/**
+ * The buckets an event lands in: UTC hour and UTC day always, plus the
+ * calendar day in the site's timezone when the site keeps one.
+ */
+function aggregateGranularities(
+  timezone: string | undefined,
+): ReadonlyArray<"hour" | "day" | "localDay"> {
+  return timezone ? ["hour", "day", "localDay"] : ["hour", "day"];
+}
+
+function aggregateBucketStart(
+  granularity: "hour" | "day" | "localDay",
+  timestamp: number,
+  timezone: string | undefined,
+): number {
+  if (granularity === "localDay" && timezone) {
+    return localDayStart(timestamp, timezone);
+  }
+  const interval = granularity === "hour" ? HOUR_MS : DAY_MS;
+  return Math.floor(timestamp / interval) * interval;
+}
+
+/** Folds only session duration growth, for heartbeats. */
+function foldSessionDuration(
+  aggregateDeltas: AggregateDeltas,
+  siteId: Id<"sites">,
+  event: TrackerEvent,
+  durationDeltaMs: number,
+  timezone?: string,
+) {
+  if (durationDeltaMs <= 0) return;
+  for (const granularity of aggregateGranularities(timezone)) {
+    const shard =
+      stableHash(event.sessionId) %
+      (granularity === "hour" ? HOURLY_AGGREGATE_SHARDS : AGGREGATE_SHARDS);
+    const bucketStart = aggregateBucketStart(
+      granularity,
+      event.timestamp,
+      timezone,
+    );
+    const key = `${siteId}:${granularity}:${bucketStart}:${shard}`;
+    const delta = aggregateDeltas.get(key) ?? {
+      siteId,
+      granularity,
+      bucketStart,
+      shard,
+      events: 0,
+      pageviews: 0,
+      clicks: 0,
+      customEvents: 0,
+      outboundClicks: 0,
+      sessions: 0,
+      visitors: 0,
+      visitorSketch: createVisitorSketch(),
+      conversions: 0,
+      revenueCents: 0,
+      dimensions: [],
+      durationMs: 0,
+      continuedSessions: 0,
+      newVisitors: 0,
+    };
+    delta.durationMs += durationDeltaMs;
+    aggregateDeltas.set(key, delta);
   }
 }
 
@@ -1705,8 +2380,19 @@ async function flushAggregates(
       .unique();
     const dimensions = mergeDimensions(
       bucket?.dimensions ?? [],
-      delta.dimensions,
+      delta.dimensions.map((slot) => ({
+        ...slot,
+        pageviews: slot.pageviews ?? 0,
+        sessions: slot.sessions ?? 0,
+      })),
     );
+    const priorSketch = bucket?.visitorSketch;
+    const visitorSketch = priorSketch
+      ? unionVisitorSketches(priorSketch, delta.visitorSketch)
+      : delta.visitorSketch;
+    const visitorSketchComplete = bucket
+      ? bucket.visitorSketchComplete === true && priorSketch !== undefined
+      : true;
     if (bucket) {
       await ctx.db.patch("aggregateBuckets", bucket._id, {
         events: bucket.events + delta.events,
@@ -1716,9 +2402,15 @@ async function flushAggregates(
         outboundClicks: bucket.outboundClicks + delta.outboundClicks,
         sessions: bucket.sessions + delta.sessions,
         visitors: bucket.visitors + delta.visitors,
+        visitorSketch,
+        visitorSketchComplete,
         conversions: bucket.conversions + delta.conversions,
         revenueCents: bucket.revenueCents + delta.revenueCents,
         dimensions,
+        durationMs: (bucket.durationMs ?? 0) + delta.durationMs,
+        continuedSessions:
+          (bucket.continuedSessions ?? 0) + delta.continuedSessions,
+        newVisitors: (bucket.newVisitors ?? 0) + delta.newVisitors,
       });
     } else {
       await ctx.db.insert("aggregateBuckets", {
@@ -1733,9 +2425,14 @@ async function flushAggregates(
         outboundClicks: delta.outboundClicks,
         sessions: delta.sessions,
         visitors: delta.visitors,
+        visitorSketch,
+        visitorSketchComplete,
         conversions: delta.conversions,
         revenueCents: delta.revenueCents,
         dimensions,
+        durationMs: delta.durationMs,
+        continuedSessions: delta.continuedSessions,
+        newVisitors: delta.newVisitors,
       });
     }
   }
@@ -1754,6 +2451,8 @@ function mergeDimensions(
     if (exact) {
       exact.count += addition.count;
       exact.revenueCents += addition.revenueCents;
+      exact.pageviews = (exact.pageviews ?? 0) + addition.pageviews;
+      exact.sessions = (exact.sessions ?? 0) + addition.sessions;
       continue;
     }
 
@@ -1761,10 +2460,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;
@@ -1774,6 +2470,8 @@ function mergeDimensions(
         value: addition.value,
         count: addition.count,
         revenueCents: addition.revenueCents,
+        pageviews: addition.pageviews,
+        sessions: addition.sessions,
       });
       continue;
     }
@@ -1783,6 +2481,8 @@ function mergeDimensions(
     if (overflow) {
       overflow.count += addition.count;
       overflow.revenueCents += addition.revenueCents;
+      overflow.pageviews = (overflow.pageviews ?? 0) + addition.pageviews;
+      overflow.sessions = (overflow.sessions ?? 0) + addition.sessions;
       continue;
     }
     if (addition.count === 0 && addition.revenueCents === 0) continue;
@@ -1796,6 +2496,8 @@ function mergeDimensions(
         value: "(other)",
         count: addition.count,
         revenueCents: addition.revenueCents,
+        pageviews: addition.pageviews,
+        sessions: addition.sessions,
       });
       continue;
     }
@@ -1807,6 +2509,8 @@ function mergeDimensions(
     replacement.value = "(other)";
     replacement.count += addition.count;
     replacement.revenueCents += addition.revenueCents;
+    replacement.pageviews = (replacement.pageviews ?? 0) + addition.pageviews;
+    replacement.sessions = (replacement.sessions ?? 0) + addition.sessions;
   }
   return result;
 }
@@ -1816,5 +2520,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;
 }