@gscdump/engine 0.40.2 → 1.0.0

package/dist/index.d.mts

@@ -1,6 +1,7 @@
 import { CodecCtx, CompactionThresholds, CompactionTier, DataSource, EngineOptions, FileSetRef, GcCtx, Grain, ListLiveFilter, LockScope, ManifestEntry, ManifestPurgeResult, ManifestStore, ParquetCodec, PurgeFilter, PurgeResult, PurgeUrlsResult, QueryCtx, QueryExecuteOptions, QueryExecuteResult, QueryExecutor, QueryProfiler, QueryResult, QuerySpan, Row, RunSQLOptions, SearchType, StorageEngine, SyncState, SyncStateDetail, SyncStateFilter, SyncStateKind, SyncStateScope, TableName, TenantCtx, Watermark, WatermarkFilter, WatermarkScope, WriteCtx, WriteResult, enumeratePartitions } from "./_chunks/storage.mjs";
-import { DuckDBFactory, DuckDBHandle, canonicalEmptyParquetSchema, createDuckDBCodec, createDuckDBExecutor } from "./_chunks/duckdb.mjs";
+import { DuckDBFactory, DuckDBHandle, createDuckDBCodec, createDuckDBExecutor } from "./_chunks/duckdb.mjs";
 import { ColumnDef, ColumnType, DrizzleSchema, SCHEMAS, TABLE_METADATA, TableSchema, allTables, countries, currentSchemaVersion, dates, dimensionToColumn, drizzleSchema, hourly_pages, inferTable, page_queries, pages, queries } from "./_chunks/schema.mjs";
+import { SnapshotIndex } from "./_chunks/snapshot.mjs";
 import { EngineError, EngineErrorKind, engineErrorToException, engineErrors, isEngineError } from "./_chunks/errors.mjs";
 import { InspectionVerdict, SchedulePolicy, ScheduleState, fixedPolicy, inspectionPolicy, sitemapPolicy } from "./schedule.mjs";
 import { IcebergTableName, Sink, SinkCapabilities, SinkCloseResult, SinkOptions, SinkSlice, SinkWriteResult } from "./_chunks/sink.mjs";
@@ -13,6 +14,86 @@ import { bindLiterals, formatLiteral } from "./sql-bind.mjs";
 import { Result } from "gscdump/result";
 import { SearchType as SearchType$1 } from "gscdump/query";
 import { Grain as Grain$1, Row as Row$1, TableName as TableName$1, TenantCtx as TenantCtx$1 } from "@gscdump/contracts";
+interface R2ObjectMetadata {
+  etag: string;
+}
+interface R2ObjectBody extends R2ObjectMetadata {
+  text: () => Promise<string>;
+}
+interface R2ListResult {
+  objects: Array<{
+    key: string;
+  }>;
+  truncated: boolean;
+  cursor?: string;
+}
+interface R2ConditionalPutOptions {
+  /**
+   * Workers-binding-style precondition. `etagMatches` rejects with `null`
+   *  return on mismatch; `etagDoesNotMatch: '*'` rejects if the key exists.
+   */
+  onlyIf?: {
+    etagMatches?: string;
+    etagDoesNotMatch?: string;
+  };
+}
+/**
+ * Minimal Cloudflare R2 binding shape needed for the manifest CAS loop.
+ * Structurally compatible with Cloudflare's `R2Bucket` Workers API.
+ */
+interface R2ManifestBucketLike {
+  get: (key: string) => Promise<R2ObjectBody | null>;
+  put: (key: string, bytes: string | Uint8Array, options?: R2ConditionalPutOptions) => Promise<R2ObjectMetadata | null>;
+  list: (options?: {
+    prefix?: string;
+    cursor?: string;
+    limit?: number;
+  }) => Promise<R2ListResult>;
+  /**
+   * Bulk delete. Required by {@link ManifestStore.purgeTenant}. Cloudflare's
+   * `R2Bucket.delete` accepts a single key or a string[] batch; both shapes
+   * work here.
+   */
+  delete: (keys: string | string[]) => Promise<void>;
+}
+/**
+ * CAS lifecycle events emitted by the manifest store. Consumers wire these
+ * into metrics (prom-client, console.table, the contention harness) to
+ * measure rejection rate and latency under real R2 load.
+ */
+type R2ManifestEvent = {
+  kind: 'cas-attempt';
+  siteId: string;
+  table: TableName;
+  attempt: number;
+} | {
+  kind: 'cas-rejected';
+  siteId: string;
+  table: TableName;
+  attempt: number;
+} | {
+  kind: 'cas-committed';
+  siteId: string;
+  table: TableName;
+  attempts: number;
+};
+interface CreateR2ManifestStoreOptions {
+  bucket: R2ManifestBucketLike;
+  /** Tenant scope. All shard keys are prefixed `u_<userId>/manifest/...`. */
+  userId: string;
+  /** Override the snapshot version-id generator. Defaults to `${ts}-${random}`. */
+  newSnapshotId?: () => string;
+  now?: () => number;
+  /** Maximum CAS retries before giving up. Defaults to 8. */
+  maxRetries?: number;
+  /**
+   * Optional telemetry hook. Fired synchronously from the CAS loop on each
+   * attempt, rejection, and successful commit. Must not throw; exceptions
+   * propagate and will fail the mutation.
+   */
+  onEvent?: (event: R2ManifestEvent) => void;
+}
+declare function createR2ManifestStore(opts: CreateR2ManifestStoreOptions): ManifestStore;
 declare function coerceRow(row: Row$1): Row$1;
 declare function coerceRows(rows: readonly Row$1[]): Row$1[];
 declare const MAX_DAY_BYTES: number;
@@ -208,4 +289,4 @@ declare const MIN_SYNC_IMPRESSIONS = 1;
 declare const MIN_COUNTRY_IMPRESSIONS = 10;
 declare const MAX_SITEMAP_URLS_PER_SITE = 50000;
 declare const MAX_TRACKED_URLS_PER_SITE = 200000;
