@gscdump/cli 3.8.0 → 4.0.0

package/dist/route.mjs

@@ -0,0 +1,295 @@
+import { probeAuth } from "./auth.mjs";
+import { listStoreSites } from "./store-sites.mjs";
+import { formatSiteResolution, siteArg } from "./context.mjs";
+import { hasSyncedDays, syncStateCoverageReader } from "./coverage.mjs";
+import { isProcessAlive, readSyncRun, syncRunStatus } from "./sync-run.mjs";
+import { addDays } from "gscdump/dates";
+import { buildCoveragePlan, gapsForRange } from "@gscdump/engine/analysis-range";
+const CONNECT_COMMAND = "gscdump init";
+const LOGIN_COMMAND = "gscdump auth login";
+function isCovered(need) {
+	return need.kind === "window" ? need.gaps.length === 0 : need.stored;
+}
+function datesOf(spans) {
+	const dates = /* @__PURE__ */ new Set();
+	for (const span of spans) for (let date = span.start; date <= span.end; date = addDays(date, 1)) dates.add(date);
+	return dates;
+}
+function syncCommandFor(site, coverage) {
+	const target = site ? siteArg(site) : "example.com";
+	const missing = coverage.filter((need) => !isCovered(need));
+	const gaps = missing.flatMap((need) => need.kind === "window" ? need.gaps : []);
+	const tables = [...new Set(missing.flatMap((need) => need.kind === "window" ? [need.table] : need.tables))];
+	const types = [...new Set(missing.flatMap((need) => need.searchType && need.searchType !== "web" ? [need.searchType] : []))];
+	const parts = [
+		"gscdump",
+		"sync",
+		"--site",
+		target
+	];
+	if (gaps.length > 0) {
+		parts.push("--start", gaps.reduce((min, gap) => gap.start < min ? gap.start : min, gaps[0].start));
+		parts.push("--end", gaps.reduce((max, gap) => gap.end > max ? gap.end : max, gaps[0].end));
+	}
+	if (tables.length > 0) parts.push("--tables", tables.join(","));
+	if (types.length > 0) parts.push("--types", types.join(","));
+	return parts.map(quote).join(" ");
+}
+function quote(part) {
+	return /^[\w:./=,@~-]+$/.test(part) ? part : `'${part.replaceAll("'", "'\\''")}'`;
+}
+function liveCommand(req) {
+	return [
+		"gscdump",
+		...req.argv ?? req.label.split(" "),
+		"--live"
+	].map(quote).join(" ");
+}
+function runsForSite(syncRun, site) {
+	return syncRun.kind === "running" && (site === void 0 || syncRun.record.sites.includes(site));
+}
+function windowGaps(coverage) {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const need of coverage) {
+		if (need.kind !== "window" || need.gaps.length === 0) continue;
+		const key = `${need.period}|${need.table}|${need.searchType}|${need.window.start}|${need.window.end}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		out.push({
+			period: need.period,
+			table: need.table,
+			window: need.window,
+			missing: need.gaps
+		});
+	}
+	return out;
+}
+function windowGapLine(gap) {
+	const expected = datesOf([gap.window]).size;
+	const missing = datesOf(gap.missing).size;
+	const first = gap.missing[0].start;
+	const last = gap.missing.at(-1).end;
+	return `  ${gap.period} window ${gap.window.start} to ${gap.window.end}: ${gap.table} misses ${missing} of ${expected} days (${first} to ${last}).`;
+}
+function decideRoute(req, state) {
+	const { auth, coverage, syncRun } = state;
+	const stored = coverage.some((need) => need.stored);
+	const covered = coverage.length > 0 && coverage.every(isCovered);
+	const connected = auth !== "none";
+	const syncCommand = syncCommandFor(req.site ?? req.siteHint, coverage);
+	const tables = [...new Set(coverage.flatMap((need) => need.kind === "window" ? [need.table] : need.tables))];
+	const notConnected = {
+		kind: "prompt",
+		reason: {
+			kind: "not-connected",
+			tables
+		},
+		nextCommand: CONNECT_COMMAND
+	};
+	if (req.forceLive) {
+		if (!req.liveCapable) return {
+			kind: "prompt",
+			reason: { kind: "store-only" },
+			nextCommand: syncCommand
+		};
+		return connected ? {
+			kind: "live",
+			reason: "forced"
+		} : notConnected;
+	}
+	if (!req.localCapable) return connected ? {
+		kind: "prompt",
+		reason: { kind: "live-only" },
+		nextCommand: liveCommand(req)
+	} : {
+		...notConnected,
+		reason: {
+			kind: "not-connected",
+			tables: []
+		}
+	};
+	if (covered) return { kind: "local" };
+	if (runsForSite(syncRun, req.site)) return {
+		kind: "syncing",
+		done: syncRun.record.done,
+		total: syncRun.record.planned
+	};
+	if (!stored) {
+		if (!connected) return notConnected;
+		if (req.liveCapable) return {
+			kind: "live",
+			reason: "no-store-data"
+		};
+		return {
+			kind: "prompt",
+			reason: {
+				kind: "no-data",
+				tables
+			},
+			nextCommand: syncCommand
+		};
+	}
+	const windows = coverage.flatMap((need) => need.kind === "window" ? [need.window] : []);
+	const gaps = coverage.flatMap((need) => need.kind === "window" ? need.gaps : []);
+	const wanted = datesOf(windows);
+	const coveredDays = /* @__PURE__ */ new Set();
+	for (const need of coverage) {
+		if (need.kind !== "window") continue;
+		const missingDays = datesOf(need.gaps);
+		for (const date of datesOf([need.window])) if (!missingDays.has(date)) coveredDays.add(date);
+	}
+	return {
+		kind: "prompt",
+		reason: {
+			kind: "partial",
+			done: coveredDays.size,
+			total: wanted.size,
+			missing: gaps,
+			windows: windowGaps(coverage)
+		},
+		nextCommand: connected ? syncCommand : LOGIN_COMMAND
+	};
+}
+function siteLabel(site) {
+	return site ?? "this Site";
+}
+function routeMessage(route, req, auth) {
+	const site = siteLabel(req.site ?? req.siteHint);
+	if (route.kind === "syncing") {
+		const live = req.liveCapable ? ", or pass --live" : "";
+		return `Sync running: ${route.done.toLocaleString("en-US")} of ${route.total.toLocaleString("en-US")} days done. Run again when it finishes${live}.`;
+	}
+	const next = route.nextCommand;
+	switch (route.reason.kind) {
+		case "not-connected": return `${route.reason.tables.length > 0 ? `The Store has no ${route.reason.tables.join(", ")} data for ${site}, and Google is not connected.` : `\`${req.label}\` needs Search Console, and Google is not connected.`} Run \`${next}\` to connect Google and sync the Site, or \`${LOGIN_COMMAND}\` to query Search Console directly.`;
+		case "no-data": return `The Store has no ${route.reason.tables.join(", ")} data for ${site}. \`${req.label}\` reads synced data only. Run \`${next}\` first.`;
+		case "live-only": return `\`${req.label}\` runs against the live Search Console API only. Run \`${next}\`.`;
+		case "store-only": return `\`${req.label}\` reads synced data only. Remove --live. If the Store has no data for ${site}, run \`${next}\` first.`;
+		case "partial": {
+			const { done, total, windows } = route.reason;
+			const head = [`The Store has ${done.toLocaleString("en-US")} of ${total.toLocaleString("en-US")} days for ${site}.`, ...windows.map(windowGapLine)].join("\n");
+			if (auth === "none") return `${head}\nRun \`${next}\` to connect Google, then \`${syncCommandFor(req.site ?? req.siteHint, [])}\` to sync the rest.`;
+			return `${head}\nRun \`${next}\` to sync the rest${req.liveCapable ? ", or pass --live to ask Search Console directly" : ""}.`;
+		}
+	}
+}
+function liveNote(site) {
+	return `No synced data for ${site}; answering from the live Search Console API.`;
+}
+function stopCode(route) {
+	if (route.kind === "syncing") return "SYNC_RUNNING";
+	switch (route.reason.kind) {
+		case "not-connected": return "NOT_CONNECTED";
+		case "no-data": return "NO_SYNCED_DATA";
+		case "store-only": return "STORE_ONLY";
+		case "live-only": return "LIVE_ONLY";
+		case "partial": return "STORE_RANGE_NOT_COVERED";
+	}
+}
+function routeStopError(route, message) {
+	return Object.assign(new Error(message), {
+		name: "RouteStopError",
+		routeStop: route
+	});
+}
+async function needCoverage(needs, states) {
+	const reader = syncStateCoverageReader(states);
+	const plans = /* @__PURE__ */ new Map();
+	const planFor = (searchType, window, tables) => {
+		const key = `${searchType}|${window.start}|${window.end}`;
+		const plan = plans.get(key) ?? buildCoveragePlan({
+			searchType,
+			requested: window,
+			tables,
+			reader
+		});
+		plans.set(key, plan);
+		return plan;
+	};
+	const windowed = needs.filter((need) => need.kind === "window");
+	const tablesFor = (need) => [...new Set(windowed.filter((other) => other.searchType === need.searchType && other.window.start === need.window.start && other.window.end === need.window.end).map((other) => other.table))];
+	return Promise.all(needs.map(async (need) => {
+		if (need.kind === "any") {
+			const stored = need.tables.some((table) => need.searchType ? hasSyncedDays(states, table, need.searchType) : states.some((state) => state.table === table && state.state === "done"));
+			return {
+				...need,
+				stored
+			};
+		}
+		const table = (await planFor(need.searchType, need.window, tablesFor(need))).tables.find((entry) => entry.table === need.table);
+		return {
+			...need,
+			stored: hasSyncedDays(states, need.table, need.searchType),
+			gaps: table ? table.gaps : gapsForRange([], need.window)
+		};
+	}));
+}
+async function readRouteState(input) {
+	const { store, site } = input;
+	const states = input.states ?? await readSiteStates(store, site);
+	const [auth, record] = await Promise.all([input.auth ?? probeAuth(), readSyncRun(store.dataDir)]);
+	return {
+		auth,
+		coverage: await needCoverage(input.needs, states),
+		syncRun: syncRunStatus(record, {
+			now: input.now ?? Date.now(),
+			isAlive: isProcessAlive
+		})
+	};
+}
+async function readSiteStates(store, site) {
+	return store.engine.getSyncStates({
+		userId: store.userId,
+		...site ? { siteId: store.siteIdFor(site) } : {}
+	});
+}
+async function resolveReadSite(ctx, target, opts) {
+	const auth = await probeAuth();
+	const connected = auth !== "none";
+	if (opts.forceLive && connected) return {
+		site: await (await opts.connect()).resolveSite(target, { scope: "account" }),
+		auth
+	};
+	const hint = target?.trim() || ctx.config.defaultSite;
+	if (hint) {
+		const found = await ctx.matchSite(hint, { scope: "store" });
+		if (found.kind === "resolved") return {
+			site: found.siteUrl,
+			auth
+		};
+		if (found.kind !== "not-found") throw new Error(formatSiteResolution(found, "store"));
+	} else if ((await listStoreSites(ctx.dataDir)).length > 0) return {
+		site: await ctx.resolveSite(void 0, { scope: "store" }),
+		auth
+	};
+	if (!connected) return {
+		site: void 0,
+		...hint ? { siteHint: hint } : {},
+		auth
+	};
+	return {
+		site: await (await opts.connect()).resolveSite(target, { scope: "account" }),
+		auth
+	};
+}
+function describeStop(route, req, auth) {
+	const message = routeMessage(route, req, auth);
+	return {
+		code: stopCode(route),
+		message,
+		siteUrl: req.site ?? req.siteHint ?? null,
+		nextCommand: route.kind === "prompt" ? route.nextCommand : null,
+		...route.kind === "prompt" && route.reason.kind === "partial" ? { missingDates: [...datesOf(route.reason.missing)].sort() } : {},
+		...route.kind === "syncing" ? { sync: {
+			done: route.done,
+			total: route.total
+		} } : {}
+	};
+}
+function stopAtRoute(route, req, auth, opts) {
+	const details = describeStop(route, req, auth);
+	if (opts.json) console.log(JSON.stringify({ error: details }, null, 2));
+	throw routeStopError(route, details.message);
+}
+export { decideRoute, describeStop, liveCommand, liveNote, needCoverage, readRouteState, readSiteStates, resolveReadSite, routeMessage, routeStopError, stopAtRoute, stopCode, syncCommandFor };

