@gscdump/engine 0.9.2 → 0.11.0

package/dist/rollups.mjs

@@ -0,0 +1,546 @@
+import { encodeRowsToParquetFlex } from "./adapters/hyparquet.mjs";
+import { createIndexingMetadataStore, createInspectionStore, createSitemapStore } from "./entities.mjs";
+import { MS_PER_DAY } from "gscdump";
+function rollupPrefix(ctx) {
+	return ctx.siteId ? `u_${ctx.userId}/${ctx.siteId}/rollups` : `u_${ctx.userId}/rollups`;
+}
+function rollupKey(ctx, id, builtAt) {
+	return `${rollupPrefix(ctx)}/${id}__v${builtAt}.json`;
+}
+function rollupParquetKey(ctx, id, builtAt) {
+	return `${rollupPrefix(ctx)}/${id}__v${builtAt}.parquet`;
+}
+async function rebuildRollups(opts) {
+	const now = opts.now ?? (() => Date.now());
+	const results = [];
+	for (const def of opts.defs) {
+		const builtAt = now();
+		const payload = await def.build({
+			engine: opts.engine,
+			ctx: opts.ctx,
+			dataSource: opts.dataSource,
+			builtAt
+		});
+		if (def.format === "parquet") {
+			if (!def.parquetColumns || def.parquetColumns.length === 0) throw new Error(`rollup '${def.id}' declared format='parquet' without parquetColumns`);
+			const rows = payload ?? [];
+			const parquetBytes = encodeRowsToParquetFlex(rows, {
+				columns: def.parquetColumns,
+				sortKey: def.parquetSortKey
+			});
+			const parquetKey = rollupParquetKey(opts.ctx, def.id, builtAt);
+			await opts.dataSource.write(parquetKey, parquetBytes);
+			const pointer = {
+				parquetKey,
+				rowCount: rows.length
+			};
+			const envelope = {
+				version: 1,
+				id: def.id,
+				builtAt,
+				windowDays: def.windowDays,
+				payload: pointer
+			};
+			const envelopeBytes = new TextEncoder().encode(JSON.stringify(envelope));
+			const key = rollupKey(opts.ctx, def.id, builtAt);
+			await opts.dataSource.write(key, envelopeBytes);
+			results.push({
+				id: def.id,
+				objectKey: key,
+				parquetKey,
+				bytes: envelopeBytes.byteLength,
+				parquetBytes: parquetBytes.byteLength,
+				builtAt
+			});
+			continue;
+		}
+		const envelope = {
+			version: 1,
+			id: def.id,
+			builtAt,
+			windowDays: def.windowDays,
+			payload
+		};
+		const json = JSON.stringify(envelope);
+		const bytes = new TextEncoder().encode(json);
+		const key = rollupKey(opts.ctx, def.id, builtAt);
+		await opts.dataSource.write(key, bytes);
+		results.push({
+			id: def.id,
+			objectKey: key,
+			bytes: bytes.byteLength,
+			builtAt
+		});
+	}
+	return results;
+}
+function utcDateMinusDays(at, days) {
+	const d = new Date(at - days * MS_PER_DAY);
+	return `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, "0")}-${String(d.getUTCDate()).padStart(2, "0")}`;
+}
+const dailyTotalsRollup = {
+	id: "daily_totals",
+	windowDays: null,
+	async build({ engine, ctx }) {
+		const pages = await engine.runSQL({
+			ctx,
+			table: "pages",
+			fileSets: { FILES: { table: "pages" } },
+			sql: `
+        SELECT
+          date,
+          SUM(clicks)::BIGINT AS clicks,
+          SUM(impressions)::BIGINT AS impressions,
+          SUM(sum_position)::DOUBLE AS sum_position
+        FROM read_parquet({{FILES}}, union_by_name = true)
+        GROUP BY date
+        ORDER BY date
+      `
+		});
+		const keywords = await engine.runSQL({
+			ctx,
+			table: "keywords",
+			fileSets: { FILES: { table: "keywords" } },
+			sql: `
+        SELECT
+          date,
+          SUM(impressions)::BIGINT AS impressions
+        FROM read_parquet({{FILES}}, union_by_name = true)
+        GROUP BY date
+      `
+		});
+		const keywordImpressionsByDate = /* @__PURE__ */ new Map();
+		for (const r of keywords.rows) keywordImpressionsByDate.set(String(r.date), BigInt(r.impressions));
+		return pages.rows.map((r) => {
+			const totalImpressions = BigInt(r.impressions);
+			const queryImpressions = keywordImpressionsByDate.get(String(r.date)) ?? BigInt(0);
+			const anonymized = totalImpressions === BigInt(0) ? 0 : 1 - Number(queryImpressions) / Number(totalImpressions);
+			return {
+				date: r.date,
+				clicks: Number(r.clicks),
+				impressions: Number(r.impressions),
+				sum_position: Number(r.sum_position),
+				anonymizedImpressionsPct: Math.max(0, Math.min(1, anonymized))
+			};
+		});
+	}
+};
+const weeklyTotalsRollup = {
+	id: "weekly_totals",
+	windowDays: null,
+	async build({ engine, ctx }) {
+		return (await engine.runSQL({
+			ctx,
+			table: "pages",
+			fileSets: { FILES: { table: "pages" } },
+			sql: `
+        SELECT
+          strftime(date_trunc('week', date::DATE), '%Y-%m-%d') AS week,
+          SUM(clicks)::BIGINT AS clicks,
+          SUM(impressions)::BIGINT AS impressions,
+          SUM(sum_position)::DOUBLE AS sum_position
+        FROM read_parquet({{FILES}}, union_by_name = true)
+        GROUP BY 1
+        ORDER BY 1
+      `
+		})).rows.map((r) => ({
+			week: r.week,
+			clicks: Number(r.clicks),
+			impressions: Number(r.impressions),
+			sum_position: Number(r.sum_position)
+		}));
+	}
+};
+const topPages28dRollup = {
+	id: "top_pages_28d",
+	windowDays: 28,
+	async build({ engine, ctx, builtAt }) {
+		const cutoff = utcDateMinusDays(builtAt, 28);
+		return (await engine.runSQL({
+			ctx,
+			table: "pages",
+			fileSets: { FILES: { table: "pages" } },
+			sql: `
+        SELECT
+          url,
+          SUM(clicks)::BIGINT AS clicks,
+          SUM(impressions)::BIGINT AS impressions,
+          SUM(sum_position)::DOUBLE AS sum_position
+        FROM read_parquet({{FILES}}, union_by_name = true)
+        WHERE date >= '${cutoff}'
+        GROUP BY url
+        ORDER BY clicks DESC
+        LIMIT 1000
+      `
+		})).rows.map((r) => ({
+			url: r.url,
+			clicks: Number(r.clicks),
+			impressions: Number(r.impressions),
+			sum_position: Number(r.sum_position)
+		}));
+	}
+};
+const topCountries28dRollup = {
+	id: "top_countries_28d",
+	windowDays: 28,
+	async build({ engine, ctx, builtAt }) {
+		const cutoff = utcDateMinusDays(builtAt, 28);
+		return (await engine.runSQL({
+			ctx,
+			table: "countries",
+			fileSets: { FILES: { table: "countries" } },
+			sql: `
+        SELECT
+          country,
+          SUM(clicks)::BIGINT AS clicks,
+          SUM(impressions)::BIGINT AS impressions,
+          SUM(sum_position)::DOUBLE AS sum_position
+        FROM read_parquet({{FILES}}, union_by_name = true)
+        WHERE date >= '${cutoff}'
+        GROUP BY country
+        ORDER BY clicks DESC
+        LIMIT 250
+      `
+		})).rows.map((r) => ({
+			country: r.country,
+			clicks: Number(r.clicks),
+			impressions: Number(r.impressions),
+			sum_position: Number(r.sum_position)
+		}));
+	}
+};
+const topKeywords28dRollup = {
+	id: "top_keywords_28d",
+	windowDays: 28,
+	async build({ engine, ctx, builtAt }) {
+		const cutoff = utcDateMinusDays(builtAt, 28);
+		return (await engine.runSQL({
+			ctx,
+			table: "keywords",
+			fileSets: { FILES: { table: "keywords" } },
+			sql: `
+        SELECT
+          query,
+          SUM(clicks)::BIGINT AS clicks,
+          SUM(impressions)::BIGINT AS impressions,
+          SUM(sum_position)::DOUBLE AS sum_position
+        FROM read_parquet({{FILES}}, union_by_name = true)
+        WHERE date >= '${cutoff}'
+        GROUP BY query
+        ORDER BY clicks DESC
+        LIMIT 1000
+      `
+		})).rows.map((r) => ({
+			query: r.query,
+			clicks: Number(r.clicks),
+			impressions: Number(r.impressions),
+			sum_position: Number(r.sum_position)
+		}));
+	}
+};
+const topKeywords28dParquetRollup = {
+	id: "top_keywords_28d_parquet",
+	windowDays: 28,
+	format: "parquet",
+	parquetColumns: [
+		{
+			name: "query",
+			type: "VARCHAR",
+			nullable: false
+		},
+		{
+			name: "clicks",
+			type: "BIGINT",
+			nullable: false
+		},
+		{
+			name: "impressions",
+			type: "BIGINT",
+			nullable: false
+		},
+		{
+			name: "sum_position",
+			type: "DOUBLE",
+			nullable: false
+		}
+	],
+	parquetSortKey: ["clicks"],
+	async build({ engine, ctx, builtAt }) {
+		const cutoff = utcDateMinusDays(builtAt, 28);
+		return (await engine.runSQL({
+			ctx,
+			table: "keywords",
+			fileSets: { FILES: { table: "keywords" } },
+			sql: `
+        SELECT
+          query,
+          SUM(clicks)::BIGINT AS clicks,
+          SUM(impressions)::BIGINT AS impressions,
+          SUM(sum_position)::DOUBLE AS sum_position
+        FROM read_parquet({{FILES}}, union_by_name = true)
+        WHERE date >= '${cutoff}'
+        GROUP BY query
+        ORDER BY clicks DESC
+        LIMIT 1000
+      `
+		})).rows.map((r) => ({
+			query: String(r.query),
+			clicks: BigInt(r.clicks),
+			impressions: BigInt(r.impressions),
+			sum_position: Number(r.sum_position)
+		}));
+	}
+};
+const indexingMetadataRollup = {
+	id: "indexing_metadata",
+	windowDays: null,
+	async build({ dataSource, ctx }) {
+		const index = await createIndexingMetadataStore({ dataSource }).loadIndex(ctx);
+		const records = Object.values(index.records);
+		const updatesByDay = /* @__PURE__ */ new Map();
+		const removesByDay = /* @__PURE__ */ new Map();
+		let totalUpdates = 0;
+		let totalRemoves = 0;
+		let latestUpdate;
+		let latestRemove;
+		for (const r of records) {
+			if (r.latestUpdateAt) {
+				totalUpdates++;
+				const day = r.latestUpdateAt.slice(0, 10);
+				updatesByDay.set(day, (updatesByDay.get(day) ?? 0) + 1);
+				if (!latestUpdate || r.latestUpdateAt > latestUpdate) latestUpdate = r.latestUpdateAt;
+			}
+			if (r.latestRemoveAt) {
+				totalRemoves++;
+				const day = r.latestRemoveAt.slice(0, 10);
+				removesByDay.set(day, (removesByDay.get(day) ?? 0) + 1);
+				if (!latestRemove || r.latestRemoveAt > latestRemove) latestRemove = r.latestRemoveAt;
+			}
+		}
+		const days = new Set([...updatesByDay.keys(), ...removesByDay.keys()]);
+		const perDay = Array.from(days).sort().map((day) => ({
+			day,
+			updates: updatesByDay.get(day) ?? 0,
+			removes: removesByDay.get(day) ?? 0
+		}));
+		return {
+			totals: {
+				urls: records.length,
+				updates: totalUpdates,
+				removes: totalRemoves,
+				latestUpdateAt: latestUpdate ?? null,
+				latestRemoveAt: latestRemove ?? null
+			},
+			days: perDay
+		};
+	}
+};
+function sqlString(s) {
+	return `'${s.replace(/'/g, "''")}'`;
+}
+const indexingHealthRollup = {
+	id: "indexing_health",
+	windowDays: 90,
+	async build({ engine, ctx, dataSource, builtAt }) {
+		const uri = createInspectionStore({ dataSource }).parquetUri(ctx);
+		if (!uri) return { days: [] };
+		const cutoff = utcDateMinusDays(builtAt, 90);
+		const sql = `
+      SELECT
+        substr(inspectedAt, 1, 10) AS date,
+        COUNT(*)::BIGINT AS total_urls,
+        SUM(CASE WHEN indexStatus = 'PASS' THEN 1 ELSE 0 END)::BIGINT AS indexed_count,
+        SUM(CASE WHEN pageFetchState = 'SOFT_404' THEN 1 ELSE 0 END)::BIGINT AS soft_404,
+        SUM(CASE WHEN pageFetchState = 'REDIRECT_ERROR' THEN 1 ELSE 0 END)::BIGINT AS redirect,
+        SUM(CASE WHEN pageFetchState = 'NOT_FOUND' THEN 1 ELSE 0 END)::BIGINT AS not_found,
+        SUM(CASE WHEN mobileUsabilityVerdict = 'PASS' THEN 1 ELSE 0 END)::BIGINT AS mobile_passes,
+        SUM(CASE WHEN richResultsVerdict = 'PASS' THEN 1 ELSE 0 END)::BIGINT AS rich_results_passes,
+        SUM(CASE WHEN userCanonical IS NOT NULL AND googleCanonical IS NOT NULL AND userCanonical <> googleCanonical THEN 1 ELSE 0 END)::BIGINT AS canonical_mismatches
+      FROM read_parquet(${sqlString(uri)})
+      WHERE substr(inspectedAt, 1, 10) >= '${cutoff}'
+      GROUP BY 1
+      ORDER BY 1
+    `;
+		return { days: (await engine.runSQL({
+			ctx,
+			table: "pages",
+			fileSets: {},
+			sql
+		})).rows.map((r) => ({
+			date: String(r.date),
+			total_urls: Number(r.total_urls),
+			indexed_count: Number(r.indexed_count),
+			soft_404: Number(r.soft_404),
+			redirect: Number(r.redirect),
+			not_found: Number(r.not_found),
+			mobile_passes: Number(r.mobile_passes),
+			rich_results_passes: Number(r.rich_results_passes),
+			canonical_mismatches: Number(r.canonical_mismatches)
+		})) };
+	}
+};
+const indexPercentRollup = {
+	id: "index_percent",
+	windowDays: 90,
+	async build({ engine, ctx, dataSource, builtAt }) {
+		const urlsUri = createSitemapStore({ dataSource }).urlsParquetUri(ctx);
+		if (!urlsUri) return {
+			totalSitemapUrls: 0,
+			days: []
+		};
+		const cutoff = utcDateMinusDays(builtAt, 90);
+		const numerator = await engine.runSQL({
+			ctx,
+			table: "pages",
+			fileSets: { PAGES: { table: "pages" } },
+			sql: `
+        SELECT
+          p.date AS date,
+          COUNT(DISTINCT p.url)::BIGINT AS clicked_urls
+        FROM read_parquet({{PAGES}}, union_by_name = true) p
+        INNER JOIN read_parquet(${sqlString(urlsUri)}) s
+          ON s.loc = p.url AND s.removed_at IS NULL
+        WHERE p.clicks > 0 AND p.date >= '${cutoff}'
+        GROUP BY p.date
+        ORDER BY p.date
+      `
+		});
+		const denom = await engine.runSQL({
+			ctx,
+			table: "pages",
+			fileSets: {},
+			sql: `
+        SELECT COUNT(*)::BIGINT AS total
+        FROM read_parquet(${sqlString(urlsUri)})
+        WHERE removed_at IS NULL
+      `
+		});
+		const total = Number(denom.rows[0]?.total ?? 0);
+		return {
+			totalSitemapUrls: total,
+			days: numerator.rows.map((r) => {
+				const clicked = Number(r.clicked_urls);
+				return {
+					date: String(r.date),
+					clicked_urls: clicked,
+					total_sitemap_urls: total,
+					ratio: total === 0 ? 0 : clicked / total
+				};
+			})
+		};
+	}
+};
+const sitemapHealthRollup = {
+	id: "sitemap_health",
+	windowDays: 90,
+	async build({ dataSource, ctx, builtAt }) {
+		const index = await createSitemapStore({ dataSource }).loadIndex(ctx);
+		const records = Object.values(index.records);
+		const cutoff = utcDateMinusDays(builtAt, 90);
+		const byDay = /* @__PURE__ */ new Map();
+		const feeds = [];
+		for (const r of records) {
+			const day = (r.capturedAt ?? r.lastDownloaded ?? "").slice(0, 10);
+			if (!day || day < cutoff) continue;
+			const errors = Number(r.errors ?? 0);
+			const warnings = Number(r.warnings ?? 0);
+			const urlCount = Number(r.urlCount ?? 0);
+			const bucket = byDay.get(day) ?? {
+				day,
+				feeds: 0,
+				total_urls: 0,
+				errors: 0,
+				warnings: 0
+			};
+			bucket.feeds += 1;
+			bucket.total_urls += urlCount;
+			bucket.errors += errors;
+			bucket.warnings += warnings;
+			byDay.set(day, bucket);
+			feeds.push({
+				path: r.path,
+				urlCount,
+				errors,
+				warnings,
+				contentHash: r.contentHash ?? null,
+				lastDownloaded: r.lastDownloaded ?? null,
+				capturedAt: r.capturedAt
+			});
+		}
+		return {
+			days: Array.from(byDay.values()).sort((a, b) => a.day < b.day ? -1 : 1),
+			feeds
+		};
+	}
+};
+const sitemapChanges28dRollup = {
+	id: "sitemap_changes_28d",
+	windowDays: 28,
+	async build({ dataSource, ctx, builtAt }) {
+		const store = createSitemapStore({ dataSource });
+		const from = utcDateMinusDays(builtAt, 28);
+		const to = utcDateMinusDays(builtAt, 0);
+		const counts = /* @__PURE__ */ new Map();
+		const addedTop = [];
+		const removedTop = [];
+		function key(k) {
+			return `${k.day}\x00${k.feedpath}`;
+		}
+		for await (const d of store.loadDeltas(ctx, {
+			from,
+			to
+		})) {
+			const day = new Date(d.at).toISOString().slice(0, 10);
+			const k = key({
+				day,
+				feedpath: d.feedpath
+			});
+			const cur = counts.get(k) ?? {
+				day,
+				feedpath: d.feedpath,
+				added: 0,
+				removed: 0
+			};
+			if (d.op === "added") {
+				cur.added += 1;
+				addedTop.push({
+					loc: d.loc,
+					feedpath: d.feedpath,
+					at: d.at
+				});
+			} else {
+				cur.removed += 1;
+				removedTop.push({
+					loc: d.loc,
+					feedpath: d.feedpath,
+					at: d.at
+				});
+			}
+			counts.set(k, cur);
+		}
+		const days = Array.from(counts.values()).sort((a, b) => {
+			if (a.day !== b.day) return a.day < b.day ? -1 : 1;
+			return a.feedpath < b.feedpath ? -1 : 1;
+		});
+		addedTop.sort((a, b) => b.at - a.at);
+		removedTop.sort((a, b) => b.at - a.at);
+		return {
+			days,
+			topAdded: addedTop.slice(0, 200),
+			topRemoved: removedTop.slice(0, 200)
+		};
+	}
+};
+const DEFAULT_ROLLUPS = [
+	dailyTotalsRollup,
+	weeklyTotalsRollup,
+	topPages28dRollup,
+	topKeywords28dRollup,
+	topCountries28dRollup,
+	indexingMetadataRollup,
+	indexingHealthRollup,
+	indexPercentRollup,
+	sitemapHealthRollup,
+	sitemapChanges28dRollup
+];
+export { DEFAULT_ROLLUPS, dailyTotalsRollup, indexPercentRollup, indexingHealthRollup, indexingMetadataRollup, rebuildRollups, rollupKey, rollupParquetKey, sitemapChanges28dRollup, sitemapHealthRollup, topCountries28dRollup, topKeywords28dParquetRollup, topKeywords28dRollup, topPages28dRollup, weeklyTotalsRollup };

