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

package/dist/component/ingest.js

@@ -1,11 +1,16 @@
 import { v } from "convex/values";
 import { mutation } from "./_generated/server.js";
 import { internal } from "./_generated/api.js";
-import { AGGREGATE_SHARDS, MAX_BATCH_EVENT_GROUPS, DAY_MS, HOURLY_AGGREGATE_SHARDS, DIMENSION_SLOTS, HOUR_MS, LIVE_SESSION_TTL_MS, LIVE_SWEEP_INTERVAL_MS, MAX_BATCH_EVENTS, MAX_SITE_BYTES_PER_SHARD_WINDOW, MAX_SITE_EVENTS_PER_SHARD_WINDOW, MAX_BYTES_PER_SESSION_WINDOW, MAX_EVENTS_PER_SESSION_WINDOW, MAX_FUNNELS_PER_SITE, MAX_GOALS_PER_SITE, RATE_LIMIT_WINDOW_MS, SECONDARY_AGGREGATE_SHARDS, SITE_INGEST_SHARDS, } from "./constants.js";
+import { AGGREGATE_SHARDS, MAX_BATCH_EVENT_GROUPS, DAY_MS, HOURLY_AGGREGATE_SHARDS, DIMENSION_SLOTS, HOUR_MS, LIVE_LEAVE_GRACE_MS, LIVE_SESSION_TTL_MS, LIVE_SWEEP_INTERVAL_MS, MAX_BATCH_EVENTS, MAX_SITE_BYTES_PER_SHARD_WINDOW, MAX_SITE_EVENTS_PER_SHARD_WINDOW, MAX_BYTES_PER_SESSION_WINDOW, MAX_EVENTS_PER_SESSION_WINDOW, 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, } from "./cardinality.js";
+import { addToVitalHistogram, emptyVitalHistogram, vitalDevice, VITAL_ALL, } from "./vitals.js";
 import { fail } from "./errors.js";
+import { ensureAnalyticsControl } from "./coverage.js";
 import { bufferEventBatch, eventBatchKey, eventBucketStart, findTelemetry, flushEventBatches, insertEventBatch, inspectTelemetryMinute, } from "./eventStore.js";
-import { cleanString, ensureBatchBytes, isValidMoney, originAllowed, sanitizeContext, sanitizeCurrency, sanitizeEvent, sanitizeOpaqueId, sanitizePath, sanitizeProperties, sanitizeSlug, sourceFromReferrer, stableHash, } from "./sanitize.js";
+import { cleanString, isValidMoney, measureBatchBytes, normalizeRoute, originAllowed, sanitizeContext, sanitizeCurrency, sanitizeEvent, sanitizeOpaqueId, sanitizePath, sanitizeProperties, sanitizeSlug, sourceFromReferrer, stableHash, } from "./sanitize.js";
 import { ingestContextValidator, ingestResultValidator, trackerEventValidator, trustedConversionValidator, } from "./validators.js";
