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

package/src/component/ingest.ts

@@ -18,12 +18,21 @@ import {
   MAX_BYTES_PER_SESSION_WINDOW,
   MAX_EVENTS_PER_SESSION_WINDOW,
   MAX_FUNNELS_PER_SITE,
+  MAX_FUNNEL_STEPS,
   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 { fail } from "./errors.js";
+import { ensureAnalyticsControl } from "./coverage.js";
 import {
   bufferEventBatch,
   eventBatchKey,
@@ -36,8 +45,8 @@ import {
 } from "./eventStore.js";
 import {
   cleanString,
-  ensureBatchBytes,
   isValidMoney,
+  measureBatchBytes,
   originAllowed,
   sanitizeContext,
   sanitizeCurrency,
@@ -60,6 +69,7 @@ import {
 
 type DimensionType =
   | "source"
+  | "campaign"
   | "page"
   | "country"
   | "device"
@@ -81,11 +91,49 @@ type AggregateDelta = {
   outboundClicks: number;
   sessions: number;
   visitors: number;
+  visitorSketch: VisitorSketch;
   conversions: number;
   revenueCents: number;
   dimensions: Doc<"aggregateBuckets">["dimensions"];
 };
 type AggregateDeltas = Map<string, AggregateDelta>;
+type GoalRollupDelta = {
+  siteId: Id<"sites">;
+  goalId: Id<"goals">;
+  bucketStart: number;
+  shard: number;
+  goalKey: string;
+  completions: number;
+  valueCents: number;
+};
+type FunnelRollupDelta = {
+  siteId: Id<"sites">;
+  funnelId: Id<"funnels">;
+  bucketStart: number;
+  shard: number;
+  steps: Map<number, {
+    step: number;
+    entrants: number;
+    completions: number;
+  }>;
+};
+type AffiliateRollupDelta = {
+  siteId: Id<"sites">;
+  affiliateId: Id<"affiliates">;
+  bucketStart: number;
+  shard: number;
+  affiliateSlug: string;
+  visits: number;
+  visitorSketch: VisitorSketch;
+  conversions: number;
+  revenueCents: number;
+  commissionCents: number;
+};
+type ReportRollupDeltas = {
+  goals: Map<string, GoalRollupDelta>;
+  funnels: Map<string, FunnelRollupDelta>;
+  affiliates: Map<string, AffiliateRollupDelta>;
+};
 type AttributionSnapshot = {
   affiliateId: Id<"affiliates">;
   affiliateSlug: string;
@@ -99,6 +147,8 @@ type SessionState = {
   isNewVisitorDay: boolean;
   startedAt: number;
   source: string;
+  visitorKey: string;
+  utmCampaign?: string;
   country?: string;
   city?: string;
   latitude?: number;
@@ -161,21 +211,25 @@ export const ingestBatch = mutation({
         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 aggregateDeltas: AggregateDeltas = new Map();
+    const reportRollupDeltas = createReportRollupDeltas();
     const sessionRateWindows = new Map<string, SessionRateWindowState>();
     const batchState: BatchState = {
       sessions: new Map(),
@@ -367,6 +421,7 @@ export const ingestBatch = mutation({
         goals: canMatchDefinition ? goals ?? [] : [],
         funnels: canMatchDefinition ? funnels ?? [] : [],
         aggregateDeltas,
+        reportRollupDeltas,
         recordTelemetry: true,
         financialConversion: false,
         trustedGoalKey: undefined,
@@ -384,6 +439,7 @@ export const ingestBatch = mutation({
     await flushBatchState(ctx, batchState);
     await flushSessionRateLimits(ctx, sessionRateWindows, now);
     await flushAggregates(ctx, aggregateDeltas);
+    await flushReportRollups(ctx, reportRollupDeltas);
     return { accepted, duplicates, rejected };
   },
 });
@@ -475,6 +531,7 @@ export const trackConversion = mutation({
     };
 
     const aggregateDeltas: AggregateDeltas = new Map();
+    const reportRollupDeltas = createReportRollupDeltas();
     const session = await accountEvent(ctx, {
       siteId: args.siteId,
       event,
@@ -483,6 +540,7 @@ export const trackConversion = mutation({
       goals: [],
       funnels: [],
       aggregateDeltas,
+      reportRollupDeltas,
       recordTelemetry: existingTelemetry === null && !telemetry.saturated,
       financialConversion: true,
       trustedGoalKey,
@@ -497,6 +555,8 @@ export const trackConversion = mutation({
       );
     }
     await flushAggregates(ctx, aggregateDeltas);
+    await flushReportRollups(ctx, reportRollupDeltas);
+    await ensureAnalyticsControl(ctx, args.siteId, Date.now());
     return { accepted: 1, duplicates: 0, rejected: 0 };
   },
 });
@@ -619,6 +679,7 @@ async function accountEvent(
     goals: Doc<"goals">[];
     funnels: Doc<"funnels">[];
     aggregateDeltas: AggregateDeltas;
+    reportRollupDeltas: ReportRollupDeltas;
     recordTelemetry: boolean;
     financialConversion: boolean;
     trustedGoalKey: string | undefined;
@@ -635,6 +696,7 @@ async function accountEvent(
         input.context,
         input.existingSession,
         input.financialConversion,
+        input.reportRollupDeltas,
         input.batchState,
       )
     : await accountTrustedSession(ctx, input.existingSession, event);
@@ -691,12 +753,25 @@ 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,
+      );
     }
   }
 
@@ -707,11 +782,16 @@ 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: session.country ?? "unknown" },
     { type: "device", value: input.context.device ?? "unknown" },
@@ -769,6 +849,8 @@ async function accountTrustedSession(
     isNewVisitorDay: false,
     startedAt: existing.startedAt,
     source: existing.source,
+    utmCampaign: existing.utmCampaign,
+    visitorKey: existing.visitorKey ?? existing.visitorId,
     country: existing.country,
     city: existing.city,
     latitude: existing.latitude,
@@ -789,10 +871,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(
@@ -803,6 +894,15 @@ 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 = {
@@ -850,6 +950,8 @@ async function upsertSession(
         Math.floor(event.timestamp / DAY_MS),
       startedAt,
       source: existing.source,
+      utmCampaign: existing.utmCampaign,
+      visitorKey,
       country: context.country ?? existing.country,
       city: context.city ?? existing.city,
       latitude: context.latitude ?? existing.latitude,
@@ -885,6 +987,7 @@ async function upsertSession(
     siteId,
     sessionId: event.sessionId,
     visitorId: event.visitorId,
+    visitorKey,
     startedAt: event.timestamp,
     lastSeenAt: event.timestamp,
     entryPath: event.path,
@@ -912,6 +1015,15 @@ async function upsertSession(
     ...(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");
@@ -932,6 +1044,8 @@ async function upsertSession(
         Math.floor(event.timestamp / DAY_MS),
     startedAt: event.timestamp,
     source,
+    utmCampaign,
+    visitorKey,
     country: context.country,
     city: context.city,
     latitude: context.latitude,
@@ -1128,6 +1242,7 @@ async function accountHeartbeat(
       isNewVisitorDay: 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,
@@ -1145,17 +1260,15 @@ 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();
   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;
@@ -1225,7 +1338,6 @@ async function consumeSiteRateLimit(
       });
     }
   }
-  return eventByteCounts;
 }
 
 async function consumeRateLimit(
@@ -1410,9 +1522,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,
@@ -1433,6 +1549,7 @@ async function advanceFunnel(
   siteId: Id<"sites">,
   funnel: Doc<"funnels">,
   event: TrackerEvent,
+  reportRollupDeltas: ReportRollupDeltas,
   batchState?: BatchState,
 ) {
   const cacheKey = JSON.stringify([funnel._id, event.visitorId]);
@@ -1481,6 +1598,7 @@ async function advanceFunnel(
       };
     }
     await incrementFunnelStep(ctx, siteId, funnel._id, event, 0, false);
+    foldFunnelRollup(reportRollupDeltas, siteId, funnel._id, event, 0, false);
     return;
   }
   if (progress.completedAt !== undefined || event.timestamp < progress.lastStepAt) return;
@@ -1507,6 +1625,7 @@ async function advanceFunnel(
       });
     }
     await incrementFunnelStep(ctx, siteId, funnel._id, event, 0, false);
+    foldFunnelRollup(reportRollupDeltas, siteId, funnel._id, event, 0, false);
     return;
   }
   const nextStep = funnel.steps[progress.currentStep];
@@ -1533,6 +1652,14 @@ async function advanceFunnel(
     progress.currentStep,
     completed,
   );
+  foldFunnelRollup(
+    reportRollupDeltas,
+    siteId,
+    funnel._id,
+    event,
+    progress.currentStep,
+    completed,
+  );
 }
 
 function stepMatches(
@@ -1591,6 +1718,7 @@ async function accountConversion(
   session: SessionState,
   event: TrackerEvent,
   trustedGoalKey: string | undefined,
+  reportRollupDeltas: ReportRollupDeltas,
 ) {
   const revenueCents = event.revenueCents ?? 0;
   const currency = event.currency ?? "USD";
@@ -1622,6 +1750,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
@@ -1657,6 +1794,255 @@ async function accountConversion(
   }
 }
 
+function createReportRollupDeltas(): ReportRollupDeltas {
+  return {
+    goals: new Map(),
+    funnels: new Map(),
+    affiliates: new Map(),
+  };
+}
+
+function reportRollupCoordinates(
+  siteId: Id<"sites">,
+  definitionId: string,
+  timestamp: number,
+  visitorId: string,
+) {
+  const bucketStart = Math.floor(timestamp / DAY_MS) * DAY_MS;
+  const shard = stableHash(visitorId) % REPORT_ROLLUP_SHARDS;
+  return {
+    bucketStart,
+    shard,
+    key: `${siteId}:${definitionId}:${bucketStart}:${shard}`,
+  };
+}
+
+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 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,
+    visitorSketch: createVisitorSketch(),
+    conversions: 0,
+    revenueCents: 0,
+    commissionCents: 0,
+  };
+  current.visits += 1;
+  current.visitorSketch = addVisitor(current.visitorSketch, 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,
+    visitorSketch: createVisitorSketch(),
+    conversions: 0,
+    revenueCents: 0,
+    commissionCents: 0,
+  };
+  current.conversions += 1;
+  current.revenueCents += revenueCents;
+  current.commissionCents += commissionCents;
+  deltas.affiliates.set(coordinates.key, current);
+}
+
+async function flushReportRollups(
+  ctx: MutationCtx,
+  deltas: ReportRollupDeltas,
+) {
+  for (const delta of deltas.goals.values()) {
+    const existing = await ctx.db
+      .query("goalDailyRollups")
+      .withIndex("by_siteId_and_goalId_and_bucketStart_and_shard", (range) =>
+        range
+          .eq("siteId", delta.siteId)
+          .eq("goalId", delta.goalId)
+          .eq("bucketStart", delta.bucketStart)
+          .eq("shard", delta.shard),
+      )
+      .unique();
+    const fields = {
+      siteId: delta.siteId,
+      goalId: delta.goalId,
+      bucketStart: delta.bucketStart,
+      shard: delta.shard,
+      generation: 1 as const,
+      goalKey: delta.goalKey,
+      completions: (existing?.completions ?? 0) + delta.completions,
+      valueCents: (existing?.valueCents ?? 0) + delta.valueCents,
+    };
+    if (existing) {
+      await ctx.db.replace("goalDailyRollups", existing._id, fields);
+    } else {
+      await ctx.db.insert("goalDailyRollups", fields);
+    }
+  }
+  for (const delta of deltas.funnels.values()) {
+    const existing = await ctx.db
+      .query("funnelDailyRollups")
+      .withIndex("by_siteId_and_funnelId_and_bucketStart_and_shard", (range) =>
+        range
+          .eq("siteId", delta.siteId)
+          .eq("funnelId", delta.funnelId)
+          .eq("bucketStart", delta.bucketStart)
+          .eq("shard", delta.shard),
+      )
+      .unique();
+    const steps = existing?.steps.map((step) => ({ ...step })) ?? [];
+    for (const addition of delta.steps.values()) {
+      const current = steps.find((step) => step.step === addition.step);
+      if (current) {
+        current.entrants += addition.entrants;
+        current.completions += addition.completions;
+      } else {
+        if (steps.length >= MAX_FUNNEL_STEPS) {
+          fail("LIMIT_EXCEEDED", "daily funnel rollup step limit exceeded");
+        }
+        steps.push(addition);
+      }
+    }
+    const fields = {
+      siteId: delta.siteId,
+      funnelId: delta.funnelId,
+      bucketStart: delta.bucketStart,
+      shard: delta.shard,
+      generation: 1 as const,
+      steps,
+    };
+    if (existing) {
+      await ctx.db.replace("funnelDailyRollups", existing._id, fields);
+    } else {
+      await ctx.db.insert("funnelDailyRollups", fields);
+    }
+  }
+  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),
+      )
+      .unique();
+    const fields = {
+      siteId: delta.siteId,
+      affiliateId: delta.affiliateId,
+      bucketStart: delta.bucketStart,
+      shard: delta.shard,
+      generation: 1 as const,
+      affiliateSlug: delta.affiliateSlug,
+      visits: (existing?.visits ?? 0) + delta.visits,
+      visitorSketch: unionVisitorSketches(
+        existing?.visitorSketch ?? createVisitorSketch(),
+        delta.visitorSketch,
+      ),
+      conversions: (existing?.conversions ?? 0) + delta.conversions,
+      revenueCents: (existing?.revenueCents ?? 0) + delta.revenueCents,
+      commissionCents:
+        (existing?.commissionCents ?? 0) + delta.commissionCents,
+    };
+    if (existing) {
+      await ctx.db.replace("affiliateDailyRollups", existing._id, fields);
+    } else {
+      await ctx.db.insert("affiliateDailyRollups", fields);
+    }
+  }
+}
+
 function foldAggregates(
   aggregateDeltas: AggregateDeltas,
   siteId: Id<"sites">,
@@ -1694,6 +2080,7 @@ function foldAggregates(
         outboundClicks: 0,
         sessions: 0,
         visitors: 0,
+        visitorSketch: createVisitorSketch(),
         conversions: 0,
         revenueCents: 0,
         dimensions: [],
@@ -1714,6 +2101,9 @@ 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);
@@ -1741,6 +2131,13 @@ async function flushAggregates(
       bucket?.dimensions ?? [],
       delta.dimensions,
     );
+    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,
@@ -1750,6 +2147,8 @@ 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,
@@ -1767,6 +2166,8 @@ async function flushAggregates(
         outboundClicks: delta.outboundClicks,
         sessions: delta.sessions,
         visitors: delta.visitors,
+        visitorSketch,
+        visitorSketchComplete,
         conversions: delta.conversions,
         revenueCents: delta.revenueCents,
         dimensions,