package/dist/sitemap.mjs

@@ -41,6 +41,10 @@ async function loadSitemapUrls(url, options = {}) {
 		_tag: "ok",
 		value: {
 			urls: result.entries.map((entry) => entry.loc),
+			entries: result.entries.map((entry) => entry.lastmod === void 0 ? { loc: entry.loc } : {
+				loc: entry.loc,
+				lastmod: entry.lastmod
+			}),
 			complete: result._tag === "complete",
 			documentsRead: result.documentsRead
 		}

package/dist/sql-views.mjs

@@ -0,0 +1,117 @@
+import { allTables } from "./local-store.mjs";
+import { readSiteMap } from "./store-sites.mjs";
+import { exportColumns, groupTableSources } from "./table-sources.mjs";
+import { attachParquetIndex } from "@gscdump/engine/node";
+import { SCHEMAS } from "@gscdump/engine/schema";
+import { DuckDBInstance, DuckDBTypeId } from "@duckdb/node-api";
+const RAW_SCHEMA = "gsc_raw";
+const GSC_POSITION_MACRO = "CREATE OR REPLACE MACRO gsc_position(sum_position, impressions) AS SUM(sum_position) / NULLIF(SUM(impressions), 0) + 1";
+function referencedTables(sql, tables) {
+	const words = new Set(sql.toLowerCase().match(/[a-z_][\w$]*/g) ?? []);
+	return tables.filter((table) => words.has(table));
+}
+function toJsonValue(value, type) {
+	if (value === null || value === void 0) return null;
+	if (typeof value === "bigint") return value >= BigInt(Number.MIN_SAFE_INTEGER) && value <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(value) : value.toString();
+	if (value instanceof Date) return type?.typeId === DuckDBTypeId.DATE ? value.toISOString().slice(0, 10) : value.toISOString();
+	if (Array.isArray(value)) return value.map((item) => toJsonValue(item));
+	if (value instanceof Uint8Array) return value;
+	if (typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, toJsonValue(item)]));
+	return value;
+}
+function emptyViewSql(table) {
+	return `CREATE OR REPLACE VIEW main.${table} AS SELECT ${withPageAlias(table, exportColumns(table).map((column) => `NULL::${column.type} AS ${column.name}`)).join(", ")} WHERE false`;
+}
+function withPageAlias(table, columns) {
+	const index = SCHEMAS[table].columns.findIndex((column) => column.name === "url");
+	if (index === -1) return columns;
+	const at = index + 3;
+	return [
+		...columns.slice(0, at),
+		"url AS page",
+		...columns.slice(at)
+	];
+}
+async function viewColumns(connection, table) {
+	return (await connection.runAndReadAll(`DESCRIBE main.${table}`)).getRowObjectsJS().map((row) => ({
+		name: String(row.column_name),
+		type: String(row.column_type)
+	}));
+}
+async function createViews(connection, sources) {
+	const byTable = /* @__PURE__ */ new Map();
+	for (const source of sources) byTable.set(source.table, [...byTable.get(source.table) ?? [], source]);
+	await attachParquetIndex(async (sql) => {
+		await connection.run(sql);
+		return [];
+	}, {
+		schema: RAW_SCHEMA,
+		tables: Object.fromEntries([...byTable].map(([table, group]) => [table, group.map((source) => ({
+			urls: source.files,
+			constants: {
+				site: source.site,
+				search_type: source.searchType
+			}
+		}))]))
+	});
+	for (const table of allTables()) {
+		if (!byTable.has(table)) {
+			await connection.run(emptyViewSql(table));
+			continue;
+		}
+		const present = new Set((await connection.runAndReadAll(`DESCRIBE ${RAW_SCHEMA}.${table}`)).getRowObjectsJS().map((row) => String(row.column_name)));
+		const columns = exportColumns(table).map((column) => {
+			if (!present.has(column.name)) return `NULL::${column.type} AS ${column.name}`;
+			return column.type === "DATE" ? `CAST(${column.name} AS DATE) AS ${column.name}` : column.name;
+		});
+		await connection.run(`CREATE OR REPLACE VIEW main.${table} AS SELECT ${withPageAlias(table, columns).join(", ")} FROM ${RAW_SCHEMA}.${table}`);
+	}
+}
+async function openSqlViews(store, scope = {}) {
+	const entries = await store.engine.listLive({
+		userId: store.userId,
+		...scope.searchType !== void 0 ? { searchType: scope.searchType } : {}
+	});
+	const siteIds = scope.siteIds ? new Set(scope.siteIds) : void 0;
+	const siteMap = await readSiteMap(store.dataDir, store.userId);
+	const sources = groupTableSources(entries.filter((entry) => !siteIds || entry.siteId !== void 0 && siteIds.has(entry.siteId)), store.dataDir, siteMap);
+	const instance = await DuckDBInstance.create(":memory:");
+	const connection = await instance.connect();
+	const close = () => {
+		connection.closeSync();
+		instance.closeSync();
+	};
+	try {
+		await createViews(connection, sources);
+		await connection.run(GSC_POSITION_MACRO);
+		const views = [];
+		for (const table of allTables()) views.push({
+			table,
+			columns: await viewColumns(connection, table),
+			sources: sources.filter((source) => source.table === table).map((source) => ({
+				site: source.site,
+				searchType: source.searchType,
+				files: source.files.length,
+				rows: source.rows
+			}))
+		});
+		return {
+			views,
+			emptyTables: views.filter((view) => view.sources.length === 0).map((view) => view.table),
+			async run(sql) {
+				const reader = await connection.runAndReadAll(sql);
+				const columns = reader.columnNames();
+				const types = reader.columnTypes();
+				return {
+					columns,
+					rows: reader.getRowsJS().map((values) => Object.fromEntries(columns.map((name, index) => [name, toJsonValue(values[index], types[index])])))
+				};
+			},
+			close
+		};
+	} catch (error) {
+		close();
+		throw error;
+	}
+}
+export { GSC_POSITION_MACRO, openSqlViews, referencedTables, toJsonValue };