-export { type CodecCtx, type ColumnDef, type ColumnType, type CompactionThresholds, type CompactionTier, type CreateIngestAccumulatorOptions, DEFAULT_SEARCH_TYPE, type DataSource, type DateWeight, type DrizzleSchema, type DuckDBFactory, type DuckDBHandle, ENGINE_QUERY_CAPABILITIES, EngineError, EngineErrorKind, type EngineOptions, FILES_PLACEHOLDER, type FileSetRef, type FinalizeOptions, type FinalizeResult, type GcCtx, type Grain, type GscApiRow, type InMemorySink, type IngestAccumulator, type IngestAccumulatorCtx, type IngestAccumulatorEngine, type IngestAccumulatorHooks, type IngestOptions, type InspectionVerdict, type ListLiveFilter, type LockScope, MAX_DAY_BYTES, MAX_GSC_PAGES_R2, MAX_SITEMAP_URLS_PER_SITE, MAX_TRACKED_URLS_PER_SITE, MIN_COUNTRY_IMPRESSIONS, MIN_SYNC_IMPRESSIONS, type ManifestEntry, type ManifestPurgeResult, type ManifestStore, type ParquetCodec, type PurgeFilter, type PurgeResult, type PurgeUrlsResult, type QueryCtx, type QueryExecuteOptions, type QueryExecuteResult, type QueryExecutor, type QueryProfiler, type QueryResult, type QuerySpan, ROW_LIMIT_R2, type ResolvedQuery, type Row, type RowAccumulator, type RowAccumulatorOptions, type RunSQLOptions, SCHEMAS, type SchedulePolicy, type ScheduleState, type SearchType, type Sink, type SinkCapabilities, type SinkCloseResult, type SinkOptions, type SinkSlice, type SinkWriteResult, type StorageEngine, type StoredRow, type SyncState, type SyncStateDetail, type SyncStateFilter, type SyncStateKind, type SyncStateScope, type SyncTableName, TABLES_BY_SEARCH_TYPE, TABLE_METADATA, TABLE_TIERS, TIER_PRIORITY, type TableName, type TableSchema, type TableTier, type TenantCtx, type TieredTableName, WEIGHT_PRIORITY, type Watermark, type WatermarkFilter, type WatermarkScope, type WriteCtx, type WriteResult, allTables, assembleDatesRow, bindLiterals, canonicalEmptyParquetSchema, coerceRow, coerceRows, collectSpans, countries, createDuckDBCodec, createDuckDBExecutor, createIcebergResolverAdapter, createInMemorySink, createIngestAccumulator, createParquetResolverAdapter, createQueryProfiler, createR2SqlResolverAdapter, createRowAccumulator, createSqlQuerySource, createStorageEngine, currentSchemaVersion, dates, dayPartition, dimensionToColumn, drizzleSchema, engineErrorToException, engineErrors, enumeratePartitions, fixedPolicy, formatLiteral, getDateWeight, getTableTier, getTablesForTier, hourPartition, hourly_pages, inferLegacyTier, inferSearchType, inferTable, inspectionPolicy, isEngineError, objectKey, page_queries, pages, parseEnabledSearchTypes, pgResolverAdapter, queries, rebuildDailyFromHourly, resolveParquetSQL, sitemapPolicy, substituteNamedFiles, toPath, toSumPosition, transformGscRow, validateEnabledSearchTypes, validateEnabledSearchTypesResult };
+export { type CodecCtx, type ColumnDef, type ColumnType, type CompactionThresholds, type CompactionTier, type CreateIngestAccumulatorOptions, type CreateR2ManifestStoreOptions, DEFAULT_SEARCH_TYPE, type DataSource, type DateWeight, type DrizzleSchema, type DuckDBFactory, type DuckDBHandle, ENGINE_QUERY_CAPABILITIES, EngineError, EngineErrorKind, type EngineOptions, FILES_PLACEHOLDER, type FileSetRef, type FinalizeOptions, type FinalizeResult, type GcCtx, type Grain, type GscApiRow, type InMemorySink, type IngestAccumulator, type IngestAccumulatorCtx, type IngestAccumulatorEngine, type IngestAccumulatorHooks, type IngestOptions, type InspectionVerdict, type ListLiveFilter, type LockScope, MAX_DAY_BYTES, MAX_GSC_PAGES_R2, MAX_SITEMAP_URLS_PER_SITE, MAX_TRACKED_URLS_PER_SITE, MIN_COUNTRY_IMPRESSIONS, MIN_SYNC_IMPRESSIONS, type ManifestEntry, type ManifestPurgeResult, type ManifestStore, type ParquetCodec, type PurgeFilter, type PurgeResult, type PurgeUrlsResult, type QueryCtx, type QueryExecuteOptions, type QueryExecuteResult, type QueryExecutor, type QueryProfiler, type QueryResult, type QuerySpan, type R2ManifestBucketLike, type R2ManifestEvent, ROW_LIMIT_R2, type ResolvedQuery, type Row, type RowAccumulator, type RowAccumulatorOptions, type RunSQLOptions, SCHEMAS, type SchedulePolicy, type ScheduleState, type SearchType, type Sink, type SinkCapabilities, type SinkCloseResult, type SinkOptions, type SinkSlice, type SinkWriteResult, type SnapshotIndex, type StorageEngine, type StoredRow, type SyncState, type SyncStateDetail, type SyncStateFilter, type SyncStateKind, type SyncStateScope, type SyncTableName, TABLES_BY_SEARCH_TYPE, TABLE_METADATA, TABLE_TIERS, TIER_PRIORITY, type TableName, type TableSchema, type TableTier, type TenantCtx, type TieredTableName, WEIGHT_PRIORITY, type Watermark, type WatermarkFilter, type WatermarkScope, type WriteCtx, type WriteResult, allTables, assembleDatesRow, bindLiterals, coerceRow, coerceRows, collectSpans, countries, createDuckDBCodec, createDuckDBExecutor, createIcebergResolverAdapter, createInMemorySink, createIngestAccumulator, createParquetResolverAdapter, createQueryProfiler, createR2ManifestStore, createR2SqlResolverAdapter, createRowAccumulator, createSqlQuerySource, createStorageEngine, currentSchemaVersion, dates, dayPartition, dimensionToColumn, drizzleSchema, engineErrorToException, engineErrors, enumeratePartitions, fixedPolicy, formatLiteral, getDateWeight, getTableTier, getTablesForTier, hourPartition, hourly_pages, inferLegacyTier, inferSearchType, inferTable, inspectionPolicy, isEngineError, objectKey, page_queries, pages, parseEnabledSearchTypes, pgResolverAdapter, queries, rebuildDailyFromHourly, resolveParquetSQL, sitemapPolicy, substituteNamedFiles, toPath, toSumPosition, transformGscRow, validateEnabledSearchTypes, validateEnabledSearchTypesResult };

package/dist/index.mjs

