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

package/src/component/retention.ts

@@ -1,12 +1,22 @@
 import { v } from "convex/values";
+import { internal } from "./_generated/api.js";
 import type { Id } from "./_generated/dataModel.js";
 import type { MutationCtx } from "./_generated/server.js";
-import { mutation } from "./_generated/server.js";
-import { MAX_RETENTION_BATCH } from "./constants.js";
+import { internalMutation, mutation, query } from "./_generated/server.js";
+import {
+  DAY_MS,
+  HOUR_MS,
+  MAX_RETENTION_BATCH,
+  MINUTE_MS,
+  RATE_LIMIT_WINDOW_MS,
+  RETENTION_LEASE_MS,
+  RETENTION_POLICY_INTERVAL_MS,
+} from "./constants.js";
+import { ensureAnalyticsControl } from "./coverage.js";
 import { fail } from "./errors.js";
 import { deleteTelemetryBefore } from "./eventStore.js";
 
-const cleanupKindValidator = v.union(
+export const cleanupKindValidator = v.union(
   v.literal("events"),
   v.literal("sessions"),
   v.literal("conversions"),
@@ -16,12 +26,23 @@ const cleanupKindValidator = v.union(
   v.literal("funnelProgress"),
   v.literal("funnelSteps"),
   v.literal("affiliateStats"),
+  v.literal("goalRollups"),
+  v.literal("funnelRollups"),
+  v.literal("affiliateRollups"),
+  v.literal("vitalRollups"),
+  v.literal("siteMapRollups"),
   v.literal("attributions"),
   v.literal("liveSessions"),
   v.literal("ingestWindows"),
   v.literal("siteIngestWindows"),
 );
 
+const cleanupResultValidator = v.object({
+  deleted: v.number(),
+  hasMore: v.boolean(),
+  before: v.number(),
+});
+
 export const cleanup = mutation({
   args: {
     siteId: v.id("sites"),
@@ -29,38 +50,385 @@ export const cleanup = mutation({
     before: v.number(),
     batchSize: v.optional(v.number()),
   },
-  returns: v.object({ deleted: v.number(), hasMore: v.boolean() }),
+  returns: cleanupResultValidator,
   handler: async (ctx, args) => {
-    if (!Number.isFinite(args.before) || args.before < 0) {
-      fail("INVALID_ARGUMENT", "before must be a positive timestamp");
+    const policy = await ctx.db
+      .query("retentionPolicies")
+      .withIndex("by_siteId", (range) => range.eq("siteId", args.siteId))
+      .unique();
+    if (policy) {
+      fail(
+        "CONFLICT",
+        "disable the retention policy before running manual cleanup",
+      );
     }
-    const batchSize = args.batchSize ?? 100;
-    if (!Number.isSafeInteger(batchSize) || batchSize < 1 || batchSize > MAX_RETENTION_BATCH) {
-      fail("INVALID_ARGUMENT", `batchSize must be an integer between 1 and ${MAX_RETENTION_BATCH}`);
+    const before = safeCleanupBoundary(args.kind, args.before, Date.now());
+    const result = await executeCleanupBatch(ctx, { ...args, before });
+    await persistDirectState(ctx, { ...args, before }, result);
+    await recordRetentionBoundary(ctx, args.siteId, args.kind, before);
+    return { ...result, before };
+  },
+});
+
+const policyValidator = v.object({
+  eventsDays: v.number(),
+  sessionsDays: v.number(),
+  conversionsDays: v.number(),
+  aggregatesDays: v.number(),
+  reportsDays: v.number(),
+});
+
+export const setPolicy = mutation({
+  args: { siteId: v.id("sites"), ...policyValidator.fields },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    validatePolicy(args);
+    const now = Date.now();
+    const existingPolicy = await ctx.db
+      .query("retentionPolicies")
+      .withIndex("by_siteId", (range) => range.eq("siteId", args.siteId))
+      .unique();
+    const policy = { ...args, updatedAt: now };
+    if (existingPolicy) {
+      await ctx.db.replace("retentionPolicies", existingPolicy._id, policy);
+    } else {
+      await ctx.db.insert("retentionPolicies", policy);
     }
-    const effectiveBatchSize = args.kind === "events"
-      ? Math.min(batchSize, 32)
-      : batchSize;
-    if (args.kind === "events") {
-      return await deleteTelemetryBefore(ctx, {
+
+    for (const kind of POLICY_CLEANUP_KINDS) {
+      const requestedBefore = now - retentionDaysForKind(policy, kind) * DAY_MS;
+      const before = safeCleanupBoundary(kind, requestedBefore, now);
+      const existing = await loadState(ctx, args.siteId, kind);
+      const generation = (existing?.generation ?? 0) + 1;
+      const fields = {
         siteId: args.siteId,
-        before: args.before,
-        batchSize: effectiveBatchSize,
+        kind,
+        before,
+        status: "pending" as const,
+        generation,
+        attempt: 0,
+        scheduledAt: now,
+        deleted: 0,
+        updatedAt: now,
+      };
+      const stateId = existing
+        ? (await ctx.db.replace("retentionStates", existing._id, fields),
+          existing._id)
+        : await ctx.db.insert("retentionStates", fields);
+      await ctx.scheduler.runAfter(0, internal.retention.runScheduled, {
+        stateId,
+        generation,
+      });
+    }
+    return null;
+  },
+});
+
+export const disablePolicy = mutation({
+  args: { siteId: v.id("sites") },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    const policy = await ctx.db
+      .query("retentionPolicies")
+      .withIndex("by_siteId", (range) => range.eq("siteId", args.siteId))
+      .unique();
+    if (policy) await ctx.db.delete("retentionPolicies", policy._id);
+    const now = Date.now();
+    const states = await ctx.db
+      .query("retentionStates")
+      .withIndex("by_siteId_and_kind", (range) =>
+        range.eq("siteId", args.siteId),
+      )
+      .take(POLICY_CLEANUP_KINDS.length + 1);
+    for (const state of states) {
+      await ctx.db.patch("retentionStates", state._id, {
+        status: "complete",
+        generation: state.generation + 1,
+        leaseExpiresAt: undefined,
+        scheduledAt: undefined,
+        updatedAt: now,
+      });
+    }
+    return null;
+  },
+});
+
+export const runPolicy = mutation({
+  args: {
+    siteId: v.id("sites"),
+    kind: cleanupKindValidator,
+    batchSize: v.optional(v.number()),
+  },
+  returns: cleanupResultValidator,
+  handler: async (ctx, args) => {
+    const policy = await ctx.db
+      .query("retentionPolicies")
+      .withIndex("by_siteId", (range) => range.eq("siteId", args.siteId))
+      .unique();
+    if (!policy) fail("NOT_FOUND", "retention policy not found");
+    const now = Date.now();
+    const existing = await loadState(ctx, args.siteId, args.kind);
+    if (
+      existing?.status === "running" &&
+      existing.leaseExpiresAt !== undefined &&
+      existing.leaseExpiresAt > now
+    ) {
+      return { deleted: 0, hasMore: true, before: existing.before };
+    }
+    const before =
+      existing && existing.status !== "complete"
+        ? existing.before
+        : safeCleanupBoundary(
+            args.kind,
+            now - retentionDaysForKind(policy, args.kind) * DAY_MS,
+            now,
+          );
+    const result = await executeCleanupBatch(ctx, { ...args, before });
+    const generation = existing?.generation ?? 1;
+    const fields = {
+      siteId: args.siteId,
+      kind: args.kind,
+      before,
+      status: result.hasMore ? ("pending" as const) : ("complete" as const),
+      generation,
+      attempt: existing?.attempt ?? 0,
+      scheduledAt: result.hasMore ? now : now + RETENTION_POLICY_INTERVAL_MS,
+      deleted:
+        existing?.before === before
+          ? existing.deleted + result.deleted
+          : result.deleted,
+      updatedAt: now,
+    };
+    const stateId = existing
+      ? (await ctx.db.replace("retentionStates", existing._id, fields),
+        existing._id)
+      : await ctx.db.insert("retentionStates", fields);
+    await recordRetentionBoundary(ctx, args.siteId, args.kind, before);
+    if (result.hasMore) {
+      await ctx.scheduler.runAfter(0, internal.retention.runScheduled, {
+        stateId,
+        generation,
       });
+    } else {
+      await ctx.scheduler.runAt(
+        now + RETENTION_POLICY_INTERVAL_MS,
+        internal.retention.startScheduledCycle,
+        { stateId, generation },
+      );
     }
-    const deletions = await deletionsForCleanup(
+    return { ...result, before };
+  },
+});
+
+export const runScheduled = internalMutation({
+  args: { stateId: v.id("retentionStates"), generation: v.number() },
+  returns: v.object({
+    claimed: v.boolean(),
+    stale: v.boolean(),
+    attempt: v.number(),
+  }),
+  handler: async (ctx, args) => {
+    const state = await ctx.db.get("retentionStates", args.stateId);
+    const now = Date.now();
+    if (
+      !state ||
+      state.generation !== args.generation ||
+      state.status === "complete" ||
+      (state.status === "running" &&
+        state.leaseExpiresAt !== undefined &&
+        state.leaseExpiresAt > now)
+    ) {
+      return { claimed: false, stale: true, attempt: state?.attempt ?? 0 };
+    }
+    const attempt = state.attempt + 1;
+    const leaseExpiresAt = now + RETENTION_LEASE_MS;
+    await ctx.db.patch("retentionStates", state._id, {
+      status: "running",
+      attempt,
+      leaseExpiresAt,
+      scheduledAt: now,
+      updatedAt: now,
+    });
+    await ctx.scheduler.runAfter(0, internal.retention.executeScheduled, {
+      stateId: state._id,
+      generation: state.generation,
+      attempt,
+    });
+    await ctx.scheduler.runAt(leaseExpiresAt, internal.retention.runScheduled, {
+      stateId: state._id,
+      generation: state.generation,
+    });
+    return { claimed: true, stale: false, attempt };
+  },
+});
+
+export const executeScheduled = internalMutation({
+  args: {
+    stateId: v.id("retentionStates"),
+    generation: v.number(),
+    attempt: v.number(),
+  },
+  returns: v.object({
+    deleted: v.number(),
+    hasMore: v.boolean(),
+    stale: v.boolean(),
+  }),
+  handler: async (ctx, args) => {
+    const state = await ctx.db.get("retentionStates", args.stateId);
+    if (
+      !state ||
+      state.generation !== args.generation ||
+      state.attempt !== args.attempt ||
+      state.status !== "running"
+    ) {
+      return { deleted: 0, hasMore: false, stale: true };
+    }
+    const result = await executeCleanupBatch(ctx, {
+      siteId: state.siteId,
+      kind: state.kind as CleanupKind,
+      before: state.before,
+      batchSize: 100,
+    });
+    const now = Date.now();
+    const policy = result.hasMore
+      ? null
+      : await ctx.db
+          .query("retentionPolicies")
+          .withIndex("by_siteId", (range) => range.eq("siteId", state.siteId))
+          .unique();
+    const nextCycleAt = policy ? now + RETENTION_POLICY_INTERVAL_MS : undefined;
+    await ctx.db.patch("retentionStates", state._id, {
+      status: result.hasMore ? "pending" : "complete",
+      leaseExpiresAt: undefined,
+      scheduledAt: result.hasMore ? now : nextCycleAt,
+      deleted: state.deleted + result.deleted,
+      updatedAt: now,
+    });
+    await recordRetentionBoundary(
       ctx,
-      args.siteId,
-      args.kind,
-      args.before,
-      effectiveBatchSize + 1,
+      state.siteId,
+      state.kind as CleanupKind,
+      state.before,
     );
-    for (const remove of deletions.slice(0, effectiveBatchSize)) {
-      await remove();
+    if (result.hasMore) {
+      await ctx.scheduler.runAfter(0, internal.retention.runScheduled, {
+        stateId: state._id,
+        generation: state.generation,
+      });
+    } else if (nextCycleAt !== undefined) {
+      await ctx.scheduler.runAt(
+        nextCycleAt,
+        internal.retention.startScheduledCycle,
+        { stateId: state._id, generation: state.generation },
+      );
     }
+    return { ...result, stale: false };
+  },
+});
+
+export const startScheduledCycle = internalMutation({
+  args: { stateId: v.id("retentionStates"), generation: v.number() },
+  returns: v.object({
+    started: v.boolean(),
+    stale: v.boolean(),
+    before: v.union(v.number(), v.null()),
+  }),
+  handler: async (ctx, args) => {
+    const state = await ctx.db.get("retentionStates", args.stateId);
+    const now = Date.now();
+    if (
+      !state ||
+      state.generation !== args.generation ||
+      state.status !== "complete" ||
+      (state.scheduledAt !== undefined && state.scheduledAt > now)
+    ) {
+      return { started: false, stale: true, before: null };
+    }
+    const policy = await ctx.db
+      .query("retentionPolicies")
+      .withIndex("by_siteId", (range) => range.eq("siteId", state.siteId))
+      .unique();
+    if (!policy) return { started: false, stale: true, before: null };
+    const kind = state.kind as CleanupKind;
+    const before = safeCleanupBoundary(
+      kind,
+      now - retentionDaysForKind(policy, kind) * DAY_MS,
+      now,
+    );
+    await ctx.db.patch("retentionStates", state._id, {
+      before,
+      status: "pending",
+      attempt: 0,
+      leaseExpiresAt: undefined,
+      scheduledAt: now,
+      deleted: 0,
+      updatedAt: now,
+    });
+    await ctx.scheduler.runAfter(0, internal.retention.runScheduled, {
+      stateId: state._id,
+      generation: state.generation,
+    });
+    return { started: true, stale: false, before };
+  },
+});
+
+export const status = query({
+  args: { siteId: v.id("sites") },
+  returns: v.object({
+    policy: v.union(
+      policyValidator.extend({ updatedAt: v.number() }),
+      v.null(),
+    ),
+    jobs: v.array(
+      v.object({
+        kind: cleanupKindValidator,
+        before: v.number(),
+        status: v.union(
+          v.literal("pending"),
+          v.literal("running"),
+          v.literal("complete"),
+        ),
+        deleted: v.number(),
+        scheduledAt: v.union(v.number(), v.null()),
+        updatedAt: v.number(),
+      }),
+    ),
+    backlog: v.number(),
+  }),
+  handler: async (ctx, args) => {
+    const policy = await ctx.db
+      .query("retentionPolicies")
+      .withIndex("by_siteId", (range) => range.eq("siteId", args.siteId))
+      .unique();
+    const jobs = await ctx.db
+      .query("retentionStates")
+      .withIndex("by_siteId_and_kind", (range) =>
+        range.eq("siteId", args.siteId),
+      )
+      .take(POLICY_CLEANUP_KINDS.length + 1);
+    const publicJobs = jobs.map(
+      ({ kind, before, status, deleted, scheduledAt, updatedAt }) => ({
+        kind: kind as CleanupKind,
+        before,
+        status,
+        deleted,
+        scheduledAt: scheduledAt ?? null,
+        updatedAt,
+      }),
+    );
     return {
-      deleted: Math.min(deletions.length, effectiveBatchSize),
-      hasMore: deletions.length > effectiveBatchSize,
+      policy: policy
+        ? {
+            eventsDays: policy.eventsDays,
+            sessionsDays: policy.sessionsDays,
+            conversionsDays: policy.conversionsDays,
+            aggregatesDays: policy.aggregatesDays,
+            reportsDays: policy.reportsDays,
+            updatedAt: policy.updatedAt,
+          }
+        : null,
+      jobs: publicJobs,
+      backlog: publicJobs.filter((job) => job.status !== "complete").length,
     };
   },
 });
@@ -75,11 +443,247 @@ type CleanupKind =
   | "funnelProgress"
   | "funnelSteps"
   | "affiliateStats"
+  | "goalRollups"
+  | "funnelRollups"
+  | "affiliateRollups"
+  | "vitalRollups"
+  | "siteMapRollups"
   | "attributions"
   | "liveSessions"
   | "ingestWindows"
   | "siteIngestWindows";
 
+const POLICY_CLEANUP_KINDS: CleanupKind[] = [
+  "events",
+  "sessions",
+  "conversions",
+  "aggregateHour",
+  "aggregateDay",
+  "goalCompletions",
+  "funnelProgress",
+  "funnelSteps",
+  "affiliateStats",
+  "goalRollups",
+  "funnelRollups",
+  "affiliateRollups",
+  "vitalRollups",
+  "siteMapRollups",
+  "attributions",
+  "ingestWindows",
+  "siteIngestWindows",
+];
+
+function validatePolicy(policy: {
+  eventsDays: number;
+  sessionsDays: number;
+  conversionsDays: number;
+  aggregatesDays: number;
+  reportsDays: number;
+}) {
+  for (const [name, days] of Object.entries(policy)) {
+    if (!name.endsWith("Days")) continue;
+    if (!Number.isSafeInteger(days) || days < 1 || days > 3_650) {
+      fail("INVALID_ARGUMENT", `${name} must be an integer between 1 and 3650`);
+    }
+  }
+}
+
+function retentionDaysForKind(
+  policy: {
+    eventsDays: number;
+    sessionsDays: number;
+    conversionsDays: number;
+    aggregatesDays: number;
+    reportsDays: number;
+  },
+  kind: CleanupKind,
+) {
+  if (kind === "events") return policy.eventsDays;
+  if (kind === "sessions") return policy.sessionsDays;
+  if (kind === "conversions") return policy.conversionsDays;
+  if (kind === "aggregateHour" || kind === "aggregateDay") {
+    return policy.aggregatesDays;
+  }
+  return policy.reportsDays;
+}
+
+function safeCleanupBoundary(
+  kind: CleanupKind,
+  requested: number,
+  now: number,
+) {
+  if (!Number.isFinite(requested) || requested < 0) {
+    fail("INVALID_ARGUMENT", "before must be a positive timestamp");
+  }
+  if (kind === "events") return safeBucketBoundary(requested, now, MINUTE_MS);
+  if (kind === "aggregateHour")
+    return safeBucketBoundary(requested, now, HOUR_MS);
+  if (
+    kind === "aggregateDay" ||
+    kind === "funnelSteps" ||
+    kind === "affiliateStats" ||
+    kind === "goalRollups" ||
+    kind === "funnelRollups" ||
+    kind === "affiliateRollups" ||
+    kind === "vitalRollups" ||
+    kind === "siteMapRollups"
+  ) {
+    return safeBucketBoundary(requested, now, DAY_MS);
+  }
+  if (kind === "ingestWindows" || kind === "siteIngestWindows") {
+    return Math.min(
+      Math.floor(requested / RATE_LIMIT_WINDOW_MS) * RATE_LIMIT_WINDOW_MS,
+      Math.floor(now / RATE_LIMIT_WINDOW_MS) * RATE_LIMIT_WINDOW_MS,
+    );
+  }
+  return Math.trunc(requested);
+}
+
+function safeBucketBoundary(
+  requested: number,
+  now: number,
+  intervalMs: number,
+) {
+  return Math.min(
+    Math.floor(requested / intervalMs) * intervalMs,
+    Math.floor(now / intervalMs) * intervalMs,
+  );
+}
+
+async function loadState(
+  ctx: MutationCtx,
+  siteId: Id<"sites">,
+  kind: CleanupKind,
+) {
+  return ctx.db
+    .query("retentionStates")
+    .withIndex("by_siteId_and_kind", (range) =>
+      range.eq("siteId", siteId).eq("kind", kind),
+    )
+    .unique();
+}
+
+async function persistDirectState(
+  ctx: MutationCtx,
+  args: { siteId: Id<"sites">; kind: CleanupKind; before: number },
+  result: { deleted: number; hasMore: boolean },
+) {
+  const now = Date.now();
+  const existing = await loadState(ctx, args.siteId, args.kind);
+  const fields = {
+    siteId: args.siteId,
+    kind: args.kind,
+    before: args.before,
+    status: result.hasMore ? ("pending" as const) : ("complete" as const),
+    generation: (existing?.generation ?? 0) + 1,
+    attempt: 0,
+    deleted:
+      existing?.before === args.before
+        ? existing.deleted + result.deleted
+        : result.deleted,
+    updatedAt: now,
+  };
+  if (existing) {
+    await ctx.db.replace("retentionStates", existing._id, fields);
+  } else {
+    await ctx.db.insert("retentionStates", fields);
+  }
+}
+
+async function recordRetentionBoundary(
+  ctx: MutationCtx,
+  siteId: Id<"sites">,
+  kind: CleanupKind,
+  before: number,
+) {
+  const datasets = coverageDatasetsForKind(kind);
+  if (datasets.length === 0) return;
+  const now = Date.now();
+  const coverage = await ensureAnalyticsControl(
+    ctx,
+    siteId,
+    now,
+    datasets.map((dataset) => ({ dataset, before })),
+  );
+  const retained = coverage.retained.filter(
+    (item) => !datasets.includes(item.dataset),
+  );
+  let changed = retained.length !== coverage.retained.length;
+  for (const dataset of datasets) {
+    const prior =
+      coverage.retained.find((item) => item.dataset === dataset)?.before ?? 0;
+    const next = Math.max(prior, before);
+    retained.push({ dataset, before: next });
+    changed ||= next !== prior;
+  }
+  if (changed) {
+    await ctx.db.patch("analyticsCoverage", coverage._id, {
+      retained,
+      updatedAt: now,
+    });
+  }
+}
+
+function coverageDatasetsForKind(kind: CleanupKind): string[] {
+  if (kind === "events") return ["events"];
+  if (kind === "sessions") return ["sessions"];
+  if (kind === "conversions") return ["conversions"];
+  if (kind === "aggregateHour") return ["overviewHour"];
+  if (kind === "aggregateDay") return ["overviewDay", "overviewLocalDay"];
+  if (kind === "goalCompletions") return ["goalCompletions"];
+  if (kind === "funnelSteps") return ["funnelSteps"];
+  if (kind === "affiliateStats") return ["affiliateStats"];
+  if (kind === "goalRollups") return ["goalRollups"];
+  if (kind === "funnelRollups") return ["funnelRollups"];
+  if (kind === "affiliateRollups") return ["affiliateRollups"];
+  if (kind === "vitalRollups") return ["vitalRollups"];
+  if (kind === "siteMapRollups") return ["siteMapRollups"];
+  return [];
+}
+
+async function executeCleanupBatch(
+  ctx: MutationCtx,
+  args: {
+    siteId: Id<"sites">;
+    kind: CleanupKind;
+    before: number;
+    batchSize?: number;
+  },
+) {
+  const batchSize = args.batchSize ?? 100;
+  if (
+    !Number.isSafeInteger(batchSize) ||
+    batchSize < 1 ||
+    batchSize > MAX_RETENTION_BATCH
+  ) {
+    fail(
+      "INVALID_ARGUMENT",
+      `batchSize must be an integer between 1 and ${MAX_RETENTION_BATCH}`,
+    );
+  }
+  const effectiveBatchSize =
+    args.kind === "events" ? Math.min(batchSize, 32) : batchSize;
+  if (args.kind === "events") {
+    return deleteTelemetryBefore(ctx, {
+      siteId: args.siteId,
+      before: args.before,
+      batchSize: effectiveBatchSize,
+    });
+  }
+  const deletions = await deletionsForCleanup(
+    ctx,
+    args.siteId,
+    args.kind,
+    args.before,
+    effectiveBatchSize + 1,
+  );
+  for (const remove of deletions.slice(0, effectiveBatchSize)) await remove();
+  return {
+    deleted: Math.min(deletions.length, effectiveBatchSize),
+    hasMore: deletions.length > effectiveBatchSize,
+  };
+}
+
 type CleanupDelete = () => Promise<void>;
 
 async function deletionsForCleanup(
@@ -90,94 +694,182 @@ async function deletionsForCleanup(
   limit: number,
 ): Promise<CleanupDelete[]> {
   if (kind === "sessions") {
-    return (await ctx.db
-      .query("sessions")
-      .withIndex("by_siteId_and_lastSeenAt", (range) =>
-        range.eq("siteId", siteId).lt("lastSeenAt", before),
-      )
-      .take(limit)).map((row) => () => ctx.db.delete("sessions", row._id));
+    return (
+      await ctx.db
+        .query("sessions")
+        .withIndex("by_siteId_and_lastSeenAt", (q) =>
+          q.eq("siteId", siteId).lt("lastSeenAt", before),
+        )
+        .take(limit)
+    ).map((row) => () => ctx.db.delete("sessions", row._id));
   }
   if (kind === "conversions") {
-    return (await ctx.db
-      .query("conversions")
-      .withIndex("by_siteId_and_timestamp", (range) =>
-        range.eq("siteId", siteId).lt("timestamp", before),
-      )
-      .take(limit)).map((row) => () => ctx.db.delete("conversions", row._id));
+    return (
+      await ctx.db
+        .query("conversions")
+        .withIndex("by_siteId_and_timestamp", (q) =>
+          q.eq("siteId", siteId).lt("timestamp", before),
+        )
+        .take(limit)
+    ).map((row) => () => ctx.db.delete("conversions", row._id));
   }
   if (kind === "goalCompletions") {
-    return (await ctx.db
-      .query("goalCompletions")
-      .withIndex("by_siteId_and_timestamp", (range) =>
-        range.eq("siteId", siteId).lt("timestamp", before),
-      )
-      .take(limit)).map((row) => () => ctx.db.delete("goalCompletions", row._id));
+    return (
+      await ctx.db
+        .query("goalCompletions")
+        .withIndex("by_siteId_and_timestamp", (q) =>
+          q.eq("siteId", siteId).lt("timestamp", before),
+        )
+        .take(limit)
+    ).map((row) => () => ctx.db.delete("goalCompletions", row._id));
   }
   if (kind === "aggregateHour" || kind === "aggregateDay") {
-    return (await ctx.db
-      .query("aggregateBuckets")
-      .withIndex("by_siteId_and_granularity_and_bucketStart", (range) =>
-        range
-          .eq("siteId", siteId)
-          .eq("granularity", kind === "aggregateHour" ? "hour" : "day")
-          .lt("bucketStart", before),
-      )
-      .take(limit)).map((row) => () => ctx.db.delete("aggregateBuckets", row._id));
+    // The daily kind also retires the site's local-day buckets. Their cutoff
+    // sits a day and an hour earlier than the UTC-aligned one: a local day
+    // may begin almost a day before its UTC counterpart and, across a
+    // fall-back transition, last 25 hours, so this keeps every bucket that
+    // could still contain the cutoff instant.
+    const granularities =
+      kind === "aggregateHour"
+        ? ([["hour", before]] as const)
+        : ([
+            ["day", before],
+            ["localDay", before - DAY_MS - HOUR_MS],
+          ] as const);
+    const deletions: Array<() => Promise<void>> = [];
+    for (const [granularity, cutoff] of granularities) {
+      if (deletions.length >= limit) break;
+      const rows = await ctx.db
+        .query("aggregateBuckets")
+        .withIndex("by_siteId_and_granularity_and_bucketStart", (q) =>
+          q
+            .eq("siteId", siteId)
+            .eq("granularity", granularity)
+            .lt("bucketStart", cutoff),
+        )
+        .take(limit - deletions.length);
+      deletions.push(
+        ...rows.map((row) => () => ctx.db.delete("aggregateBuckets", row._id)),
+      );
+    }
+    return deletions;
   }
   if (kind === "funnelProgress") {
-    return (await ctx.db
-      .query("funnelProgress")
-      .withIndex("by_siteId_and_lastStepAt", (range) =>
-        range.eq("siteId", siteId).lt("lastStepAt", before),
-      )
-      .take(limit)).map((row) => () => ctx.db.delete("funnelProgress", row._id));
+    return (
+      await ctx.db
+        .query("funnelProgress")
+        .withIndex("by_siteId_and_lastStepAt", (q) =>
+          q.eq("siteId", siteId).lt("lastStepAt", before),
+        )
+        .take(limit)
+    ).map((row) => () => ctx.db.delete("funnelProgress", row._id));
   }
   if (kind === "funnelSteps") {
-    return (await ctx.db
-      .query("funnelStepBuckets")
-      .withIndex("by_siteId_and_bucketStart", (range) =>
-        range.eq("siteId", siteId).lt("bucketStart", before),
-      )
-      .take(limit)).map((row) => () => ctx.db.delete("funnelStepBuckets", row._id));
+    return (
+      await ctx.db
+        .query("funnelStepBuckets")
+        .withIndex("by_siteId_and_bucketStart", (q) =>
+          q.eq("siteId", siteId).lt("bucketStart", before),
+        )
+        .take(limit)
+    ).map((row) => () => ctx.db.delete("funnelStepBuckets", row._id));
   }
   if (kind === "affiliateStats") {
-    return (await ctx.db
-      .query("affiliateDailyStats")
-      .withIndex("by_siteId_and_bucketStart", (range) =>
-        range.eq("siteId", siteId).lt("bucketStart", before),
-      )
-      .take(limit)).map((row) => () => ctx.db.delete("affiliateDailyStats", row._id));
+    return (
+      await ctx.db
+        .query("affiliateDailyStats")
+        .withIndex("by_siteId_and_bucketStart", (q) =>
+          q.eq("siteId", siteId).lt("bucketStart", before),
+        )
+        .take(limit)
+    ).map((row) => () => ctx.db.delete("affiliateDailyStats", row._id));
+  }
+  if (kind === "goalRollups") {
+    return (
+      await ctx.db
+        .query("goalDailyRollups")
+        .withIndex("by_siteId_and_bucketStart", (q) =>
+          q.eq("siteId", siteId).lt("bucketStart", before),
+        )
+        .take(limit)
+    ).map((row) => () => ctx.db.delete("goalDailyRollups", row._id));
+  }
+  if (kind === "funnelRollups") {
+    return (
+      await ctx.db
+        .query("funnelDailyRollups")
+        .withIndex("by_siteId_and_bucketStart", (q) =>
+          q.eq("siteId", siteId).lt("bucketStart", before),
+        )
+        .take(limit)
+    ).map((row) => () => ctx.db.delete("funnelDailyRollups", row._id));
+  }
+  if (kind === "affiliateRollups") {
+    return (
+      await ctx.db
+        .query("affiliateDailyRollups")
+        .withIndex("by_siteId_and_bucketStart", (q) =>
+          q.eq("siteId", siteId).lt("bucketStart", before),
+        )
+        .take(limit)
+    ).map((row) => () => ctx.db.delete("affiliateDailyRollups", row._id));
+  }
+  if (kind === "vitalRollups") {
+    return (
+      await ctx.db
+        .query("vitalRollups")
+        .withIndex("by_siteId_and_bucketStart", (q) =>
+          q.eq("siteId", siteId).lt("bucketStart", before),
+        )
+        .take(limit)
+    ).map((row) => () => ctx.db.delete("vitalRollups", row._id));
+  }
+  if (kind === "siteMapRollups") {
+    return (
+      await ctx.db
+        .query("routeDailyRollups")
+        .withIndex("by_siteId_and_bucketStart", (q) =>
+          q.eq("siteId", siteId).lt("bucketStart", before),
+        )
+        .take(limit)
+    ).map((row) => () => ctx.db.delete("routeDailyRollups", row._id));
   }
   if (kind === "attributions") {
-    return (await ctx.db
-      .query("visitorAttributions")
-      .withIndex("by_siteId_and_expiresAt", (range) =>
-        range.eq("siteId", siteId).lt("expiresAt", before),
-      )
-      .take(limit)).map((row) => () =>
-        ctx.db.delete("visitorAttributions", row._id),
-      );
+    return (
+      await ctx.db
+        .query("visitorAttributions")
+        .withIndex("by_siteId_and_expiresAt", (q) =>
+          q.eq("siteId", siteId).lt("expiresAt", before),
+        )
+        .take(limit)
+    ).map((row) => () => ctx.db.delete("visitorAttributions", row._id));
   }
   if (kind === "liveSessions") {
-    return (await ctx.db
-      .query("liveSessions")
-      .withIndex("by_siteId_and_expiresAt", (range) =>
-        range.eq("siteId", siteId).lt("expiresAt", before),
-      )
-      .take(limit)).map((row) => () => ctx.db.delete("liveSessions", row._id));
+    return (
+      await ctx.db
+        .query("liveSessions")
+        .withIndex("by_siteId_and_expiresAt", (q) =>
+          q.eq("siteId", siteId).lt("expiresAt", before),
+        )
+        .take(limit)
+    ).map((row) => () => ctx.db.delete("liveSessions", row._id));
   }
   if (kind === "siteIngestWindows") {
-    return (await ctx.db
-      .query("siteIngestWindows")
-      .withIndex("by_siteId_and_updatedAt", (range) =>
-        range.eq("siteId", siteId).lt("updatedAt", before),
-      )
-      .take(limit)).map((row) => () => ctx.db.delete("siteIngestWindows", row._id));
+    return (
+      await ctx.db
+        .query("siteIngestWindows")
+        .withIndex("by_siteId_and_updatedAt", (q) =>
+          q.eq("siteId", siteId).lt("updatedAt", before),
+        )
+        .take(limit)
+    ).map((row) => () => ctx.db.delete("siteIngestWindows", row._id));
   }
-  return (await ctx.db
-    .query("ingestWindows")
-    .withIndex("by_siteId_and_updatedAt", (range) =>
-      range.eq("siteId", siteId).lt("updatedAt", before),
-    )
-    .take(limit)).map((row) => () => ctx.db.delete("ingestWindows", row._id));
+  return (
+    await ctx.db
+      .query("ingestWindows")
+      .withIndex("by_siteId_and_updatedAt", (q) =>
+        q.eq("siteId", siteId).lt("updatedAt", before),
+      )
+      .take(limit)
+  ).map((row) => () => ctx.db.delete("ingestWindows", row._id));
 }