package/dist/schedule.d.mts

@@ -0,0 +1,19 @@
+interface ScheduleState {
+  nextAt: number;
+  consecutiveUnchanged: number;
+  policyVersion: number;
+}
+interface SchedulePolicy {
+  readonly version: number;
+  initial: (now: number) => ScheduleState;
+  observe: (prev: ScheduleState, evt: {
+    changed: boolean;
+    at: number;
+  }) => ScheduleState;
+  isDue: (state: ScheduleState, now: number) => boolean;
+}
+declare const sitemapPolicy: SchedulePolicy;
+type InspectionVerdict = 'PASS' | 'FAIL' | 'NEUTRAL';
+declare function inspectionPolicy(verdict: InspectionVerdict): SchedulePolicy;
+declare function fixedPolicy(intervalMs: number): SchedulePolicy;
+export { InspectionVerdict, SchedulePolicy, ScheduleState, fixedPolicy, inspectionPolicy, sitemapPolicy };

package/dist/schedule.mjs

@@ -0,0 +1,100 @@
+const DAY = 24 * (3600 * 1e3);
+function isDue(state, now) {
+	return now >= state.nextAt;
+}
+function sitemapCadenceMs(consecutiveUnchanged) {
+	if (consecutiveUnchanged >= 7) return 30 * DAY;
+	if (consecutiveUnchanged >= 3) return 7 * DAY;
+	return DAY;
+}
+const SITEMAP_VERSION = 1;
+const sitemapPolicy = {
+	version: SITEMAP_VERSION,
+	initial(now) {
+		return {
+			nextAt: now + DAY,
+			consecutiveUnchanged: 0,
+			policyVersion: SITEMAP_VERSION
+		};
+	},
+	observe(prev, evt) {
+		if (prev.policyVersion !== SITEMAP_VERSION) return {
+			nextAt: evt.at + sitemapCadenceMs(0),
+			consecutiveUnchanged: 0,
+			policyVersion: SITEMAP_VERSION
+		};
+		if (evt.changed) return {
+			nextAt: evt.at + DAY,
+			consecutiveUnchanged: 0,
+			policyVersion: SITEMAP_VERSION
+		};
+		const next = prev.consecutiveUnchanged + 1;
+		return {
+			nextAt: evt.at + sitemapCadenceMs(next),
+			consecutiveUnchanged: next,
+			policyVersion: SITEMAP_VERSION
+		};
+	},
+	isDue
+};
+const INSPECTION_VERSION = 1;
+function inspectionCadenceMs(verdict) {
+	if (verdict === "PASS") return 30 * DAY;
+	if (verdict === "FAIL") return 7 * DAY;
+	return 14 * DAY;
+}
+function inspectionPolicy(verdict) {
+	const cadence = inspectionCadenceMs(verdict);
+	return {
+		version: INSPECTION_VERSION,
+		initial(now) {
+			return {
+				nextAt: now + cadence,
+				consecutiveUnchanged: 0,
+				policyVersion: INSPECTION_VERSION
+			};
+		},
+		observe(prev, evt) {
+			if (prev.policyVersion !== INSPECTION_VERSION) return {
+				nextAt: evt.at + cadence,
+				consecutiveUnchanged: 0,
+				policyVersion: INSPECTION_VERSION
+			};
+			const next = evt.changed ? 0 : prev.consecutiveUnchanged + 1;
+			return {
+				nextAt: evt.at + cadence,
+				consecutiveUnchanged: next,
+				policyVersion: INSPECTION_VERSION
+			};
+		},
+		isDue
+	};
+}
+const FIXED_VERSION = 1;
+function fixedPolicy(intervalMs) {
+	return {
+		version: FIXED_VERSION,
+		initial(now) {
+			return {
+				nextAt: now + intervalMs,
+				consecutiveUnchanged: 0,
+				policyVersion: FIXED_VERSION
+			};
+		},
+		observe(prev, evt) {
+			if (prev.policyVersion !== FIXED_VERSION) return {
+				nextAt: evt.at + intervalMs,
+				consecutiveUnchanged: 0,
+				policyVersion: FIXED_VERSION
+			};
+			const next = evt.changed ? 0 : prev.consecutiveUnchanged + 1;
+			return {
+				nextAt: evt.at + intervalMs,
+				consecutiveUnchanged: next,
+				policyVersion: FIXED_VERSION
+			};
+		},
+		isDue
+	};
+}
+export { fixedPolicy, inspectionPolicy, sitemapPolicy };

package/dist/snapshot.d.mts

@@ -1,14 +1,2 @@
-/**
- * Describes a hot/cold snapshot set. Produced by the snapshot builder,
- * consumed by `attachSnapshotIndex`. Filenames are derived from `cold`
- * via `cold-${yearMonth}.duckdb`; hot is always `hot.duckdb` when
- * `hot: true`.
- */
-interface SnapshotIndex {
-  version: 1;
-  builtAt: string;
-  cold: string[];
-  hot: boolean;
-  hotDays: number;
-}
+import { t as SnapshotIndex } from "./_chunks/snapshot.mjs";
 export { SnapshotIndex };