+import { createReportRollupDeltas, enqueueReportRollups, reportRollupCoordinates, } from "./rollupStore.js";
+import { localDayStart, localDayTimezone } from "./localTime.js";
 export const ingestBatch = mutation({
     args: {
         siteId: v.id("sites"),
@@ -28,16 +33,20 @@ export const ingestBatch = mutation({
                 limit: MAX_BATCH_EVENTS,
             });
         }
+        let eventByteCounts;
         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(ctx, args.siteId, args.events, now);
+        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 = new Map();
+        const reportRollupDeltas = createReportRollupDeltas();
         const sessionRateWindows = new Map();
         const batchState = {
             sessions: new Map(),
@@ -71,7 +80,9 @@ export const ingestBatch = mutation({
             const bucketStart = eventBucketStart(event.timestamp);
             const groupKey = eventBatchKey(event.sessionId, bucketStart);
             requestGroups.add(groupKey);
-            if (event.type === "heartbeat")
+            if (event.type === "heartbeat" ||
+                event.type === "vital" ||
+                event.type === "leave")
                 continue;
             const eventIds = eventIdsByGroup.get(groupKey) ?? new Set();
             if (eventIds.has(event.eventId)) {
@@ -97,7 +108,6 @@ 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)).length;
             if (newCount > 0 &&
@@ -136,7 +146,52 @@ export const ingestBatch = mutation({
                     rejected += 1;
                     continue;
                 }
-                await accountHeartbeat(ctx, args.siteId, existingSession, event, context, now, batchState);
+                const durationDeltaMs = await accountHeartbeat(ctx, args.siteId, existingSession, event, context, 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;
             }
@@ -164,26 +219,29 @@ 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 };
     },
 });
@@ -261,7 +319,8 @@ export const trackConversion = mutation({
             device: existingTelemetry?.device ?? existingSession?.device,
         };
         const aggregateDeltas = new Map();
-        await accountEvent(ctx, {
+        const reportRollupDeltas = createReportRollupDeltas();
+        const session = await accountEvent(ctx, {
             siteId: args.siteId,
             event,
             context: conversionContext,
@@ -269,15 +328,20 @@ 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 };
     },
 });
@@ -347,8 +411,13 @@ function withoutSystemFields(document) {
 async function accountEvent(ctx, input) {
     const { event } = input;
     const session = input.recordTelemetry
-        ? await upsertSession(ctx, input.siteId, event, input.context, input.existingSession, input.financialConversion, input.batchState)
+        ? await upsertSession(ctx, input.siteId, event, 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 = [];
     const matchingGoals = input.goals.filter((goal) => goal.active && goalMatches(goal, event));
     if (matchingGoals.length > 1) {
@@ -366,8 +435,7 @@ async function accountEvent(ctx, input) {
             .eq("siteId", input.siteId)
             .eq("goalId", goal._id)
             .eq("eventId", completionEventId))
-            .take(2))
-            .find((completion) => completion.idempotencyVersion === 2);
+            .take(2)).find((completion) => completion.idempotencyVersion === 2);
         const legacyPrior = scopedPrior
             ? undefined
             : (await ctx.db
@@ -376,8 +444,7 @@ async function accountEvent(ctx, input) {
                 .eq("siteId", input.siteId)
                 .eq("goalId", goal._id)
                 .eq("eventId", event.eventId))
-                .take(2))
-                .find((completion) => completion.idempotencyVersion === undefined &&
+                .take(2)).find((completion) => completion.idempotencyVersion === undefined &&
                 completion.sessionId === event.sessionId &&
                 eventBucketStart(completion.timestamp) ===
                     eventBucketStart(event.timestamp));
@@ -394,33 +461,39 @@ async function accountEvent(ctx, input) {
             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);
         }
     }
     if (input.financialConversion) {
-        await accountConversion(ctx, input.siteId, session, event, input.trustedGoalKey);
+        await accountConversion(ctx, input.siteId, session, event, input.trustedGoalKey, input.reportRollupDeltas);
     }
+    const campaignDimensions = session.utmCampaign
+        ? [{ type: "campaign", value: session.utmCampaign }]
+        : [];
     const dimensions = [
         { 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) => ({ type: "goal", value })),
     ];
-    foldAggregates(input.aggregateDeltas, input.siteId, event, session, dimensions, input.recordTelemetry, input.financialConversion);
+    foldAggregates(input.aggregateDeltas, input.siteId, event, session, dimensions, input.recordTelemetry, input.financialConversion, input.timezone);
     if (input.recordTelemetry &&
         event.timestamp >= input.now - LIVE_SESSION_TTL_MS) {
         await updateLiveSession(ctx, input.siteId, event, input.context, session, input.now, input.batchState);
     }
+    return session;
 }
 async function accountTrustedSession(ctx, existing, event) {
     if (!existing) {
@@ -436,8 +509,17 @@ async function accountTrustedSession(ctx, existing, event) {
         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,
@@ -446,13 +528,23 @@ async function accountTrustedSession(ctx, existing, event) {
         affiliateExpiresAt: existing.affiliateExpiresAt,
     };
 }
-async function upsertSession(ctx, siteId, event, context, existing, financialConversion, batchState) {
-    const source = sourceFromReferrer(event.referrer);
+async function upsertSession(ctx, siteId, event, context, existing, financialConversion, reportRollupDeltas, batchState) {
+    // 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(ctx, siteId, event, existing, 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 = {
@@ -462,10 +554,15 @@ async function upsertSession(ctx, siteId, event, context, existing, financialCon
             exitPath: event.timestamp >= existing.lastSeenAt ? event.path : existing.exitPath,
             eventCount: existing.eventCount + 1,
             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 }
                 : {}),
@@ -476,7 +573,9 @@ async function upsertSession(ctx, siteId, event, context, existing, financialCon
             ...(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,
@@ -497,8 +596,17 @@ async function upsertSession(ctx, siteId, event, context, existing, financialCon
                 Math.floor(event.timestamp / HOUR_MS),
             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,
             ...(attribution ?? {}),
@@ -520,10 +628,23 @@ async function upsertSession(ctx, siteId, event, context, existing, financialCon
             }
         }
     }
+    // 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 = {
         siteId,
         sessionId: event.sessionId,
         visitorId: event.visitorId,
+        visitorKey,
         startedAt: event.timestamp,
         lastSeenAt: event.timestamp,
         entryPath: event.path,
@@ -536,21 +657,27 @@ async function upsertSession(ctx, siteId, event, context, existing, financialCon
         ...(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)
@@ -568,8 +695,17 @@ async function upsertSession(ctx, siteId, event, context, existing, financialCon
         isNewVisitorDay: 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 ?? {}),
@@ -689,14 +825,14 @@ async function accountHeartbeat(ctx, siteId, session, event, context, now, batch
     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,
@@ -711,26 +847,33 @@ async function accountHeartbeat(ctx, siteId, session, event, context, now, batch
     else {
         await ctx.db.patch("sessions", session._id, updates);
     }
+    const durationDeltaMs = Math.max(0, updates.durationMs - session.durationMs);
     await updateLiveSession(ctx, siteId, event, context, {
         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,
     }, now, batchState);
+    return durationDeltaMs;
 }
-async function consumeSiteRateLimit(ctx, siteId, events, now) {
+async function consumeSiteRateLimit(ctx, siteId, events, eventByteCounts, now) {
     const windowStart = Math.floor(now / RATE_LIMIT_WINDOW_MS) * RATE_LIMIT_WINDOW_MS;
     const increments = new Map();
-    const eventByteCounts = [];
-    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;
@@ -745,9 +888,7 @@ async function consumeSiteRateLimit(ctx, siteId, events, now) {
             .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 ||
             (window?.byteCount ?? 0) + increment.byteCount >
@@ -787,7 +928,6 @@ async function consumeSiteRateLimit(ctx, siteId, events, now) {
             });
         }
     }
-    return eventByteCounts;
 }
 async function consumeRateLimit(ctx, siteId, sessionId, byteCount, now, states) {
     const windowStart = Math.floor(now / RATE_LIMIT_WINDOW_MS) * RATE_LIMIT_WINDOW_MS;
@@ -855,6 +995,10 @@ async function updateLiveSession(ctx, siteId, event, context, session, now, batc
             .withIndex("by_siteId_and_sessionId", (range) => range.eq("siteId", siteId).eq("sessionId", event.sessionId))
             .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"
             ? [
@@ -870,16 +1014,21 @@ async function updateLiveSession(ctx, siteId, event, context, session, now, batc
             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,
@@ -904,10 +1053,10 @@ async function updateLiveSession(ctx, siteId, event, context, session, now, batc
         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,
@@ -937,9 +1086,14 @@ async function ensureLiveSweep(ctx, siteId, now, batchState) {
         .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,
@@ -953,7 +1107,7 @@ function goalMatches(goal, event) {
     }
     return event.type === "custom" && event.name === goal.matchValue;
 }
-async function advanceFunnel(ctx, siteId, funnel, event, batchState) {
+async function advanceFunnel(ctx, siteId, funnel, event, reportRollupDeltas, batchState) {
     const cacheKey = JSON.stringify([funnel._id, event.visitorId]);
     let progressState = batchState?.funnelProgress.get(cacheKey);
     if (batchState && !progressState) {
@@ -996,10 +1150,12 @@ async function advanceFunnel(ctx, siteId, funnel, event, batchState) {
                 _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)
+    if (progress.completedAt !== undefined ||
+        event.timestamp < progress.lastStepAt)
         return;
     if (event.timestamp - progress.startedAt > funnel.conversionWindowMs) {
         if (!matchesFirst)
@@ -1025,7 +1181,8 @@ async function advanceFunnel(ctx, siteId, funnel, event, batchState) {
                 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];
@@ -1046,44 +1203,15 @@ async function advanceFunnel(ctx, siteId, funnel, event, batchState) {
     else {
         await ctx.db.patch("funnelProgress", progress._id, updates);
     }
-    await incrementFunnelStep(ctx, siteId, funnel._id, event, progress.currentStep, completed);
+    foldFunnelStepDelta(reportRollupDeltas, siteId, funnel._id, event, progress.currentStep, completed);
+    foldFunnelRollup(reportRollupDeltas, siteId, funnel._id, event, progress.currentStep, completed);
 }
 function stepMatches(step, event) {
     return step.type === "pageview"
         ? event.type === "pageview" && event.path === step.value
         : event.type === "custom" && event.name === step.value;
 }
-async function incrementFunnelStep(ctx, siteId, funnelId, event, step, completed) {
-    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, siteId, session, event, trustedGoalKey) {
+async function accountConversion(ctx, siteId, session, event, trustedGoalKey, reportRollupDeltas) {
     const revenueCents = event.revenueCents ?? 0;
     const currency = event.currency ?? "USD";
     const candidate = attributionSnapshot(session);
@@ -1112,6 +1240,7 @@ async function accountConversion(ctx, siteId, session, event, trustedGoalKey) {
         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
@@ -1143,18 +1272,200 @@ async function accountConversion(ctx, siteId, session, event, trustedGoalKey) {
         }
     }
 }
-function foldAggregates(aggregateDeltas, siteId, event, session, dimensions, recordTelemetry, financialConversion) {
-    const revenueCents = financialConversion ? event.revenueCents ?? 0 : 0;
+function foldGoalRollup(deltas, siteId, event, goal) {
+    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, siteId, funnelId, event, step, completed) {
+    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, siteId, funnelId, event, step, completed) {
+    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, siteId, event, attribution, visitorKey) {
+    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(),
+        conversions: 0,
+        revenueCents: 0,
+        commissionCents: 0,
+    };
+    current.visits += 1;
+    current.visitorKeys.add(visitorKey);
+    deltas.affiliates.set(coordinates.key, current);
+}
+function foldAffiliateConversionRollup(deltas, siteId, event, affiliate, affiliateSlug, revenueCents, commissionCents) {
+    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(),
+        conversions: 0,
+        revenueCents: 0,
+        commissionCents: 0,
+    };
+    current.conversions += 1;
+    current.revenueCents += revenueCents;
+    current.commissionCents += commissionCents;
+    deltas.affiliates.set(coordinates.key, current);
+}
+function foldVitalRollups(deltas, siteId, event, device) {
+    const metric = event.name;
+    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(),
+        };
+        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, siteId, route, timestamp, visitorId, apply) {
+    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(),
+        outgoing: new Map(),
+    };
+    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, siteId, event, session, existing) {
+    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, siteId, event, session, dimensions, recordTelemetry, financialConversion, timezone) {
+    const revenueCents = financialConversion ? (event.revenueCents ?? 0) : 0;
     const dimensionDeltas = dimensions.map((dimension) => ({
         ...dimension,
         count: Number(recordTelemetry),
         revenueCents,
+        pageviews: Number(recordTelemetry && event.type === "pageview"),
+        sessions: Number(recordTelemetry && session.isNewSession),
     }));
-    for (const granularity of ["hour", "day"]) {
+    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) {
@@ -1170,9 +1481,13 @@ function foldAggregates(aggregateDeltas, siteId, event, session, dimensions, rec
                 outboundClicks: 0,
                 sessions: 0,
                 visitors: 0,
+                visitorSketch: createVisitorSketch(),
                 conversions: 0,
                 revenueCents: 0,
                 dimensions: [],
+                durationMs: 0,
+                continuedSessions: 0,
+                newVisitors: 0,
             };
             aggregateDeltas.set(key, delta);
         }
@@ -1188,9 +1503,64 @@ function foldAggregates(aggregateDeltas, siteId, event, session, dimensions, rec
                 ? 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) {
+    return timezone ? ["hour", "day", "localDay"] : ["hour", "day"];
+}
+function aggregateBucketStart(granularity, timestamp, timezone) {
+    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, siteId, event, durationDeltaMs, timezone) {
+    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);
     }
 }
 async function flushAggregates(ctx, aggregateDeltas) {
@@ -1203,7 +1573,18 @@ async function flushAggregates(ctx, aggregateDeltas) {
             .eq("bucketStart", delta.bucketStart)
             .eq("shard", delta.shard))
             .unique();
-        const dimensions = mergeDimensions(bucket?.dimensions ?? [], delta.dimensions);
+        const dimensions = mergeDimensions(bucket?.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,
@@ -1213,9 +1594,14 @@ async function flushAggregates(ctx, aggregateDeltas) {
                 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 {
@@ -1231,9 +1617,14 @@ async function flushAggregates(ctx, aggregateDeltas) {
                 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,
             });
         }
     }
@@ -1245,6 +1636,8 @@ function mergeDimensions(current, additions) {
         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;
         }
         const typeSlots = result.filter((candidate) => candidate.type === addition.type);
@@ -1261,6 +1654,8 @@ function mergeDimensions(current, additions) {
                 value: addition.value,
                 count: addition.count,
                 revenueCents: addition.revenueCents,
+                pageviews: addition.pageviews,
+                sessions: addition.sessions,
             });
             continue;
         }
@@ -1268,6 +1663,8 @@ function mergeDimensions(current, additions) {
         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)
@@ -1283,6 +1680,8 @@ function mergeDimensions(current, additions) {
                 value: "(other)",
                 count: addition.count,
                 revenueCents: addition.revenueCents,
+                pageviews: addition.pageviews,
+                sessions: addition.sessions,
             });
             continue;
         }
@@ -1294,11 +1693,15 @@ function mergeDimensions(current, additions) {
         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;
 }
 function stringProperty(properties, key) {
     const value = properties?.[key];
-    return typeof value === "string" ? cleanString(value, 120) || undefined : undefined;
+    return typeof value === "string"
+        ? cleanString(value, 120) || undefined
+        : undefined;
 }
 //# sourceMappingURL=ingest.js.map