@gscdump/engine 1.4.10 → 1.5.0

package/dist/rollups.d.mts

@@ -1,471 +1,8 @@
-import { DataSource, FileSetRef, Row as Row$1, TableName as TableName$1 } from "./storage.mjs";
-import { ColumnDef } from "./schema.mjs";
-import { EngineError } from "./errors.mjs";
-import "./contracts.mjs";
-import { TenantCtx } from "@gscdump/contracts";
-import { SearchType } from "gscdump/query";
-interface RollupCtx extends TenantCtx {
-  /** When the rollup was built. Stamped into payload + filename. */
-  builtAt: number;
-}
-/**
- * Tenant-scoped engine surface a rollup builder needs. Subset of
- * `StorageEngine.runSQL` so rollups stay testable without a full engine.
- */
-interface RollupEngine {
-  runSQL: (opts: {
-    ctx: TenantCtx;
-    fileSets: Record<string, FileSetRef>;
-    table?: TableName$1;
-    sql: string;
-    params?: unknown[];
-    /**
-     * Restrict every manifest lookup to a single GSC search-type slice. The
-     * rollup runner forwards `RebuildRollupsOptions.searchType` so the
-     * aggregated facts never mix web + non-web rows. Undefined preserves
-     * the legacy cross-type union (web-only tenants).
-     */
-    searchType?: SearchType;
-  }) => Promise<{
-    rows: Row$1[];
-  }>;
-  /**
-   * Read the live manifest for a (tenant, table[, searchType]) cohort —
-   * cheap, no parquet decode. Builders use this to chunk a full-history scan
-   * into byte-bounded windows (see `WINDOW_BYTE_BUDGET`) so a single `runSQL`
-   * call never ships an oversized Arrow IPC payload across the Workers
-   * service-binding RPC (32MiB hard cap).
-   */
-  listPartitions: (opts: {
-    ctx: TenantCtx;
-    table: TableName$1;
-    searchType?: SearchType;
-  }) => Promise<Array<{
-    partition: string;
-    bytes: number;
-  }>>;
-}
-/**
- * One rollup definition. Build runs SQL over the tenant's facts and/or reads
- * from entity stores via `dataSource`, returning a JSON-serializable payload
- * that the runner timestamps + writes.
- */
-interface RollupDef {
-  id: string;
-  /**
-   * Window in days the rollup covers. `null` means full history. Used by
-   * the runner to populate `windowDays` in the payload metadata so readers
-   * can validate freshness.
-   */
-  windowDays: number | null;
-  /**
-   * Storage format. `'json'` (default) wraps the build payload in a
-   * `RollupEnvelope` and writes as a JSON blob. `'parquet'` expects `build`
-   * to return rows matching `parquetColumns` and writes a parquet file plus
-   * a tiny JSON sidecar envelope that points at it, so metadata
-   * (`builtAt` / `windowDays`) stays readable without decoding parquet.
-   */
-  format?: 'json' | 'parquet';
-  /**
-   * Column schema for parquet output. Required when `format === 'parquet'`.
-   * 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[];
-  /** Sort-key column names for parquet row-group stats. Optional. */
-  parquetSortKey?: readonly string[];
-  /**
-   * When true, this rollup's payload is independent of GSC slice (e.g. entity
-   * rollups sourced from sitemap / indexing snapshots, not slice-partitioned
-   * fact tables). The runner rejects calls that pass `searchType` alongside
-   * a slice-orthogonal def so the output never lands under a per-slice prefix
-   * that the read path won't look at.
-   */
-  sliceOrthogonal?: boolean;
-  build: (deps: {
-    engine: RollupEngine;
-    ctx: TenantCtx;
-    /**
-     * Tenant-scoped object store. Rollups that aggregate over entity
-     * snapshots (e.g. indexing metadata) read JSON docs through this.
-     * Pure-SQL rollups can ignore it.
-     */
-    dataSource: DataSource;
-    /**
-     * UTC millis the trailing window anchors to — its inclusive END. Equals
-     * the newest synced/finalized data date when the runner is given
-     * `dataEndDate`, otherwise wall-clock build time. Builders derive window
-     * cutoffs from this (e.g. the trailing-28d boundary) and inline a date
-     * literal so the SQL stays portable across DuckDB builds without the ICU
-     * extension (Workers DuckDB — `CURRENT_DATE` lives in ICU).
-     */
-    windowAnchorMs: number;
-    /**
-     * GSC search-type slice the runner was invoked for. Builders forward
-     * this to every `engine.runSQL` call so the aggregated facts come
-     * from one cohort. Undefined preserves the legacy cross-type union
-     * (used by web-only tenants and admin paths).
-     */
-    searchType?: SearchType;
-  }) => Promise<unknown>;
-}
-/**
- * Wire shape persisted to R2/disk. Readers can rely on the `version` + `builtAt`.
- * Parquet rollups write this envelope as a sidecar whose `payload` points at
- * the co-located `.parquet` object via `{ parquetKey, rowCount }`.
- */
-interface RollupEnvelope<T = unknown> {
-  version: 1;
-  id: string;
-  builtAt: number;
-  windowDays: number | null;
-  payload: T;
-}
-interface ParquetRollupPointer {
-  parquetKey: string;
-  rowCount: number;
-  /**
-   * MULTI-FILE rollup: when set, the rollup is the UNION of these parquet keys
-   * (disjoint by the grain's partition column, e.g. `date` for the resumable
-   * `query_canonical_daily` build). Readers MUST union all keys; `parquetKey`
-   * stays populated (the first part) for single-file readers. Avoids a JS
-   * merge/re-encode of the whole rollup — the scaling bottleneck for a
-   * cross-invocation resumable build.
-   */
-  parquetKeys?: string[];
-}
-declare function rollupKey(ctx: TenantCtx, id: string, builtAt: number, searchType?: SearchType): string;
-declare function rollupParquetKey(ctx: TenantCtx, id: string, builtAt: number, searchType?: SearchType): string;
-interface RollupBucket {
-  list: (opts: {
-    prefix: string;
-    cursor?: string;
-  }) => Promise<{
-    objects: Array<{
-      key: string;
-    }>;
-    truncated?: boolean;
-    cursor?: string;
-  }>;
-  get: (key: string) => Promise<{
-    text: () => Promise<string>;
-  } | null>;
-}
-declare function readLatestRollup<T = unknown>(bucket: RollupBucket, ctx: TenantCtx, id: string, searchType?: SearchType): Promise<RollupEnvelope<T> | null>;
-interface RebuildRollupsOptions {
-  engine: RollupEngine;
-  dataSource: DataSource;
-  ctx: TenantCtx;
-  defs: readonly RollupDef[];
-  now?: () => number;
-  /**
-   * Build rollups for a single GSC search-type slice. Threads into every
-   * builder's `engine.runSQL` call so the aggregated facts come from one
-   * cohort, and namespaces the output object keys under a `<searchType>/`
-   * segment so per-slice rollups coexist without overwriting each other.
-   * Undefined preserves the legacy cross-type behaviour (one rollup over
-   * the union of all slices, written to the legacy path) — fine for web-
-   * only tenants and explicit cross-type admin views.
-   */
-  searchType?: SearchType;
-  /**
-   * ISO date (`YYYY-MM-DD`) of the newest synced/finalized day. Trailing-
-   * window rollups (28d/90d) anchor their window END here instead of
-   * wall-clock build time, so a "last 28 days" rollup covers the 28 days of
-   * data that actually exist — not 28 days back from whenever the job ran,
-   * which would include GSC's 2-3 day empty tail. Omit for the legacy
-   * wall-clock behaviour.
-   */
-  dataEndDate?: string;
-}
-interface RebuildRollupResult {
-  id: string;
-  /** JSON envelope key. For parquet rollups this is the sidecar pointer. */
-  objectKey: string;
-  /** Parquet payload key. Present only when `format === 'parquet'`. */
-  parquetKey?: string;
-  /** Envelope byte size; for parquet rollups does NOT include parquet bytes. */
-  bytes: number;
-  /** Parquet payload byte size when `format === 'parquet'`. */
-  parquetBytes?: number;
-  builtAt: number;
-  /**
-   * Set when this def's build/encode/write failed. The runner records the
-   * failure and continues with the remaining defs so one bad rollup never
-   * aborts the rest. Successful defs have no `error`. The human-readable
-   * message (including the stack when available) lives on `error.message`.
-   */
-  error?: EngineError;
-}
-declare function rebuildRollups(opts: RebuildRollupsOptions): Promise<RebuildRollupResult[]>;
-/**
- * Per-window budget, measured in *parquet* bytes (manifest `bytes`), used by
- * `planRollupWindows` to chunk a full-history scan.
- *
- * The executor decodes a window's parquet and ships it as an Arrow IPC stream
- * over the service binding; that IPC is hard-guarded at 28MiB
- * (`IPC_PLACEHOLDER_BUDGET` in @gscdump/cloudflare). Parquet is compressed and
- * the IPC stream is not, so a window inflates on the wire — keep this
- * conservatively below the guard. Re-measure the parquet→IPC ratio against
- * production and raise if headroom allows.
- */
-declare const WINDOW_BYTE_BUDGET: number;
-/**
- * Per-page OUTPUT row cap for key-paginated rollups (`runWindowed({ paginate })`
- * and `runPagedQuery`). `planRollupWindows` bounds the *input* parquet bytes a
- * window scans, which is a fine proxy for output size on fact aggregations whose
- * grain matches the input (one output row per input date). It is NOT a proxy for
- * aggregations that COLLAPSE to a smaller-cardinality grain whose row count is
- * driven by a high-cardinality GROUP key — `(query_canonical × date)` and
- * `(query_canonical)` — where output rows scale with distinct canonicals, not
- * input bytes. For those, each `runSQL` result (shipped as an Arrow IPC stream
- * over the Workers service-binding RPC; 28MiB guard in `@gscdump/cloudflare`,
- * duckdb-worker `assertResultBudget` at 24MiB / 100k rows) must be bounded by
- * paging the OUTPUT, independent of how the input is windowed.
- *
- * Narrow rows — `(canonical, date, 3 metrics)` — page at 50k (≈16MiB at the
- * worker's `cols×64` heuristic, well under both guards). WIDE rows carry a
- * `GROUP_CONCAT` variants string (up to ~10 variants × ~60 chars) the heuristic
- * under-counts, so they page smaller to keep the real IPC payload bounded.
- */
-declare const ROLLUP_PAGE_ROWS = 50000;
-declare const ROLLUP_PAGE_ROWS_WIDE = 20000;
-declare const ROLLUP_PAGE_ROWS_DAILY = 70000;
-/**
- * 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
- * windows, so every windowed SQL MUST also date-filter to the window bounds.
- */
-declare function planRollupWindows(parts: Array<{
-  partition: string;
-  bytes: number;
-}>, clampRange?: {
-  start: string;
-  end: string;
-}, maxWindowDays?: number): Array<{
-  start: string;
-  end: string;
-  partitions: 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
- * tier file spanning a window boundary doesn't double-count calendar dates.
- *
- * `paginate` additionally pages each window's OUTPUT (see `runPagedQuery`) so a
- * window whose GROUP cardinality is high — `(query_canonical × date)` on a large
- * site — can't ship an oversized result even though its input bytes fit a window.
- * Date-windowing bounds the per-query scan; output paging bounds the IPC payload.
- * The two are orthogonal and compose. When `paginate` is set, `sqlFor` MUST emit
- * no trailing `ORDER BY`/`LIMIT` and `paginate.orderBy` MUST be a total order.
- */
-declare function runWindowed(opts: {
-  engine: RollupEngine;
-  ctx: TenantCtx;
-  table: TableName$1;
-  searchType?: SearchType;
-  sqlFor: (w: {
-    start: string;
-    end: string;
-  }) => string;
-  /**
-   * Extra named file sets merged into every window's `runSQL` (alongside the
-   * windowed `FILES`). Use to JOIN a non-windowed sidecar (e.g. the query
-   * dimension parquet via `{ QUERY_DIM: { keys: [...] } }`) inside `sqlFor`.
-   */
-  extraFileSets?: Record<string, FileSetRef>;
-  /** Page each window's output by a total-order key. See `runPagedQuery`. */
-  paginate?: {
-    orderBy: string;
-    pageRows: number;
-  };
-  /** Cap each window's day span (output-cardinality bound). See `planRollupWindows`. */
-  maxWindowDays?: number;
-}): Promise<Row$1[]>;
-/**
- * Daily totals across the full history. One row per (date, table) with
- * clicks + impressions + position. Powers sparklines and headline totals.
- *
- * Includes `anonymizedImpressionsPct` per day computed as
- *   1 - sum(query_grained_impressions) / sum(page_grained_impressions)
- * — surfaces GSC's anonymous-query gap so the dashboard can warn users not
- * to trust query-grained breakdowns as comprehensive.
- */
-declare const dailyTotalsRollup: RollupDef;
-/** Weekly totals, ISO week aligned. Cheap and stable for trend widgets. */
-declare const weeklyTotalsRollup: RollupDef;
-/**
- * Top 1000 pages by clicks over the trailing 28-day window. JSON for v1;
- * promote to parquet (`top_pages_28d.parquet`) when the dashboard needs
- * server-side WHERE filtering on this rollup.
- */
-declare const topPages28dRollup: RollupDef;
-/**
- * Top 250 countries by clicks over the trailing 28-day window. Countries
- * cardinality is bounded (~250 ISO codes), so the list fits in a tiny JSON
- * payload regardless of traffic shape. Powers a geo-overview widget without
- * spinning up DuckDB-WASM.
- */
-declare const topCountries28dRollup: RollupDef;
-/**
- * Parquet-format companion to `topKeywords28dRollup`. Same shape, but persists
- * as a parquet object plus JSON sidecar pointer so widgets that need
- * server-side WHERE (filter by prefix, by clicks threshold, paginate) can scan
- * it directly with DuckDB-WASM instead of loading all 1000 rows into JS.
- *
- * Opt-in: include in the caller's rollup def list alongside (or instead of)
- * the JSON variant; the runner treats the two as independent ids so they can
- * coexist during a migration.
- */
-declare const topKeywords28dParquetRollup: RollupDef;
-declare const queryCanonicalVariantsRollup: RollupDef;
-/**
- * Canonical-grained fact aggregate (ADR-0018 Gap 2): pre-sums the raw
- * `(query × date)` query rows to `(query_canonical × date)`, so canonical-
- * primary top/gaining/losing reads a small pre-aggregated table instead of
- * re-collapsing variants on every request. Metrics are additive, so summing
- * these per-date sums over a window is exact — identical to aggregating the raw
- * rows.
- *
- * Null-free by construction: groups by the versioned query dimension when it
- * exists, with raw query as the fallback, so the rollup never carries a NULL/''
- * canonical bucket and the read path can treat the rollup's `query_canonical`
- * column as already-derived.
- *
- * Date-grained full history (`windowDays: null`): one rollup serves every date
- * range (reads filter by `date`) and both windows of a comparison. Opt-in (not
- * in `DEFAULT_ROLLUPS`); the host points the main query's file set at it for
- * queries the rollup covers (see `canonicalRollupCovers` /
- * `RunOptimizedQueryOptions.canonicalSource`).
- */
-declare const queryCanonicalDailyRollup: RollupDef;
-/**
- * Resumable, cross-invocation build of `query_canonical_daily` for a high-
- * cardinality site whose full windowed build exceeds one job reservation (300s).
- *
- * Each call builds from `(windowOffset, pageOffset)` until `deadlineMs`, writes
- * that batch's rows to a PART parquet, and returns `{ done:false, nextWindowOffset,
- * nextPageOffset }` for the caller to re-enqueue. When the last window is fully
- * paged it publishes a multi-file envelope listing every part (parts are disjoint
- * by `(query_canonical, date)`, so the read path just unions them — no merge),
- * returning `{ done:true }`. `builtAt` MUST be stable across the continuation chain
- * (it versions both the part keys and the final rollup key).
- *
- * INTRA-WINDOW resumability: the deadline is checked between raw-query hash shards,
- * not just between date windows. A single high-cardinality day can spend a full
- * reservation inside one grouped/sorted aggregate before the deadline check gets
- * control back. `pageOffset` is the next shard index for the current window, so a
- * continuation resumes the SAME day at the next shard. Parts are keyed by
- * `(windowOffset, pageOffset)`; multiple parts may contain the same canonical/date
- * from different raw-query shards, and rollup reads sum over the union.
- */
-declare function rebuildCanonicalDailyResumable(opts: {
-  engine: RollupEngine;
-  ctx: TenantCtx;
-  dataSource: DataSource;
-  searchType?: SearchType;
-  builtAt: number;
-  windowOffset: number;
-  /** Resume the `windowOffset` window at this shard offset (0 = window start). */
-  pageOffset?: number;
-  /** Output rows per page (default `ROLLUP_PAGE_ROWS_DAILY`). Injectable for tests. */
-  pageRows?: number;
-  /** Cap each input window's day span (default `DAILY_MAX_WINDOW_DAYS`). */
-  maxWindowDays?: number;
-  /** Split each date window by raw-query hash before grouping (1 = no sharding). */
-  shardCount?: number;
-  deadlineMs: number;
-}): Promise<{
-  done: boolean;
-  nextWindowOffset: number;
-  nextPageOffset: number;
-  windowsTotal: number;
-  windowsBuilt: number;
-  rowsWritten: number;
-}>;
-/**
- * Aggregates the per-URL Indexing API metadata entity store (populated by
- * `gscdump entities indexing snapshot`) into daily counts of `URL_UPDATED`
- * and `URL_REMOVED` notifications. Covers the third entity-snapshot shape
- * without needing its own parquet family — publish events are sparse and
- * aggregate cleanly into a small JSON rollup.
- *
- * Safe no-op when the entity store is empty: returns `{ totals: {...}, days: [] }`
- * so downstream readers don't have to special-case first-run sites.
- */
-declare const indexingMetadataRollup: RollupDef;
-/**
- * Indexing-API health by day: per `inspectedAt` date, counts of indexed,
- * soft-404, redirect, not-found, mobile passes, rich-results passes, and
- * canonical mismatches. Sourced from the inspections parquet sidecar
- * (`InspectionStore.parquetUri`), which holds the latest record per URL.
- *
- * Empty-payload no-op when the sidecar URI is unavailable (in-memory
- * `DataSource`, or before `materialize` has run).
- */
-declare const indexingHealthRollup: RollupDef;
-/**
- * Per-day index-percent: ratio of (sitemap URLs that received GSC clicks on
- * that date) / (total live sitemap URLs). Uses a DuckDB JOIN between the
- * sitemap urls parquet (`SitemapStore.urlsParquetUri`) and the `pages` fact
- * parquet. Total denominator is the count of live URLs in the urls index;
- * numerator is per-day distinct loc count where pages.clicks > 0.
- */
-declare const indexPercentRollup: RollupDef;
-/**
- * Sitemap-health per-day series materialized from the sitemap-store JSON
- * index. Each `SitemapRecord` carries `urlCount`, `errors`, `warnings`,
- * `contentHash`, and `lastDownloaded`. We bucket records by the day of their
- * `capturedAt` (or `lastDownloaded` fallback) and emit per-day aggregates plus
- * a snapshot of per-feed stats at the most recent capture.
- */
-declare const sitemapHealthRollup: RollupDef;
-/**
- * Trailing-28-day sitemap URL changes: per-day per-feedpath {added, removed}
- * counts plus rolling top-200 added and removed URLs. Streams from
- * retained `SitemapReadStore.loadEvents()` history. State compaction cannot
- * erase analytics input; memory scales independently of total site state.
- */
-declare const sitemapChanges28dRollup: RollupDef;
-/**
- * Aggregate one day's `hourly_pages` partition into the daily `pages` shape
- * and write it to the daily Discover partition. After this runs for date D,
- * the daily query path serves D from `pages/.../daily/D` and the `hourly/D`
- * partition becomes read-only / GC-only.
- *
- * `(position - 1)` weighting matches the storage convention encoded by
- * `toSumPosition`: `sum_position = SUM((position - 1) * impressions)`, so a
- * downstream `SUM(sum_position) / SUM(impressions) + 1` recovers the mean.
- *
- * searchType-scoped: only call with `searchType: 'discover'`. The hourly
- * partition lives under `hourly_pages` and the output lands under `pages` so
- * existing dashboard queries (which read `pages`) see the rolled-up day
- * transparently.
- */
-interface RebuildDailyFromHourlyOptions {
-  engine: RollupEngine & {
-    writeDay: (scope: TenantCtx & {
-      table: TableTypeName;
-      date: string;
-      searchType?: SearchType;
-    }, rows: Row$1[]) => Promise<void>;
-  };
-  ctx: TenantCtx;
-  /** PT calendar day to roll up. */
-  date: string;
-  searchType: 'discover';
-}
-type TableTypeName = import('@gscdump/contracts').TableName;
-declare function rebuildDailyFromHourly(opts: RebuildDailyFromHourlyOptions): Promise<{
-  rowsWritten: number;
-}>;
-declare const DEFAULT_ROLLUPS: readonly RollupDef[];
-/**
- * Canonical-primary rollups (ADR-0017 / ADR-0018). Opt-in — kept out of
- * `DEFAULT_ROLLUPS` because they only pay off once the consumer queries by
- * `queryCanonical` and wires the read seams (`resolveExtra` /
- * `canonicalSource`). Hosts opt in by concatenating these onto their def list
- * (CLI: `gscdump rollups --with-canonical`).
- */
-declare const CANONICAL_ROLLUPS: readonly RollupDef[];
-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 };
+import { ParquetRollupPointer, RebuildRollupResult, RebuildRollupsOptions, RollupBucket, RollupCtx, RollupDef, RollupEngine, RollupEnvelope, readLatestRollup, rebuildRollups, rollupKey, rollupParquetKey } from "./rollups/core.mjs";
+import { queryCanonicalDailyRollup, queryCanonicalVariantsRollup, rebuildCanonicalDailyResumable } from "./rollups/canonical.mjs";
+import { CANONICAL_ROLLUPS, DEFAULT_ROLLUPS } from "./rollups/defaults.mjs";
+import { RebuildDailyFromHourlyOptions, rebuildDailyFromHourly } from "./rollups/hourly.mjs";
+import { indexPercentRollup, indexingHealthRollup, indexingMetadataRollup, sitemapChanges28dRollup, sitemapHealthRollup } from "./rollups/indexing.mjs";
+import { dailyTotalsRollup, topCountries28dRollup, topKeywords28dParquetRollup, topPages28dRollup, weeklyTotalsRollup } from "./rollups/traffic.mjs";
+import { ROLLUP_PAGE_ROWS, ROLLUP_PAGE_ROWS_DAILY, ROLLUP_PAGE_ROWS_WIDE, WINDOW_BYTE_BUDGET, planRollupWindows, runWindowed } from "./rollups/windows.mjs";
+export { CANONICAL_ROLLUPS, DEFAULT_ROLLUPS, type ParquetRollupPointer, ROLLUP_PAGE_ROWS, ROLLUP_PAGE_ROWS_DAILY, ROLLUP_PAGE_ROWS_WIDE, type RebuildDailyFromHourlyOptions, type RebuildRollupResult, type RebuildRollupsOptions, type RollupBucket, type RollupCtx, type RollupDef, type RollupEngine, type RollupEnvelope, WINDOW_BYTE_BUDGET, dailyTotalsRollup, indexPercentRollup, indexingHealthRollup, indexingMetadataRollup, planRollupWindows, queryCanonicalDailyRollup, queryCanonicalVariantsRollup, readLatestRollup, rebuildCanonicalDailyResumable, rebuildDailyFromHourly, rebuildRollups, rollupKey, rollupParquetKey, runWindowed, sitemapChanges28dRollup, sitemapHealthRollup, topCountries28dRollup, topKeywords28dParquetRollup, topPages28dRollup, weeklyTotalsRollup };