@@ -1,11 +1,11 @@
-import { coerceRow, coerceRows } from "./_chunks/coerce.mjs";
+import { engineErrorToException, engineErrors, isEngineError } from "./errors.mjs";
 import { DEFAULT_SEARCH_TYPE, dayPartition, hourPartition, inferLegacyTier, inferSearchType, objectKey } from "./_chunks/layout.mjs";
+import { matchesManifestEntryFilter, matchesSyncStateFilter, matchesWatermarkFilter } from "./_chunks/manifest-store-utils.mjs";
+import { coerceRow, coerceRows } from "./_chunks/coerce.mjs";
 import { SCHEMAS, TABLE_METADATA, allTables, countries, currentSchemaVersion, dates, dimensionToColumn, drizzleSchema, hourly_pages, inferTable, page_queries, pages, queries } from "./_chunks/schema.mjs";
-import { enumeratePartitions } from "./_chunks/compaction.mjs";
-import { FILES_PLACEHOLDER, resolveParquetSQL, substituteNamedFiles } from "./_chunks/parquet-plan.mjs";
-import { engineErrorToException, engineErrors, isEngineError } from "./errors.mjs";
+import { FILES_PLACEHOLDER, enumeratePartitions, resolveParquetSQL, substituteNamedFiles } from "./_chunks/parquet-plan.mjs";
 import { bindLiterals, formatLiteral } from "./sql-bind.mjs";
-import { MAX_DAY_BYTES, canonicalEmptyParquetSchema, createDuckDBCodec, createDuckDBExecutor, createStorageEngine } from "./_chunks/engine.mjs";
+import { MAX_DAY_BYTES, createDuckDBCodec, createDuckDBExecutor, createStorageEngine } from "./_chunks/engine.mjs";
 import { assembleDatesRow, createRowAccumulator, toPath, toSumPosition, transformGscRow } from "./ingest.mjs";
 import "./planner.mjs";
 import { createIcebergResolverAdapter, createParquetResolverAdapter, createR2SqlResolverAdapter, pgResolverAdapter } from "./_chunks/resolver.mjs";
@@ -13,6 +13,365 @@ import { rebuildDailyFromHourly } from "./rollups.mjs";
 import { fixedPolicy, inspectionPolicy, sitemapPolicy } from "./schedule.mjs";
 import { ENGINE_QUERY_CAPABILITIES, createSqlQuerySource } from "./_chunks/source.mjs";
 import { err, ok, unwrapResult } from "gscdump/result";