package/dist/store-sites.mjs

@@ -0,0 +1,134 @@
+import process from "node:process";
+import { randomUUID } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+import { err, ok } from "gscdump/result";
+import { decodeSiteId, encodeSiteId } from "gscdump/tenant";
+import { lock } from "proper-lockfile";
+const siteMapSchema = z.object({
+	version: z.literal(1),
+	sites: z.record(z.string(), z.string())
+});
+const SITE_ID_DIR_RE = /^[dh]_[\w.-]+$/;
+const DECODED_ORIGIN_RE = /^https:\/\/[a-z0-9.-]+\/$/i;
+function tenantDir(dataDir, userId) {
+	return path.join(dataDir, `u_${userId}`);
+}
+function siteMapPath(dataDir, userId) {
+	return path.join(tenantDir(dataDir, userId), "sites.json");
+}
+function ignoreMissing(fallback) {
+	return (error) => {
+		if (error.code === "ENOENT") return fallback;
+		throw error;
+	};
+}
+async function readSiteMap(dataDir, userId = "local") {
+	const file = siteMapPath(dataDir, userId);
+	const body = await fs.readFile(file, "utf8").catch(ignoreMissing(null));
+	if (body === null) return {};
+	const parsed = siteMapSchema.safeParse(await Promise.resolve().then(() => JSON.parse(body)).catch(() => void 0));
+	if (!parsed.success) throw new Error(`The Site map at ${file} is invalid. Delete it, then run gscdump sync again.`);
+	return parsed.data.sites;
+}
+async function listSiteIds(dataDir, userId) {
+	return (await fs.readdir(tenantDir(dataDir, userId), { withFileTypes: true }).catch(ignoreMissing([]))).filter((entry) => entry.isDirectory() && SITE_ID_DIR_RE.test(entry.name)).map((entry) => entry.name);
+}
+async function listStoreSites(dataDir, userId = "local") {
+	const [map, siteIds] = await Promise.all([readSiteMap(dataDir, userId), listSiteIds(dataDir, userId)]);
+	return siteIds.map((siteId) => ({
+		siteId,
+		siteUrl: map[siteId] ?? decodeSiteId(siteId)
+	}));
+}
+function siteUrlForId(map, siteId) {
+	return map[siteId] ?? decodeSiteId(siteId);
+}
+function claimSiteId(map, siteUrl, hasData) {
+	const siteId = encodeSiteId(siteUrl);
+	const existing = map[siteId];
+	if (existing === void 0 && hasData) {
+		const decoded = decodeSiteId(siteId);
+		if (DECODED_ORIGIN_RE.test(decoded) && decoded !== siteUrl) return err({
+			kind: "site-id-collision",
+			siteId,
+			siteUrl,
+			existing: decoded
+		});
+	}
+	if (existing !== void 0 && existing !== siteUrl) return err({
+		kind: "site-id-collision",
+		siteId,
+		siteUrl,
+		existing
+	});
+	return ok(existing === siteUrl ? map : {
+		...map,
+		[siteId]: siteUrl
+	});
+}
+async function writeSiteMap(dataDir, userId, sites) {
+	const file = siteMapPath(dataDir, userId);
+	const temp = `${file}.${process.pid}.${randomUUID()}.tmp`;
+	await fs.writeFile(temp, `${JSON.stringify({
+		version: 1,
+		sites
+	}, null, 2)}\n`);
+	await fs.rename(temp, file);
+}
+const siteMapQueues = /* @__PURE__ */ new Map();
+async function lockSiteMapFile(file, fn) {
+	await fs.mkdir(path.dirname(file), { recursive: true });
+	const release = await lock(file, {
+		realpath: false,
+		stale: 3e4,
+		retries: {
+			retries: 40,
+			minTimeout: 25,
+			maxTimeout: 500,
+			factor: 1.5
+		}
+	});
+	return await fn().finally(() => release().catch((error) => {
+		console.warn(`[gscdump] Could not release the Site map lock for ${file}.`, error);
+	}));
+}
+async function withSiteMapLock(dataDir, userId, fn) {
+	const file = siteMapPath(dataDir, userId);
+	const run = (siteMapQueues.get(file) ?? Promise.resolve()).then(() => lockSiteMapFile(file, fn));
+	const tail = run.then(() => void 0, () => {});
+	siteMapQueues.set(file, tail);
+	tail.then(() => {
+		if (siteMapQueues.get(file) === tail) siteMapQueues.delete(file);
+	});
+	return await run;
+}
+async function recordStoreSite(dataDir, siteUrl, options = {}) {
+	const { userId = "local", write = true } = options;
+	const claim = async () => {
+		const [map, siteIds] = await Promise.all([readSiteMap(dataDir, userId), listSiteIds(dataDir, userId)]);
+		const claimed = claimSiteId(map, siteUrl, siteIds.includes(encodeSiteId(siteUrl)));
+		if (claimed.ok && write && claimed.value !== map) await writeSiteMap(dataDir, userId, claimed.value);
+		return claimed;
+	};
+	const result = write ? await withSiteMapLock(dataDir, userId, claim) : await claim();
+	return result.ok ? ok(void 0) : result;
+}
+async function removeStoreSite(dataDir, siteId, userId = "local") {
+	if (!SITE_ID_DIR_RE.test(siteId)) throw new Error(`Refusing to remove "${siteId}": it is not a Site ID.`);
+	await withSiteMapLock(dataDir, userId, async () => {
+		await fs.rm(path.join(tenantDir(dataDir, userId), siteId), {
+			recursive: true,
+			force: true
+		});
+		const map = await readSiteMap(dataDir, userId);
+		if (!(siteId in map)) return;
+		const { [siteId]: _removed, ...rest } = map;
+		await writeSiteMap(dataDir, userId, rest);
+	});
+}
+function formatSiteIdCollision(collision) {
+	return `The Store keeps ${collision.existing} under the same ID as ${collision.siteUrl}. The two Sites cannot share one Store. If you no longer need the data for ${collision.existing}, run \`gscdump store rm-site ${collision.existing}\`, then sync again.`;
+}
+export { claimSiteId, formatSiteIdCollision, listStoreSites, readSiteMap, recordStoreSite, removeStoreSite, siteUrlForId };

package/dist/sync-plan.mjs

@@ -0,0 +1,129 @@
+import { searchTypeSupportsDimensions, searchTypeSupportsQueries } from "@gscdump/contracts";
+import { addDays, getDateRange } from "gscdump/dates";
+const TABLE_NEEDS = {
+	pages: {
+		queries: false,
+		dimensions: false
+	},
+	queries: {
+		queries: true,
+		dimensions: false
+	},
+	countries: {
+		queries: false,
+		dimensions: true
+	},
+	dates: {
+		queries: true,
+		dimensions: true
+	},
+	page_queries: {
+		queries: true,
+		dimensions: false
+	},
+	search_appearance: {
+		queries: false,
+		dimensions: true
+	},
+	search_appearance_pages: {
+		queries: false,
+		dimensions: true
+	},
+	search_appearance_queries: {
+		queries: true,
+		dimensions: true
+	},
+	search_appearance_page_queries: {
+		queries: true,
+		dimensions: true
+	},
+	hourly_pages: {
+		queries: false,
+		dimensions: false
+	}
+};
+function tableSupportsType(table, type) {
+	const needs = TABLE_NEEDS[table];
+	return (!needs.queries || searchTypeSupportsQueries(type)) && (!needs.dimensions || searchTypeSupportsDimensions(type));
+}
+function planSyncJobs(tables, types) {
+	const jobs = [];
+	const unsupported = [];
+	for (const table of tables) for (const type of types) {
+		const job = {
+			table,
+			type,
+			label: type === "web" ? table : `${table}/${type}`
+		};
+		if (tableSupportsType(table, type)) jobs.push(job);
+		else unsupported.push(job);
+	}
+	return {
+		jobs,
+		unsupported
+	};
+}
+function datesForJob(table, dates, today) {
+	if (table !== "hourly_pages") return [...dates];
+	const cutoff = (/* @__PURE__ */ new Date(Date.parse(`${today}T00:00:00Z`) - 864e6)).toISOString().slice(0, 10);
+	return dates.filter((date) => date >= cutoff);
+}
+function jobWindowStart(window, states) {
+	if (window.kind === "range") return window.start;
+	let oldest;
+	for (const state of states) if (state.date >= window.floor && (oldest === void 0 || state.date < oldest)) oldest = state.date;
+	const start = oldest !== void 0 && oldest < window.firstStart ? oldest : window.firstStart;
+	return start < window.floor ? window.floor : start;
+}
+function planJobDates(input) {
+	const window = datesForJob(input.table, getDateRange(jobWindowStart(input.window, input.states), input.window.end), input.today);
+	const stateByDate = new Map(input.states.map((state) => [state.date, state.state]));
+	let skippedDone = 0;
+	return {
+		dates: window.filter((date) => {
+			const state = stateByDate.get(date);
+			if (input.mode === "force") return true;
+			if (input.mode === "retry-failed") return state === "failed";
+			if (state === "done") {
+				skippedDone++;
+				return false;
+			}
+			return true;
+		}).reverse(),
+		skippedDone
+	};
+}
+function fullHistoryStart(oldestGscDate) {
+	return addDays(oldestGscDate, -14);
+}
+function minimumCallsPerDate(table) {
+	if (table === "dates") return 3;
+	if (table === "search_appearance" || table === "hourly_pages") return 2;
+	if (table.startsWith("search_appearance_")) return 2;
+	return 1;
+}
+function resolveWindow(input) {
+	const end = input.end ?? input.latest;
+	if (input.start) return {
+		kind: "range",
+		start: input.start,
+		end
+	};
+	if (input.full) return {
+		kind: "range",
+		start: fullHistoryStart(input.floor),
+		end
+	};
+	if (input.days !== void 0) return {
+		kind: "range",
+		start: addDays(end, -(input.days - 1)),
+		end
+	};
+	return {
+		kind: "catch-up",
+		firstStart: addDays(end, -27),
+		floor: input.floor,
+		end
+	};
+}
+export { datesForJob, fullHistoryStart, jobWindowStart, minimumCallsPerDate, planJobDates, planSyncJobs, resolveWindow, tableSupportsType };