+const SHARD_RE = /^u_[^/]+\/manifest\/(?<siteId>[^/]+)\/(?<table>[^/]+)\/HEAD$/;
+const CAS_BACKOFF_BASE_MS = 5;
+const CAS_BACKOFF_CAP_MS = 250;
+const SHARD_IO_CONCURRENCY = 8;
+const R2_DELETE_BATCH_SIZE = 1e3;
+async function casBackoff(attempt) {
+	const ceil = Math.min(CAS_BACKOFF_CAP_MS, CAS_BACKOFF_BASE_MS * 2 ** attempt);
+	await new Promise((resolve) => setTimeout(resolve, Math.random() * ceil));
+}
+async function mapWithConcurrency(items, concurrency, fn) {
+	if (items.length === 0) return [];
+	const workerCount = Math.max(1, Math.min(items.length, Math.floor(concurrency)));
+	const results = Array.from({ length: items.length }, () => void 0);
+	let nextIndex = 0;
+	async function worker() {
+		while (true) {
+			const index = nextIndex++;
+			if (index >= items.length) return;
+			results[index] = await fn(items[index], index);
+		}
+	}
+	await Promise.all(Array.from({ length: workerCount }, worker));
+	return results;
+}
+function defaultSnapshotId() {
+	return `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function shardPrefix(userId, siteId, table) {
+	return `u_${userId}/manifest/${siteId}/${table}/`;
+}
+function headKey(userId, siteId, table) {
+	return `${shardPrefix(userId, siteId, table)}HEAD`;
+}
+function snapshotKey(userId, siteId, table, snapshotId) {
+	return `${shardPrefix(userId, siteId, table)}v${snapshotId}.json`;
+}
+function emptySnapshot() {
+	return {
+		version: 1,
+		entries: [],
+		watermarks: [],
+		syncStates: []
+	};
+}
+function shardScopesFromEntries(entries) {
+	const out = /* @__PURE__ */ new Set();
+	for (const e of entries) {
+		if (e.siteId === void 0) throw new Error("R2 manifest store requires entries to carry siteId; cross-site entries are unshardable");
+		out.add(`${e.siteId}\0${e.table}`);
+	}
+	return out;
+}
+function createR2ManifestStore(opts) {
+	const { bucket, userId } = opts;
+	const newSnapshotId = opts.newSnapshotId ?? defaultSnapshotId;
+	const now = opts.now ?? (() => Date.now());
+	const maxRetries = opts.maxRetries ?? 16;
+	const onEvent = opts.onEvent;
+	async function readShard(siteId, table) {
+		const head = await bucket.get(headKey(userId, siteId, table));
+		if (!head) return {
+			snapshot: emptySnapshot(),
+			headEtag: void 0
+		};
+		const snapshotId = (await head.text()).trim();
+		if (!snapshotId) return {
+			snapshot: emptySnapshot(),
+			headEtag: head.etag
+		};
+		const snap = await bucket.get(snapshotKey(userId, siteId, table, snapshotId));
+		if (!snap) return {
+			snapshot: emptySnapshot(),
+			headEtag: head.etag
+		};
+		const parsed = JSON.parse(await snap.text());
+		if (parsed.version !== 1) throw new Error(`unsupported manifest snapshot version: ${parsed.version}`);
+		return {
+			snapshot: parsed,
+			headEtag: head.etag
+		};
+	}
+	async function writeShardResult(siteId, table, snapshot, headEtag, attempt) {
+		const id = newSnapshotId();
+		const snapKey = snapshotKey(userId, siteId, table, id);
+		await bucket.put(snapKey, JSON.stringify(snapshot));
+		const conditional = headEtag ? { onlyIf: { etagMatches: headEtag } } : { onlyIf: { etagDoesNotMatch: "*" } };
+		return await bucket.put(headKey(userId, siteId, table), id, conditional) !== null ? ok(void 0) : err(engineErrors.manifestCasRoundLost(siteId, table, attempt));
+	}
+	async function mutateShardResult(siteId, table, mutate) {
+		let attempt = 0;
+		while (attempt < maxRetries) {
+			onEvent?.({
+				kind: "cas-attempt",
+				siteId,
+				table,
+				attempt
+			});
+			const { snapshot, headEtag } = await readShard(siteId, table);
+			await mutate(snapshot);
+			const round = await writeShardResult(siteId, table, snapshot, headEtag, attempt);
+			if (round.ok) {
+				onEvent?.({
+					kind: "cas-committed",
+					siteId,
+					table,
+					attempts: attempt + 1
+				});
+				return round;
+			}
+			onEvent?.({
+				kind: "cas-rejected",
+				siteId,
+				table,
+				attempt
+			});
+			attempt++;
+			if (attempt < maxRetries) await casBackoff(attempt);
+		}
+		return err(engineErrors.manifestCasExhausted(siteId, table, maxRetries));
+	}
+	async function mutateShard(siteId, table, mutate) {
+		return unwrapResult(await mutateShardResult(siteId, table, mutate), engineErrorToException);
+	}
+	async function listShards(siteId) {
+		const shards = [];
+		let cursor;
+		const prefix = siteId === void 0 ? `u_${userId}/manifest/` : `u_${userId}/manifest/${siteId}/`;
+		do {
+			const res = await bucket.list({
+				prefix,
+				cursor,
+				limit: 1e3
+			});
+			for (const obj of res.objects) {
+				const m = SHARD_RE.exec(obj.key);
+				if (m?.groups) shards.push({
+					siteId: m.groups.siteId,
+					table: m.groups.table
+				});
+			}
+			cursor = res.truncated ? res.cursor : void 0;
+		} while (cursor);
+		return shards;
+	}
+	async function shardsForFilter(filter) {
+		if (filter.siteId !== void 0 && filter.table !== void 0) return [{
+			siteId: filter.siteId,
+			table: filter.table
+		}];
+		return (await listShards(filter.siteId)).filter((s) => (filter.siteId === void 0 || s.siteId === filter.siteId) && (filter.table === void 0 || s.table === filter.table));
+	}
+	function assertScopedUser(got, op) {
+		if (got !== userId) throw new Error(`${op}: R2 manifest store is scoped to userId=${userId}, got ${got}`);
+	}
+	async function readEntriesAcrossShards(filter, includeRetired) {
+		assertScopedUser(filter.userId, includeRetired ? "listAll" : "listLive");
+		return (await mapWithConcurrency(await shardsForFilter(filter), SHARD_IO_CONCURRENCY, async ({ siteId, table }) => {
+			const { snapshot } = await readShard(siteId, table);
+			const entries = [];
+			for (const entry of snapshot.entries) {
+				if (!includeRetired && entry.retiredAt !== void 0) continue;
+				if (matchesManifestEntryFilter(entry, filter, { ignoreUserId: true })) entries.push(entry);
+			}
+			return entries;
+		})).flat();
+	}
+	function groupBySiteTable(entries) {
+		const out = /* @__PURE__ */ new Map();
+		for (const e of entries) {
+			const key = `${e.siteId}\0${e.table}`;
+			if (!out.has(key)) out.set(key, []);
+			out.get(key).push(e);
+		}
+		return out;
+	}
+	async function registerVersionsImpl(newEntries, superseding) {
+		if (newEntries.length === 0 && (!superseding || superseding.length === 0)) return;
+		const supersededAt = newEntries[0]?.createdAt ?? now();
+		const byShard = /* @__PURE__ */ new Map();
+		function bucket(entry, kind) {
+			assertScopedUser(entry.userId, "registerVersions");
+			if (entry.siteId === void 0) throw new Error("R2 manifest store requires entries to carry siteId");
+			const key = `${entry.siteId}\0${entry.table}`;
+			let bag = byShard.get(key);
+			if (!bag) {
+				bag = {
+					newEntries: [],
+					superseding: []
+				};
+				byShard.set(key, bag);
+			}
+			if (kind === "new") bag.newEntries.push(entry);
+			else bag.superseding.push(entry);
+		}
+		for (const e of newEntries) bucket(e, "new");
+		if (superseding) for (const e of superseding) bucket(e, "super");
+		await mapWithConcurrency([...byShard], SHARD_IO_CONCURRENCY, async ([shardKey, { newEntries: news, superseding: supers }]) => {
+			const [siteId, table] = shardKey.split("\0");
+			await mutateShard(siteId, table, (snap) => {
+				const byObjectKey = new Map(snap.entries.map((e) => [e.objectKey, e]));
+				for (const s of supers) {
+					const existing = byObjectKey.get(s.objectKey);
+					if (existing && existing.retiredAt === void 0) byObjectKey.set(s.objectKey, {
+						...existing,
+						retiredAt: supersededAt
+					});
+				}
+				for (const n of news) byObjectKey.set(n.objectKey, n);
+				snap.entries = Array.from(byObjectKey.values());
+			});
+		});
+	}
+	return {
+		async listLive(filter) {
+			return readEntriesAcrossShards(filter, false);
+		},
+		async listAll(filter) {
+			return readEntriesAcrossShards(filter, true);
+		},
+		async registerVersion(entry, superseding) {
+			return registerVersionsImpl([entry], superseding);
+		},
+		async registerVersions(entries, superseding) {
+			shardScopesFromEntries(entries);
+			return registerVersionsImpl(entries, superseding);
+		},
+		async listRetired(olderThan) {
+			return (await mapWithConcurrency(await listShards(), SHARD_IO_CONCURRENCY, async ({ siteId, table }) => {
+				const { snapshot } = await readShard(siteId, table);
+				const retired = [];
+				for (const e of snapshot.entries) if (e.retiredAt !== void 0 && e.retiredAt <= olderThan) retired.push(e);
+				return retired;
+			})).flat();
+		},
+		async delete(toDelete) {
+			await mapWithConcurrency([...groupBySiteTable(toDelete)], SHARD_IO_CONCURRENCY, async ([shardKey, entries]) => {
+				const [siteId, table] = shardKey.split("\0");
+				await mutateShard(siteId, table, (snap) => {
+					const drop = new Set(entries.map((e) => e.objectKey));
+					snap.entries = snap.entries.filter((e) => !drop.has(e.objectKey));
+				});
+			});
+		},
+		async getWatermarks(filter) {
+			assertScopedUser(filter.userId, "getWatermarks");
+			return (await mapWithConcurrency(await shardsForFilter(filter), SHARD_IO_CONCURRENCY, async ({ siteId, table }) => {
+				const { snapshot } = await readShard(siteId, table);
+				const watermarks = [];
+				for (const w of snapshot.watermarks) if (matchesWatermarkFilter(w, filter, { ignoreUserId: true })) watermarks.push(w);
+				return watermarks;
+			})).flat();
+		},
+		async bumpWatermark(scope, date, at) {
+			assertScopedUser(scope.userId, "bumpWatermark");
+			if (scope.siteId === void 0) throw new Error("R2 manifest store requires watermarks to carry siteId");
+			const ts = at ?? now();
+			const scopeSearchType = inferSearchType(scope);
+			await mutateShard(scope.siteId, scope.table, (snap) => {
+				const idx = snap.watermarks.findIndex((w) => w.userId === userId && w.siteId === scope.siteId && w.table === scope.table && inferSearchType(w) === scopeSearchType);
+				if (idx === -1) {
+					snap.watermarks.push({
+						userId,
+						siteId: scope.siteId,
+						table: scope.table,
+						...scope.searchType !== void 0 ? { searchType: scope.searchType } : {},
+						newestDateSynced: date,
+						oldestDateSynced: date,
+						lastSyncAt: ts
+					});
+					return;
+				}
+				const w = snap.watermarks[idx];
+				const newest = date > w.newestDateSynced ? date : w.newestDateSynced;
+				const oldest = date < w.oldestDateSynced ? date : w.oldestDateSynced;
+				const lastSyncAt = ts > w.lastSyncAt ? ts : w.lastSyncAt;
+				snap.watermarks[idx] = {
+					...w,
+					newestDateSynced: newest,
+					oldestDateSynced: oldest,
+					lastSyncAt
+				};
+			});
+		},
+		async getSyncStates(filter) {
+			assertScopedUser(filter.userId, "getSyncStates");
+			return (await mapWithConcurrency(await shardsForFilter(filter), SHARD_IO_CONCURRENCY, async ({ siteId, table }) => {
+				const { snapshot } = await readShard(siteId, table);
+				const states = [];
+				for (const s of snapshot.syncStates) if (matchesSyncStateFilter(s, filter, { ignoreUserId: true })) states.push(s);
+				return states;
+			})).flat();
+		},
+		async setSyncState(scope, state, detail) {
+			assertScopedUser(scope.userId, "setSyncState");
+			if (scope.siteId === void 0) throw new Error("R2 manifest store requires sync states to carry siteId");
+			const at = detail?.at ?? now();
+			const scopeSearchType = inferSearchType(scope);
+			await mutateShard(scope.siteId, scope.table, (snap) => {
+				const idx = snap.syncStates.findIndex((s) => s.userId === userId && s.siteId === scope.siteId && s.table === scope.table && s.date === scope.date && inferSearchType(s) === scopeSearchType);
+				if (idx === -1) {
+					snap.syncStates.push({
+						userId,
+						siteId: scope.siteId,
+						table: scope.table,
+						date: scope.date,
+						state,
+						updatedAt: at,
+						attempts: 1,
+						error: detail?.error,
+						...scope.searchType !== void 0 ? { searchType: scope.searchType } : {}
+					});
+					return;
+				}
+				const prev = snap.syncStates[idx];
+				const attempts = state === "inflight" && prev.state !== "inflight" ? prev.attempts + 1 : prev.attempts;
+				const error = state === "done" ? void 0 : detail?.error ?? prev.error;
+				snap.syncStates[idx] = {
+					...prev,
+					state,
+					updatedAt: at,
+					attempts,
+					error
+				};
+			});
+		},
+		async withLock(_scope, fn) {
+			return fn();
+		},
+		async purgeTenant(filter) {
+			if (filter.userId !== userId) throw new Error(`purgeTenant: store is scoped to userId=${userId}, got ${filter.userId}`);
+			const purged = await mapWithConcurrency(await shardsForFilter({ siteId: filter.siteId }), SHARD_IO_CONCURRENCY, async ({ siteId, table }) => {
+				const { snapshot } = await readShard(siteId, table);
+				const prefix = shardPrefix(userId, siteId, table);
+				const keys = [];
+				let cursor;
+				do {
+					const res = await bucket.list({
+						prefix,
+						cursor,
+						limit: 1e3
+					});
+					for (const obj of res.objects) keys.push(obj.key);
+					cursor = res.truncated ? res.cursor : void 0;
+				} while (cursor);
+				for (let offset = 0; offset < keys.length; offset += R2_DELETE_BATCH_SIZE) await bucket.delete(keys.slice(offset, offset + R2_DELETE_BATCH_SIZE));
+				return {
+					entriesRemoved: snapshot.entries.length,
+					watermarksRemoved: snapshot.watermarks.length,
+					syncStatesRemoved: snapshot.syncStates.length
+				};
+			});
+			return {
+				entriesRemoved: purged.reduce((sum, result) => sum + result.entriesRemoved, 0),
+				watermarksRemoved: purged.reduce((sum, result) => sum + result.watermarksRemoved, 0),
+				syncStatesRemoved: purged.reduce((sum, result) => sum + result.syncStatesRemoved, 0)
+			};
+		}
+	};
+}
 function scopeOf(ctx, table, date) {
 	return {
 		userId: String(ctx.userId),
@@ -315,4 +674,4 @@ const MIN_SYNC_IMPRESSIONS = 1;
 const MIN_COUNTRY_IMPRESSIONS = 10;
 const MAX_SITEMAP_URLS_PER_SITE = 5e4;
 const MAX_TRACKED_URLS_PER_SITE = 2e5;
-export { DEFAULT_SEARCH_TYPE, ENGINE_QUERY_CAPABILITIES, FILES_PLACEHOLDER, MAX_DAY_BYTES, MAX_GSC_PAGES_R2, MAX_SITEMAP_URLS_PER_SITE, MAX_TRACKED_URLS_PER_SITE, MIN_COUNTRY_IMPRESSIONS, MIN_SYNC_IMPRESSIONS, ROW_LIMIT_R2, SCHEMAS, TABLES_BY_SEARCH_TYPE, TABLE_METADATA, TABLE_TIERS, TIER_PRIORITY, WEIGHT_PRIORITY, allTables, assembleDatesRow, bindLiterals, canonicalEmptyParquetSchema, coerceRow, coerceRows, collectSpans, countries, createDuckDBCodec, createDuckDBExecutor, createIcebergResolverAdapter, createInMemorySink, createIngestAccumulator, createParquetResolverAdapter, createQueryProfiler, createR2SqlResolverAdapter, createRowAccumulator, createSqlQuerySource, createStorageEngine, currentSchemaVersion, dates, dayPartition, dimensionToColumn, drizzleSchema, engineErrorToException, engineErrors, enumeratePartitions, fixedPolicy, formatLiteral, getDateWeight, getTableTier, getTablesForTier, hourPartition, hourly_pages, inferLegacyTier, inferSearchType, inferTable, inspectionPolicy, isEngineError, objectKey, page_queries, pages, parseEnabledSearchTypes, pgResolverAdapter, queries, rebuildDailyFromHourly, resolveParquetSQL, sitemapPolicy, substituteNamedFiles, toPath, toSumPosition, transformGscRow, validateEnabledSearchTypes, validateEnabledSearchTypesResult };
+export { DEFAULT_SEARCH_TYPE, ENGINE_QUERY_CAPABILITIES, FILES_PLACEHOLDER, MAX_DAY_BYTES, MAX_GSC_PAGES_R2, MAX_SITEMAP_URLS_PER_SITE, MAX_TRACKED_URLS_PER_SITE, MIN_COUNTRY_IMPRESSIONS, MIN_SYNC_IMPRESSIONS, ROW_LIMIT_R2, SCHEMAS, TABLES_BY_SEARCH_TYPE, TABLE_METADATA, TABLE_TIERS, TIER_PRIORITY, WEIGHT_PRIORITY, allTables, assembleDatesRow, bindLiterals, coerceRow, coerceRows, collectSpans, countries, createDuckDBCodec, createDuckDBExecutor, createIcebergResolverAdapter, createInMemorySink, createIngestAccumulator, createParquetResolverAdapter, createQueryProfiler, createR2ManifestStore, createR2SqlResolverAdapter, createRowAccumulator, createSqlQuerySource, createStorageEngine, currentSchemaVersion, dates, dayPartition, dimensionToColumn, drizzleSchema, engineErrorToException, engineErrors, enumeratePartitions, fixedPolicy, formatLiteral, getDateWeight, getTableTier, getTablesForTier, hourPartition, hourly_pages, inferLegacyTier, inferSearchType, inferTable, inspectionPolicy, isEngineError, objectKey, page_queries, pages, parseEnabledSearchTypes, pgResolverAdapter, queries, rebuildDailyFromHourly, resolveParquetSQL, sitemapPolicy, substituteNamedFiles, toPath, toSumPosition, transformGscRow, validateEnabledSearchTypes, validateEnabledSearchTypesResult };

package/dist/period/index.d.mts

@@ -1,2 +1,2 @@
-import { AnalysisPeriod, ComparisonMode, ComparisonPeriod, PadTimeseriesOptions, ResolveWindowOptions, ResolvedWindow, WindowPreset, comparisonOf, defaultEndDate, defaultStartDate, padTimeseries, periodOf, resolveWindow } from "../_chunks/index2.mjs";
-export { AnalysisPeriod, ComparisonMode, ComparisonPeriod, PadTimeseriesOptions, ResolveWindowOptions, ResolvedWindow, WindowPreset, comparisonOf, defaultEndDate, defaultStartDate, padTimeseries, periodOf, resolveWindow };
+import { AnalysisPeriod, ComparisonMode, ComparisonPeriod, PadTimeseriesOptions, ResolveWindowOptions, ResolvedWindow, WindowPreset, comparisonOf, defaultEndDate, padTimeseries, periodOf, resolveWindow } from "../_chunks/index2.mjs";
+export { AnalysisPeriod, ComparisonMode, ComparisonPeriod, PadTimeseriesOptions, ResolveWindowOptions, ResolvedWindow, WindowPreset, comparisonOf, defaultEndDate, padTimeseries, periodOf, resolveWindow };

package/dist/period/index.mjs

@@ -128,4 +128,4 @@ function padTimeseries(rows, options) {
 	}
 	return result;
 }
-export { comparisonOf, defaultEndDate, defaultStartDate, padTimeseries, periodOf, resolveWindow };
+export { comparisonOf, defaultEndDate, padTimeseries, periodOf, resolveWindow };

package/dist/planner.mjs

@@ -1,3 +1,2 @@
-import { enumeratePartitions } from "./_chunks/compaction.mjs";
-import { FILES_PLACEHOLDER, compileLogicalQueryPlan, resolveParquetSQL, substituteNamedFiles } from "./_chunks/parquet-plan.mjs";
+import { FILES_PLACEHOLDER, compileLogicalQueryPlan, enumeratePartitions, resolveParquetSQL, substituteNamedFiles } from "./_chunks/parquet-plan.mjs";
 export { FILES_PLACEHOLDER, compileLogicalQueryPlan, enumeratePartitions, resolveParquetSQL, substituteNamedFiles };

package/dist/resolver/index.d.mts

@@ -1,7 +1,7 @@
 import { SearchType as SearchType$1, TableName as TableName$1 } from "../_chunks/storage.mjs";
 import { ComparisonFilter, ExtraQuery, ResolvedComparisonSQL, ResolvedSQL, ResolvedSQLOptimized, ResolverAdapter, ResolverOptions } from "../_chunks/types.mjs";
 import { PgTableKey, R2SqlResolverAdapterOptions, ResolverAdapterOptions, createIcebergResolverAdapter, createParquetResolverAdapter, createR2SqlResolverAdapter, pgResolverAdapter } from "../_chunks/pg-adapter.mjs";
-import { LogicalDataset, LogicalDataset as LogicalDataset$1, LogicalQueryPlan, PlannerCapabilities, UnresolvableDatasetError, inferDataset as inferLogicalDataset, isDatasetResolvable } from "gscdump/query/plan";
+import { LogicalDataset, LogicalDataset as LogicalDataset$1, PlannerCapabilities, UnresolvableDatasetError, inferDataset as inferLogicalDataset, isDatasetResolvable } from "gscdump/query/plan";
 import { SQL } from "drizzle-orm";
 import { BuilderState, Dimension, FilterInput, InternalFilter, Metric } from "gscdump/query";
 import { Grain, TableName } from "@gscdump/contracts";
@@ -81,13 +81,6 @@ interface CreateResolverAdapterConfig<TableKey extends string> extends SqlFragme
   capabilities: PlannerCapabilities;
 }
 declare function createResolverAdapter<TableKey extends string>(config: CreateResolverAdapterConfig<TableKey>): ResolverAdapter<TableKey>;
-/**
- * True when `plan` can be served from the canonical-grained rollup instead of
- * the raw `queries` fact partitions. Conservative: anything that would read a
- * dropped column or the raw row grain disqualifies the query. Callers decide
- * whether that miss is a typed raw fallback or a hard coverage error.
- */
-declare function planCoveredByCanonicalRollup(plan: LogicalQueryPlan): boolean;
 /** State-level convenience: build the plan then gate. */
 declare function canonicalRollupCovers(state: BuilderState, capabilities: PlannerCapabilities): boolean;
 declare function resolveToSQLOptimized<TK extends string>(state: BuilderState, options: ResolverOptions<TK>): ResolvedSQLOptimized;
@@ -324,4 +317,4 @@ interface AssertSchemaInSyncOptions {
   mode: 'exact' | 'superset';
 }
 declare function assertSchemaInSync(options: AssertSchemaInSyncOptions): void;
-export { type AssertSchemaInSyncOptions, type CanonicalQueryDimSource, type ComparisonFilter, type ComparisonQueryResult, type CreateResolverAdapterConfig, DIMENSION_SURFACES, type DimensionBinding, type DimensionSurface, type ExtraQuery, LOGICAL_DATASETS, type LogicalDataset, type LogicalDatasetDefinition, type OptimizedQueryResult, type PgTableKey, type PrimaryColumnarSource, QuerySourceCoverageError, type QuerySourceDecision, type QuerySourceFallback, type QuerySourceFallbackKind, type QuerySourceKind, type R2SqlResolverAdapterOptions, type ResolveExtraFn, type ResolvedComparisonSQL, type ResolvedSQL, type ResolvedSQLOptimized, type ResolverAdapter, type ResolverAdapterOptions, type ResolverOptions, type RollupRowsReader, type RunOptimizedQueryOptions, type RunQueryCtx, type RunSQLFn, type SqlFragments, type SqlFragmentsConfig, UnresolvableDatasetError, assertDimensionsSupported, assertSchemaInSync, buildExtrasQueries, buildTotalsSql, canonicalRollupCovers, createIcebergResolverAdapter, createParquetResolverAdapter, createR2SqlResolverAdapter, createResolverAdapter, createRollupExtrasOverlay, createSqlFragments, dimensionColumn, dimensionValue, getDimensionFilters, getFilterDimensions, getInternalFilters, inferLogicalDataset, isDatasetResolvable, matchesDimensionFilter, matchesMetricFilter, matchesTopLevelPage, mergeExtras, metricValue, pgResolverAdapter, planCoveredByCanonicalRollup, resolveComparisonSQL, resolveToSQL, resolveToSQLOptimized, runComparisonQuery, runOptimizedQuery, supportsDimensionOnSurface };
+export { type AssertSchemaInSyncOptions, type CanonicalQueryDimSource, type ComparisonFilter, type ComparisonQueryResult, type CreateResolverAdapterConfig, DIMENSION_SURFACES, type DimensionBinding, type DimensionSurface, type ExtraQuery, LOGICAL_DATASETS, type LogicalDataset, type LogicalDatasetDefinition, type OptimizedQueryResult, type PgTableKey, type PrimaryColumnarSource, QuerySourceCoverageError, type QuerySourceDecision, type QuerySourceFallback, type QuerySourceFallbackKind, type QuerySourceKind, type R2SqlResolverAdapterOptions, type ResolveExtraFn, type ResolvedComparisonSQL, type ResolvedSQL, type ResolvedSQLOptimized, type ResolverAdapter, type ResolverAdapterOptions, type ResolverOptions, type RollupRowsReader, type RunOptimizedQueryOptions, type RunQueryCtx, type RunSQLFn, type SqlFragments, type SqlFragmentsConfig, UnresolvableDatasetError, assertDimensionsSupported, assertSchemaInSync, buildExtrasQueries, buildTotalsSql, canonicalRollupCovers, createIcebergResolverAdapter, createParquetResolverAdapter, createR2SqlResolverAdapter, createResolverAdapter, createRollupExtrasOverlay, createSqlFragments, dimensionColumn, dimensionValue, getDimensionFilters, getFilterDimensions, getInternalFilters, inferLogicalDataset, isDatasetResolvable, matchesDimensionFilter, matchesMetricFilter, matchesTopLevelPage, mergeExtras, metricValue, pgResolverAdapter, resolveComparisonSQL, resolveToSQL, resolveToSQLOptimized, runComparisonQuery, runOptimizedQuery, supportsDimensionOnSurface };

package/dist/resolver/index.mjs

@@ -1,2 +1,2 @@
-import { DIMENSION_SURFACES, LOGICAL_DATASETS, QuerySourceCoverageError, UnresolvableDatasetError, assertDimensionsSupported, assertSchemaInSync, buildExtrasQueries, buildTotalsSql, canonicalRollupCovers, createIcebergResolverAdapter, createParquetResolverAdapter, createR2SqlResolverAdapter, createResolverAdapter, createRollupExtrasOverlay, createSqlFragments, dimensionColumn, dimensionValue, getDimensionFilters, getFilterDimensions, getInternalFilters, inferLogicalDataset, isDatasetResolvable, matchesDimensionFilter, matchesMetricFilter, matchesTopLevelPage, mergeExtras, metricValue, pgResolverAdapter, planCoveredByCanonicalRollup, resolveComparisonSQL, resolveToSQL, resolveToSQLOptimized, runComparisonQuery, runOptimizedQuery, supportsDimensionOnSurface } from "../_chunks/resolver.mjs";
-export { DIMENSION_SURFACES, LOGICAL_DATASETS, QuerySourceCoverageError, UnresolvableDatasetError, assertDimensionsSupported, assertSchemaInSync, buildExtrasQueries, buildTotalsSql, canonicalRollupCovers, createIcebergResolverAdapter, createParquetResolverAdapter, createR2SqlResolverAdapter, createResolverAdapter, createRollupExtrasOverlay, createSqlFragments, dimensionColumn, dimensionValue, getDimensionFilters, getFilterDimensions, getInternalFilters, inferLogicalDataset, isDatasetResolvable, matchesDimensionFilter, matchesMetricFilter, matchesTopLevelPage, mergeExtras, metricValue, pgResolverAdapter, planCoveredByCanonicalRollup, resolveComparisonSQL, resolveToSQL, resolveToSQLOptimized, runComparisonQuery, runOptimizedQuery, supportsDimensionOnSurface };
+import { DIMENSION_SURFACES, LOGICAL_DATASETS, QuerySourceCoverageError, UnresolvableDatasetError, assertDimensionsSupported, assertSchemaInSync, buildExtrasQueries, buildTotalsSql, canonicalRollupCovers, createIcebergResolverAdapter, createParquetResolverAdapter, createR2SqlResolverAdapter, createResolverAdapter, createRollupExtrasOverlay, createSqlFragments, dimensionColumn, dimensionValue, getDimensionFilters, getFilterDimensions, getInternalFilters, inferLogicalDataset, isDatasetResolvable, matchesDimensionFilter, matchesMetricFilter, matchesTopLevelPage, mergeExtras, metricValue, pgResolverAdapter, resolveComparisonSQL, resolveToSQL, resolveToSQLOptimized, runComparisonQuery, runOptimizedQuery, supportsDimensionOnSurface } from "../_chunks/resolver.mjs";
+export { DIMENSION_SURFACES, LOGICAL_DATASETS, QuerySourceCoverageError, UnresolvableDatasetError, assertDimensionsSupported, assertSchemaInSync, buildExtrasQueries, buildTotalsSql, canonicalRollupCovers, createIcebergResolverAdapter, createParquetResolverAdapter, createR2SqlResolverAdapter, createResolverAdapter, createRollupExtrasOverlay, createSqlFragments, dimensionColumn, dimensionValue, getDimensionFilters, getFilterDimensions, getInternalFilters, inferLogicalDataset, isDatasetResolvable, matchesDimensionFilter, matchesMetricFilter, matchesTopLevelPage, mergeExtras, metricValue, pgResolverAdapter, resolveComparisonSQL, resolveToSQL, resolveToSQLOptimized, runComparisonQuery, runOptimizedQuery, supportsDimensionOnSurface };

package/dist/rollups.d.mts

@@ -1,5 +1,5 @@
 import { DataSource, FileSetRef, Row as Row$1, TableName as TableName$1 } from "./_chunks/storage.mjs";
-import { ColumnDef as ColumnDef$1 } from "./_chunks/schema.mjs";
+import { ColumnDef } from "./_chunks/schema.mjs";
 import { EngineError } from "./_chunks/errors.mjs";
 import "./_chunks/contracts.mjs";
 import { SearchType } from "gscdump/query";
@@ -71,7 +71,7 @@ interface RollupDef {
    * Types map the same way as the fact-table encoder: VARCHAR / DATE go
    * through BYTE_ARRAY/UTF8; BIGINT → INT64; INTEGER → INT32; DOUBLE → DOUBLE.
    */
-  parquetColumns?: readonly ColumnDef$1[];
+  parquetColumns?: readonly ColumnDef[];
   /** Sort-key column names for parquet row-group stats. Optional. */
   parquetSortKey?: readonly string[];
   /**
@@ -231,16 +231,6 @@ declare const WINDOW_BYTE_BUDGET: number;
 declare const ROLLUP_PAGE_ROWS = 50000;
 declare const ROLLUP_PAGE_ROWS_WIDE = 20000;
 declare const ROLLUP_PAGE_ROWS_DAILY = 70000;
-declare const DAILY_MAX_WINDOW_DAYS = 7;
-/**
- * UTC day-aligned [startMs, endMs] span a partition covers. Returns null for
- * `hourly/` partitions and anything unrecognised — those are excluded from
- * windowed planning.
- */
-declare function partitionDaySpan(partition: string): {
-  startMs: number;
-  endMs: number;
-} | null;
 /**
  * Plan byte-bounded windows over a partition set. Each window names the
  * partitions whose span intersects it; a coarse tier file can land in two
@@ -257,11 +247,6 @@ declare function planRollupWindows(parts: Array<{
   end: string;
   partitions: string[];
 }>;
-/** Partition strings whose span intersects the inclusive [start, end] date range. */
-declare function partitionsInRange(parts: Array<{
-  partition: string;
-  bytes: number;
-}>, start: string, end: string): string[];
 /**
  * Run a full-history aggregation in byte-bounded windows and concat the rows.
  * Each window's SQL MUST date-filter to `[w.start, w.end]` (see `sqlFor`) so a
@@ -322,8 +307,6 @@ declare const topPages28dRollup: RollupDef;
  * spinning up DuckDB-WASM.
  */
 declare const topCountries28dRollup: RollupDef;
-/** Top 1000 keywords by clicks over the trailing 28-day window. */
-declare const topKeywords28dRollup: RollupDef;
 /**
  * Parquet-format companion to `topKeywords28dRollup`. Same shape, but persists
  * as a parquet object plus JSON sidecar pointer so widgets that need
@@ -485,4 +468,4 @@ declare const DEFAULT_ROLLUPS: readonly RollupDef[];
  * (CLI: `gscdump rollups --with-canonical`).
  */
 declare const CANONICAL_ROLLUPS: readonly RollupDef[];
-export { CANONICAL_ROLLUPS, DAILY_MAX_WINDOW_DAYS, DEFAULT_ROLLUPS, ParquetRollupPointer, ROLLUP_PAGE_ROWS, ROLLUP_PAGE_ROWS_DAILY, ROLLUP_PAGE_ROWS_WIDE, RebuildDailyFromHourlyOptions, RebuildRollupResult, RebuildRollupsOptions, RollupBucket, RollupCtx, RollupDef, RollupEngine, RollupEnvelope, WINDOW_BYTE_BUDGET, dailyTotalsRollup, indexPercentRollup, indexingHealthRollup, indexingMetadataRollup, partitionDaySpan, partitionsInRange, planRollupWindows, queryCanonicalDailyRollup, queryCanonicalVariantsRollup, readLatestRollup, rebuildCanonicalDailyResumable, rebuildDailyFromHourly, rebuildRollups, rollupKey, rollupParquetKey, runWindowed, sitemapChanges28dRollup, sitemapHealthRollup, topCountries28dRollup, topKeywords28dParquetRollup, topKeywords28dRollup, topPages28dRollup, weeklyTotalsRollup };
+export { CANONICAL_ROLLUPS, DEFAULT_ROLLUPS, ParquetRollupPointer, ROLLUP_PAGE_ROWS, ROLLUP_PAGE_ROWS_DAILY, ROLLUP_PAGE_ROWS_WIDE, RebuildDailyFromHourlyOptions, RebuildRollupResult, RebuildRollupsOptions, RollupBucket, RollupCtx, RollupDef, RollupEngine, RollupEnvelope, WINDOW_BYTE_BUDGET, dailyTotalsRollup, indexPercentRollup, indexingHealthRollup, indexingMetadataRollup, planRollupWindows, queryCanonicalDailyRollup, queryCanonicalVariantsRollup, readLatestRollup, rebuildCanonicalDailyResumable, rebuildDailyFromHourly, rebuildRollups, rollupKey, rollupParquetKey, runWindowed, sitemapChanges28dRollup, sitemapHealthRollup, topCountries28dRollup, topKeywords28dParquetRollup, topPages28dRollup, weeklyTotalsRollup };