seo 0.2.15 → 0.2.16

package/dist/index.js

@@ -1,5 +1,5 @@
 import { createRequire as __seoCreateRequire } from 'node:module'; const require = __seoCreateRequire(import.meta.url);
-import { n as load, t as version } from "./package-Cuxp-LBy.js";
+import { n as load, t as version } from "./package-D_ix15KL.js";
 import { Headers, fetch as fetch$1 } from "undici";
 import { chmodSync, createReadStream, createWriteStream, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { arch, homedir, platform, totalmem } from "node:os";
@@ -1102,6 +1102,52 @@ async function exchangeCode(input) {
 	return tokenResponse.json();
 }
 //#endregion
+//#region packages/core/src/keyword-sets/schema.ts
+const KEYWORD_SET_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS keyword_sets (
+  id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL,
+  name TEXT NOT NULL,
+  market_json TEXT NOT NULL,
+  provider TEXT CHECK(provider IS NULL OR provider IN ('dataforseo', 'semrush', 'ahrefs')),
+  source_report TEXT,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  last_refreshed_at INTEGER,
+  UNIQUE(project_id, name COLLATE NOCASE)
+);
+CREATE INDEX IF NOT EXISTS idx_keyword_sets_project
+  ON keyword_sets(project_id, updated_at DESC, id);
+
+CREATE TABLE IF NOT EXISTS keyword_set_items (
+  set_id TEXT NOT NULL,
+  normalized_keyword TEXT NOT NULL,
+  display_keyword TEXT NOT NULL,
+  metric_json TEXT,
+  metric_provider TEXT CHECK(metric_provider IS NULL OR metric_provider IN ('dataforseo', 'semrush', 'ahrefs')),
+  metric_observed_at TEXT,
+  page_kind TEXT CHECK(page_kind IS NULL OR page_kind IN ('target', 'proposed')),
+  page_url TEXT,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  PRIMARY KEY(set_id, normalized_keyword),
+  FOREIGN KEY(set_id) REFERENCES keyword_sets(id) ON DELETE CASCADE
+) WITHOUT ROWID;
+CREATE INDEX IF NOT EXISTS idx_keyword_set_items_set
+  ON keyword_set_items(set_id, normalized_keyword);
+
+CREATE TABLE IF NOT EXISTS keyword_set_tags (
+  set_id TEXT NOT NULL,
+  normalized_keyword TEXT NOT NULL,
+  tag TEXT NOT NULL,
+  PRIMARY KEY(set_id, normalized_keyword, tag),
+  FOREIGN KEY(set_id, normalized_keyword)
+    REFERENCES keyword_set_items(set_id, normalized_keyword) ON DELETE CASCADE
+) WITHOUT ROWID;
+CREATE INDEX IF NOT EXISTS idx_keyword_set_tags_lookup
+  ON keyword_set_tags(set_id, tag, normalized_keyword);
+`;
+//#endregion
 //#region packages/core/src/storage/cache-maintenance.ts
 const MEBIBYTE$2 = 1024 * 1024;
 const CACHE_MAX_BYTES = 256 * MEBIBYTE$2;
@@ -1657,6 +1703,7 @@ function initDb(database, isNewDatabase) {
 	if (isNewDatabase) database.pragma("auto_vacuum = INCREMENTAL");
 	database.transaction(() => {
 		database.exec(CREATE_SQL);
+		database.exec(KEYWORD_SET_SCHEMA_SQL);
 		database.exec(PROVIDER_SPEND_SCHEMA_SQL);
 		database.exec(`DELETE FROM semrush_cache WHERE request_json LIKE '%"key"%'`);
 		ensureColumn(database, "crawl_pages", "snapshot_json", "TEXT");
@@ -4890,7 +4937,7 @@ async function fetchPage(url, opts = {}, dependencies = {}) {
 }
 //#endregion
 //#region packages/core/src/gsc/property-url.ts
-function invalid(message) {
+function invalid$1(message) {
 	throw new SeoError("INVALID_INPUT", message);
 }
 function normalizeHttpUrl(value) {
@@ -4898,10 +4945,10 @@ function normalizeHttpUrl(value) {
 	try {
 		url = new URL(value.trim());
 	} catch {
-		return invalid(`Invalid URL: ${value}`);
+		return invalid$1(`Invalid URL: ${value}`);
 	}
-	if (url.protocol !== "http:" && url.protocol !== "https:") return invalid("The report URL must use http:// or https://.");
-	if (url.username || url.password) return invalid("The report URL must not contain embedded credentials.");
+	if (url.protocol !== "http:" && url.protocol !== "https:") return invalid$1("The report URL must use http:// or https://.");
+	if (url.username || url.password) return invalid$1("The report URL must not contain embedded credentials.");
 	url.hash = "";
 	return url.toString();
 }
@@ -4910,13 +4957,13 @@ function assertUrlMatchesGscProperty(property, value) {
 	const parsed = new URL(url);
 	if (property.startsWith("sc-domain:")) {
 		const domain = property.slice(10).trim().toLowerCase();
-		if (!domain || /[/:]/.test(domain)) return invalid(`Invalid Search Console domain property: ${property}`);
+		if (!domain || /[/:]/.test(domain)) return invalid$1(`Invalid Search Console domain property: ${property}`);
 		const hostname = parsed.hostname.toLowerCase();
-		if (hostname !== domain && !hostname.endsWith(`.${domain}`)) return invalid(`${url} is outside the Search Console property ${property}.`);
+		if (hostname !== domain && !hostname.endsWith(`.${domain}`)) return invalid$1(`${url} is outside the Search Console property ${property}.`);
 		return url;
 	}
 	const prefix = normalizeHttpUrl(property);
-	if (!url.startsWith(prefix)) return invalid(`${url} is outside the Search Console property ${property}.`);
+	if (!url.startsWith(prefix)) return invalid$1(`${url} is outside the Search Console property ${property}.`);
 	return url;
 }
 //#endregion
@@ -23807,7 +23854,7 @@ const MAX_ACTIVE_RESERVATIONS = 100;
 const PROVIDER_SPEND_RETENTION_DAYS = RETENTION_MS / DAY_MS$1;
 const PROVIDER_SPEND_MAX_ROWS = MAX_LEDGER_ROWS;
 const PROVIDER_SPEND_MAX_BYTES = MAX_LEDGER_BYTES;
-function boundedText(provider, value, label, max) {
+function boundedText$1(provider, value, label, max) {
 	const normalized = value.trim();
 	if (!normalized || normalized.length > max) throw new ProviderError({
 		provider,
@@ -23904,10 +23951,10 @@ function reserveProviderSpend(input, options = {}) {
 	const now = options.now ?? Date.now();
 	const normalized = {
 		...input,
-		endpoint: boundedText(input.provider, input.endpoint, "Provider endpoint", 500),
-		projectId: input.projectId ? boundedText(input.provider, input.projectId, "Project id", 200) : void 0,
-		reportId: boundedText(input.provider, input.reportId, "Report id", 100),
-		reportRunId: boundedText(input.provider, input.reportRunId, "Report run id", 100),
+		endpoint: boundedText$1(input.provider, input.endpoint, "Provider endpoint", 500),
+		projectId: input.projectId ? boundedText$1(input.provider, input.projectId, "Project id", 200) : void 0,
+		reportId: boundedText$1(input.provider, input.reportId, "Report id", 100),
+		reportRunId: boundedText$1(input.provider, input.reportRunId, "Report run id", 100),
 		requestedRows: nonnegativeInteger(input.provider, input.requestedRows, "Requested rows"),
 		estimatedCostMicros: nonnegativeInteger(input.provider, input.estimatedCostMicros, "Estimated cost")
 	};
@@ -23944,7 +23991,7 @@ function reserveProviderSpend(input, options = {}) {
 function finalizeProviderSpend(reservationId, result, options = {}) {
 	const database = options.database ?? getDb();
 	const now = options.now ?? Date.now();
-	const taskIds = [...new Set(result.taskIds)].sort((left, right) => left < right ? -1 : left > right ? 1 : 0).slice(0, MAX_TASK_IDS).map((id) => boundedText(result.provider, id, "Provider task id", 100));
+	const taskIds = [...new Set(result.taskIds)].sort((left, right) => left < right ? -1 : left > right ? 1 : 0).slice(0, MAX_TASK_IDS).map((id) => boundedText$1(result.provider, id, "Provider task id", 100));
 	const actualCostMicros = result.actualCostMicros === null ? null : nonnegativeInteger(result.provider, result.actualCostMicros, "Actual cost");
 	const returnedRows = result.returnedRows === null ? null : nonnegativeInteger(result.provider, result.returnedRows, "Returned rows");
 	return database.transaction(() => {
@@ -24277,7 +24324,7 @@ const dataForSeoUserDataResponseSchema = z.object({
 const MAX_PROVIDER_MONTHLY_SEARCH_ROWS = 120;
 const nullableNumber = z.number().finite().nullable().optional();
 const nullableCount = z.union([z.number().finite(), z.string().trim().min(1)]).nullable().optional();
-const monthlySearchSchema = z.object({
+const monthlySearchSchema$1 = z.object({
 	year: z.number().int(),
 	month: z.number().int(),
 	search_volume: z.number().finite().nullable().optional()
@@ -24288,7 +24335,7 @@ const keywordOverviewItemSchema = z.object({
 		search_volume: nullableNumber,
 		cpc: nullableNumber,
 		competition: nullableNumber,
-		monthly_searches: z.array(monthlySearchSchema).max(MAX_PROVIDER_MONTHLY_SEARCH_ROWS).nullish(),
+		monthly_searches: z.array(monthlySearchSchema$1).max(MAX_PROVIDER_MONTHLY_SEARCH_ROWS).nullish(),
 		last_updated_time: z.string().trim().min(1).nullable().optional()
 	}).nullish(),
 	keyword_properties: z.object({ keyword_difficulty: nullableNumber }).nullish(),
@@ -24302,7 +24349,7 @@ const keywordOverviewItemSchema = z.object({
 }).passthrough();
 const keywordOverviewResultSchema = z.object({
 	items_count: z.number().int().nonnegative().optional(),
-	items: z.array(keywordOverviewItemSchema).optional()
+	items: z.array(keywordOverviewItemSchema).nullable().optional()
 }).passthrough();
 const keywordOverviewTaskSchema = z.object({
 	id: z.string().trim().min(1).optional(),
@@ -25253,13 +25300,55 @@ var DataForSeoKeywordMetricsProvider = class {
 		status: "available",
 		markets: [{
 			searchEngines: ["google"],
-			location: "any"
+			location: "country-only"
 		}]
 	}];
 	client;
 	constructor(options = {}) {
 		this.client = options.client ?? new DataForSeoClient(options);
 	}
+	async estimateKeywordMetricsCost(input) {
+		if (!Number.isSafeInteger(input.requestedRows) || input.requestedRows < 1 || input.requestedRows > 1e4) throw new ProviderError({
+			provider: "dataforseo",
+			operation: "keyword-metrics-cost",
+			code: "configuration",
+			message: "Keyword metric cost estimates require 1 to 10000 rows."
+		});
+		if (!searchMarketSchema.safeParse(input.market).success) throw new ProviderError({
+			provider: "dataforseo",
+			operation: "keyword-metrics-cost",
+			code: "configuration",
+			message: "Keyword metric cost estimates require a valid market."
+		});
+		if (input.market.location) throw new ProviderError({
+			provider: "dataforseo",
+			operation: "keyword-metrics-cost",
+			code: "configuration",
+			message: "DataForSEO Labs keyword metrics supports country-level markets; omit market.location and use countryCode."
+		});
+		if (!this.client.userData) throw new ProviderError({
+			provider: "dataforseo",
+			operation: "keyword-metrics-cost",
+			code: "configuration",
+			message: "Keyword metric cost estimation is unavailable."
+		});
+		const account = await this.client.userData();
+		const { perRequestMicros, perResultMicros } = account.keywordOverviewPrice;
+		const requestCount = Math.ceil(input.requestedRows / 50);
+		const complete = perRequestMicros !== null && perResultMicros !== null;
+		return {
+			schemaVersion: 1,
+			provider: "dataforseo",
+			capability: "keyword-metrics",
+			currency: "USD",
+			requestedRows: input.requestedRows,
+			requestCount,
+			estimatedMicros: complete ? requestCount * perRequestMicros + input.requestedRows * perResultMicros : null,
+			observedAt: account.observedAt,
+			completeness: complete ? "complete" : "unavailable",
+			basis: complete ? "Current account pricing for normal-priority live keyword overview requests." : "The provider account response did not include complete keyword overview pricing."
+		};
+	}
 	async keywordMetrics(input) {
 		const market = searchMarketSchema.parse(input.market);
 		if (market.searchEngine !== "google") throw new ProviderError({
@@ -25268,6 +25357,12 @@ var DataForSeoKeywordMetricsProvider = class {
 			code: "configuration",
 			message: "DataForSEO keyword metrics currently supports Google markets."
 		});
+		if (market.location) throw new ProviderError({
+			provider: "dataforseo",
+			operation: "keyword-metrics",
+			code: "configuration",
+			message: "DataForSEO Labs keyword metrics supports country-level markets; omit market.location and use countryCode."
+		});
 		if (input.keywords.length < 1 || input.keywords.length > MAX_KEYWORDS_PER_REPORT || input.keywords.some((keyword) => {
 			const normalized = keyword.trim();
 			return normalized.length < 1 || normalized.length > 80 || normalized.split(/\s+/u).length > 10;
@@ -25474,7 +25569,7 @@ function analyzeKeywordTrend(metric) {
 function keywordMetricsProvider(candidate) {
 	return "keywordMetrics" in candidate && typeof candidate.keywordMetrics === "function" ? candidate : null;
 }
-async function defaultCandidates$2() {
+async function defaultCandidates$3() {
 	return [{
 		adapter: new DataForSeoKeywordMetricsProvider(),
 		connected: Boolean(await readDataForSeoCredentials()),
@@ -25483,6 +25578,7 @@ async function defaultCandidates$2() {
 }
 function providerResolutionError(input) {
 	if (input.reason === "provider-not-connected") return new SeoError("PROVIDER_UNAVAILABLE", "No connected provider can supply keyword metrics. Run `seo providers dataforseo connect` first.");
+	if (input.provider && input.reason === "market-not-supported") return new SeoError("INVALID_INPUT", input.provider === "dataforseo" ? "DataForSEO keyword metrics uses country-level Labs data. Omit location and keep countryCode, then run serp-results separately for a local snapshot." : `${input.provider} cannot supply keyword metrics for this market.`);
 	if (input.provider) return new SeoError("PROVIDER_UNAVAILABLE", `${input.provider} cannot supply keyword metrics for this market.`);
 	return new SeoError("PROVIDER_UNAVAILABLE", "No configured provider can supply keyword metrics for this market.");
 }
@@ -25528,7 +25624,7 @@ async function keywordMetricsReport(input, dependencies = {}) {
 	const validated = validateInput$3(input);
 	let candidates;
 	try {
-		candidates = dependencies.candidates ?? await defaultCandidates$2();
+		candidates = dependencies.candidates ?? await defaultCandidates$3();
 	} catch (error) {
 		return providerReportError(error);
 	}
@@ -27087,7 +27183,7 @@ var DataForSeoKeywordDiscoveryProvider = class {
 		status: "available",
 		markets: [{
 			searchEngines: ["google"],
-			location: "any"
+			location: "country-only"
 		}]
 	}];
 	client;
@@ -27102,6 +27198,12 @@ var DataForSeoKeywordDiscoveryProvider = class {
 			code: "configuration",
 			message: "DataForSEO keyword discovery currently supports Google."
 		});
+		if (market.location) throw new ProviderError({
+			provider: "dataforseo",
+			operation: "keyword-discovery",
+			code: "configuration",
+			message: "DataForSEO Labs keyword discovery supports country-level markets; omit market.location and use countryCode."
+		});
 		const seeds = [...new Set(input.seeds.map(normalizedKeyword$1))].filter(Boolean).sort(compareCodepoints$3);
 		if (seeds.length < 1 || seeds.length > MAX_DISCOVERY_SEEDS || seeds.some((seed) => seed.length > 80 || seed.split(/\s+/u).length > 10)) throw new ProviderError({
 			provider: "dataforseo",
@@ -27217,14 +27319,14 @@ function compareCodepoints$1(left, right) {
 function discoveryProvider(candidate) {
 	return "discoverKeywords" in candidate && typeof candidate.discoverKeywords === "function" ? candidate : null;
 }
-async function defaultCandidates$1() {
+async function defaultCandidates$2() {
 	return [{
 		adapter: new DataForSeoKeywordDiscoveryProvider(),
 		connected: Boolean(await readDataForSeoCredentials()),
 		priority: 10
 	}];
 }
-function providerError$1(error) {
+function providerError$2(error) {
 	if (!(error instanceof ProviderError)) throw error;
 	if (error.code === "rate-limit") throw new SeoError("RATE_LIMITED", error.message);
 	if (error.code === "configuration") throw new SeoError("INVALID_INPUT", error.message);
@@ -27290,9 +27392,9 @@ async function keywordResearchReport(input, dependencies = {}) {
 	});
 	let candidates;
 	try {
-		candidates = dependencies.candidates ?? await defaultCandidates$1();
+		candidates = dependencies.candidates ?? await defaultCandidates$2();
 	} catch (error) {
-		return providerError$1(error);
+		return providerError$2(error);
 	}
 	const resolution = resolveProvider({
 		capability: "keyword-discovery",
@@ -27300,7 +27402,10 @@ async function keywordResearchReport(input, dependencies = {}) {
 		candidates,
 		provider: validated.provider
 	});
-	if (resolution.status === "unavailable") throw new SeoError("PROVIDER_UNAVAILABLE", resolution.reason === "provider-not-connected" ? "No connected provider can discover keywords. Run `seo providers dataforseo connect` first." : validated.provider ? `${validated.provider} cannot discover keywords for this market.` : "No configured provider can discover keywords for this market.");
+	if (resolution.status === "unavailable") {
+		const message = resolution.reason === "provider-not-connected" ? "No connected provider can discover keywords. Run `seo providers dataforseo connect` first." : validated.provider ? `${validated.provider} cannot discover keywords for this market.` : "No configured provider can discover keywords for this market.";
+		throw new SeoError(validated.provider && resolution.reason === "market-not-supported" ? "INVALID_INPUT" : "PROVIDER_UNAVAILABLE", validated.provider === "dataforseo" && resolution.reason === "market-not-supported" ? "DataForSEO keyword discovery uses country-level Labs data. Omit location and keep countryCode, then run serp-results separately for a local snapshot." : message);
+	}
 	const provider = discoveryProvider(resolution.provider);
 	if (!provider) throw new SeoError("PROVIDER_UNAVAILABLE", "The selected provider has no keyword discovery implementation.");
 	let evidence;
@@ -27318,7 +27423,7 @@ async function keywordResearchReport(input, dependencies = {}) {
 			}
 		});
 	} catch (error) {
-		return providerError$1(error);
+		return providerError$2(error);
 	}
 	const analysis = evidence.data.map((idea) => ({
 		keyword: idea.keyword,
@@ -32022,6 +32127,7 @@ var DataForSeoSerpSnapshotProvider = class {
 		const organicResults = mappedOrganicResults.slice(0, input.depth);
 		const invalidRows = organicItems.length - mappedOrganicResults.length;
 		const resultCapped = mappedOrganicResults.length > input.depth;
+		const invalidResultCount = result.se_results_count !== null && result.se_results_count !== void 0 && result.se_results_count < organicResults.length;
 		if (invalidRows > 0) warnings.push({
 			code: "invalid-organic-results",
 			field: "organicResults",
@@ -32038,6 +32144,11 @@ var DataForSeoSerpSnapshotProvider = class {
 			field: "checkUrl",
 			message: "DataForSEO returned an invalid SERP check URL."
 		});
+		if (invalidResultCount) warnings.push({
+			code: "invalid-serp-result-count",
+			field: "resultCount",
+			message: "DataForSEO returned an estimated result count below the retained organic result count; the estimate was discarded."
+		});
 		const features = [.../* @__PURE__ */ new Set([...result.item_types ?? [], ...items.map((item) => item.type)])].sort(compareCodepoints$3);
 		return {
 			schemaVersion: 1,
@@ -32049,7 +32160,7 @@ var DataForSeoSerpSnapshotProvider = class {
 				searchEngineDomain: result.se_domain?.trim().toLowerCase() ?? null,
 				checkedAt: checkedAt(result.datetime, snapshot.observedAt),
 				checkUrl,
-				resultCount: result.se_results_count === void 0 ? null : result.se_results_count,
+				resultCount: invalidResultCount ? null : result.se_results_count ?? null,
 				pagesCount: result.pages_count === void 0 ? null : result.pages_count,
 				features,
 				organicResults
@@ -32064,8 +32175,8 @@ var DataForSeoSerpSnapshotProvider = class {
 				returnedRows: snapshot.returnedRows,
 				retainedRows: organicResults.length,
 				invalidRows,
-				providerTotalRows: result.se_results_count ?? null,
-				completeness: invalidRows > 0 ? "partial" : resultCapped ? "capped" : "complete",
+				providerTotalRows: invalidResultCount ? null : result.se_results_count ?? null,
+				completeness: invalidRows > 0 || invalidResultCount ? "partial" : resultCapped ? "capped" : "complete",
 				nextCursor: null
 			},
 			cache: snapshot.cache,
@@ -32095,14 +32206,14 @@ function compareCodepoints(left, right) {
 function snapshotProvider(candidate) {
 	return "serpSnapshot" in candidate && typeof candidate.serpSnapshot === "function" ? candidate : null;
 }
-async function defaultCandidates() {
+async function defaultCandidates$1() {
 	return [{
 		adapter: new DataForSeoSerpSnapshotProvider(),
 		connected: Boolean(await readDataForSeoCredentials()),
 		priority: 10
 	}];
 }
-function providerError(error) {
+function providerError$1(error) {
 	if (!(error instanceof ProviderError)) throw error;
 	if (error.code === "rate-limit") throw new SeoError("RATE_LIMITED", error.message);
 	if (error.code === "configuration") throw new SeoError("INVALID_INPUT", error.message);
@@ -32162,9 +32273,9 @@ async function serpResultsReport(input, dependencies = {}) {
 	});
 	let candidates;
 	try {
-		candidates = dependencies.candidates ?? await defaultCandidates();
+		candidates = dependencies.candidates ?? await defaultCandidates$1();
 	} catch (error) {
-		return providerError(error);
+		return providerError$1(error);
 	}
 	const resolution = resolveProvider({
 		capability: "serp-snapshot",
@@ -32189,7 +32300,7 @@ async function serpResultsReport(input, dependencies = {}) {
 			}
 		});
 	} catch (error) {
-		return providerError(error);
+		return providerError$1(error);
 	}
 	const domains = domainSummaries(evidence.data);
 	const dataStatus = reportStatus$1(evidence);
@@ -32904,6 +33015,722 @@ function reportPresentation(report) {
 	};
 }
 //#endregion
+//#region packages/core/src/keyword-sets/limits.ts
+const KEYWORD_SET_LIMITS = {
+	setsPerProject: 25,
+	totalSets: 100,
+	keywordsPerSet: 1e4,
+	totalKeywords: 1e5,
+	mutationKeywords: 1e3,
+	tagsPerKeyword: 20,
+	outputRows: 1e3,
+	logicalBytes: 64 * 1024 * 1024
+};
+const KEYWORD_SET_FIELD_LIMITS = {
+	name: 80,
+	projectId: 80,
+	sourceReport: 100,
+	keyword: 80,
+	keywordWords: 10,
+	tag: 40,
+	url: 2048,
+	metricJsonBytes: 16 * 1024
+};
+//#endregion
+//#region packages/core/src/keyword-sets/validation.ts
+const unavailableValueSchema = z.strictObject({
+	state: z.enum([
+		"missing",
+		"unavailable",
+		"invalid"
+	]),
+	value: z.null(),
+	reason: z.string().min(1).max(500)
+});
+const providerValueNumberSchema = z.discriminatedUnion("state", [z.strictObject({
+	state: z.literal("observed"),
+	value: z.number().finite()
+}), unavailableValueSchema]);
+const providerValueStringSchema = z.discriminatedUnion("state", [z.strictObject({
+	state: z.literal("observed"),
+	value: z.string().max(500)
+}), unavailableValueSchema]);
+const monthlySearchSchema = z.strictObject({
+	year: z.number().int().min(2e3).max(2200),
+	month: z.number().int().min(1).max(12),
+	searchVolume: z.number().finite().nonnegative()
+});
+const providerValueMonthlySearchesSchema = z.discriminatedUnion("state", [z.strictObject({
+	state: z.literal("observed"),
+	value: z.array(monthlySearchSchema).max(24)
+}), unavailableValueSchema]);
+const keywordMetricSchema = z.strictObject({
+	keyword: z.string().min(1).max(KEYWORD_SET_FIELD_LIMITS.keyword),
+	monthlySearchVolume: providerValueNumberSchema,
+	monthlySearches: providerValueMonthlySearchesSchema,
+	searchVolumeUpdatedAt: providerValueStringSchema,
+	cpcUsd: providerValueNumberSchema,
+	paidCompetition: providerValueNumberSchema,
+	keywordDifficulty: providerValueNumberSchema,
+	intent: providerValueStringSchema,
+	resultCount: providerValueNumberSchema
+});
+const savedMetricSchema = z.strictObject({
+	schemaVersion: z.literal(1),
+	provider: providerIdSchema,
+	observedAt: z.iso.datetime(),
+	metric: keywordMetricSchema
+});
+function invalid(message) {
+	throw new SeoError("INVALID_INPUT", message);
+}
+function boundedText(value, label, max) {
+	const normalized = value.trim();
+	if (!normalized || normalized.length > max) invalid(`${label} must contain 1 to ${max} characters.`);
+	return normalized;
+}
+function normalizeSavedKeyword(value) {
+	const normalized = value.trim().replace(/\s+/gu, " ").toLowerCase();
+	if (!normalized || normalized.length > KEYWORD_SET_FIELD_LIMITS.keyword || normalized.split(" ").length > KEYWORD_SET_FIELD_LIMITS.keywordWords) invalid(`Keywords must contain 1 to ${KEYWORD_SET_FIELD_LIMITS.keyword} characters and at most ${KEYWORD_SET_FIELD_LIMITS.keywordWords} words.`);
+	return normalized;
+}
+function displayKeyword(value) {
+	normalizeSavedKeyword(value);
+	return value.trim().replace(/\s+/gu, " ");
+}
+function normalizedTags(values = []) {
+	if (values.length > KEYWORD_SET_LIMITS.tagsPerKeyword) invalid(`A keyword can have at most ${KEYWORD_SET_LIMITS.tagsPerKeyword} tags.`);
+	const tags = [...new Set(values.map((value) => boundedText(value, "Tag", KEYWORD_SET_FIELD_LIMITS.tag).toLowerCase()))].sort();
+	if (tags.length > KEYWORD_SET_LIMITS.tagsPerKeyword) invalid(`A keyword can have at most ${KEYWORD_SET_LIMITS.tagsPerKeyword} tags.`);
+	return tags;
+}
+function pageMapping(value) {
+	if (value === null || value === void 0) return value;
+	if (value.kind !== "target" && value.kind !== "proposed") invalid("Page mapping kind must be target or proposed.");
+	const raw = boundedText(value.url, "Page URL", KEYWORD_SET_FIELD_LIMITS.url);
+	let url;
+	try {
+		url = new URL(raw);
+	} catch {
+		invalid("Page mapping must use an absolute HTTP or HTTPS URL.");
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") invalid("Page mapping must use an absolute HTTP or HTTPS URL.");
+	return {
+		kind: value.kind,
+		url: url.toString()
+	};
+}
+function savedMetric(value, normalizedKeyword) {
+	if (value === null || value === void 0) return {
+		value,
+		json: null
+	};
+	const parsed = savedMetricSchema.safeParse(value);
+	if (!parsed.success) invalid("Use a valid normalized keyword metric snapshot.");
+	if (normalizeSavedKeyword(parsed.data.metric.keyword) !== normalizedKeyword) invalid("A saved metric must describe the same keyword as the set item.");
+	const json = JSON.stringify(parsed.data);
+	if (Buffer.byteLength(json) > KEYWORD_SET_FIELD_LIMITS.metricJsonBytes) invalid(`A saved keyword metric cannot exceed ${KEYWORD_SET_FIELD_LIMITS.metricJsonBytes} bytes.`);
+	return {
+		value: parsed.data,
+		json
+	};
+}
+function validateMutationItems(items) {
+	if (items.length < 1 || items.length > KEYWORD_SET_LIMITS.mutationKeywords) invalid(`Add 1 to ${KEYWORD_SET_LIMITS.mutationKeywords} keywords per operation.`);
+	const normalized = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const key = normalizeSavedKeyword(item.keyword);
+		const existing = normalized.get(key);
+		const tags = normalizedTags([...existing?.tags ?? [], ...item.tags ?? []]);
+		const page = pageMapping(item.page !== void 0 ? item.page : existing?.page);
+		const metric = savedMetric(item.latestMetric !== void 0 ? item.latestMetric : existing?.metric, key);
+		normalized.set(key, {
+			keyword: existing?.keyword ?? displayKeyword(item.keyword),
+			tags,
+			page,
+			metric: metric.value,
+			metricJson: metric.json
+		});
+	}
+	return normalized;
+}
+function parseStoredJson(value, schema, label) {
+	let decoded;
+	try {
+		decoded = JSON.parse(value);
+	} catch {
+		throw new SeoError("INTERNAL_ERROR", `${label} contains invalid JSON.`);
+	}
+	const parsed = schema.safeParse(decoded);
+	if (!parsed.success) throw new SeoError("INTERNAL_ERROR", `${label} has an invalid shape.`);
+	return parsed.data;
+}
+//#endregion
+//#region packages/core/src/keyword-sets/rows.ts
+const SET_SELECT = `
+  SELECT sets.*,
+    (SELECT COUNT(*) FROM keyword_set_items items WHERE items.set_id = sets.id) AS keyword_count,
+    (SELECT COUNT(DISTINCT tags.tag) FROM keyword_set_tags tags WHERE tags.set_id = sets.id) AS tag_count
+  FROM keyword_sets sets`;
+function storeDatabase(options) {
+	return options.database ?? getDb();
+}
+function rowToSet(row) {
+	const provider = row.provider ? providerIdSchema.safeParse(row.provider) : void 0;
+	if (provider && !provider.success) throw new SeoError("INTERNAL_ERROR", "Saved keyword set provider is invalid.");
+	return {
+		schemaVersion: 1,
+		id: row.id,
+		projectId: row.project_id,
+		name: row.name,
+		market: parseStoredJson(row.market_json, searchMarketSchema, "Saved search market"),
+		provider: provider?.data ?? null,
+		sourceReport: row.source_report,
+		keywordCount: row.keyword_count,
+		tagCount: row.tag_count,
+		createdAt: new Date(row.created_at).toISOString(),
+		updatedAt: new Date(row.updated_at).toISOString(),
+		lastRefreshedAt: row.last_refreshed_at === null ? null : new Date(row.last_refreshed_at).toISOString()
+	};
+}
+function findSetRow(db, projectId, idOrName) {
+	return db.prepare(`${SET_SELECT}
+       WHERE sets.project_id = ?
+         AND (sets.id = ? OR sets.name = ? COLLATE NOCASE)
+       ORDER BY CASE WHEN sets.id = ? THEN 0 ELSE 1 END
+       LIMIT 1`).get(projectId, idOrName, idOrName, idOrName);
+}
+function requireSetRow(db, projectId, idOrName) {
+	const row = findSetRow(db, projectId, idOrName);
+	if (!row) invalid(`Keyword set not found: ${idOrName}`);
+	return row;
+}
+function rowCount(db, sql, ...params) {
+	return db.prepare(sql).get(...params).count;
+}
+function keywordSetLogicalBytes(db = getDb()) {
+	return db.prepare(`SELECT
+        COALESCE((SELECT SUM(length(id) + length(project_id) + length(name) + length(market_json) + COALESCE(length(provider), 0) + COALESCE(length(source_report), 0)) FROM keyword_sets), 0) +
+        COALESCE((SELECT SUM(length(set_id) + length(normalized_keyword) + length(display_keyword) + COALESCE(length(metric_json), 0) + COALESCE(length(metric_provider), 0) + COALESCE(length(metric_observed_at), 0) + COALESCE(length(page_kind), 0) + COALESCE(length(page_url), 0)) FROM keyword_set_items), 0) +
+        COALESCE((SELECT SUM(length(set_id) + length(normalized_keyword) + length(tag)) FROM keyword_set_tags), 0)
+        AS bytes`).get().bytes;
+}
+function enforceKeywordSetLogicalBytes(db, maxLogicalBytes = KEYWORD_SET_LIMITS.logicalBytes) {
+	if (keywordSetLogicalBytes(db) > maxLogicalBytes) invalid(`Saved keyword data cannot exceed ${maxLogicalBytes} logical bytes. Remove an unused set before adding more.`);
+}
+//#endregion
+//#region packages/core/src/keyword-sets/mutations.ts
+function addKeywordsToSet(input, options = {}) {
+	const projectId = boundedText(input.projectId, "Project id", KEYWORD_SET_FIELD_LIMITS.projectId);
+	const idOrName = boundedText(input.idOrName, "Keyword set id or name", KEYWORD_SET_FIELD_LIMITS.name);
+	const items = validateMutationItems(input.items);
+	const db = storeDatabase(options);
+	const set = requireSetRow(db, projectId, idOrName);
+	const currentSetCount = rowCount(db, "SELECT COUNT(*) AS count FROM keyword_set_items WHERE set_id = ?", set.id);
+	const currentTotalCount = rowCount(db, "SELECT COUNT(*) AS count FROM keyword_set_items");
+	const existingRows = db.prepare(`SELECT * FROM keyword_set_items
+       WHERE set_id = ? AND normalized_keyword IN (${[...items].map(() => "?").join(", ")})`).all(set.id, ...items.keys());
+	const existing = new Map(existingRows.map((row) => [row.normalized_keyword, row]));
+	const additions = items.size - existing.size;
+	if (currentSetCount + additions > KEYWORD_SET_LIMITS.keywordsPerSet) invalid(`A keyword set can contain at most ${KEYWORD_SET_LIMITS.keywordsPerSet} keywords.`);
+	if (currentTotalCount + additions > KEYWORD_SET_LIMITS.totalKeywords) invalid(`At most ${KEYWORD_SET_LIMITS.totalKeywords} keywords can be saved across all sets.`);
+	const now = (options.now ?? (() => /* @__PURE__ */ new Date()))().getTime();
+	const updated = /* @__PURE__ */ new Set();
+	db.transaction(() => {
+		for (const [normalizedKeyword, item] of items) {
+			const existingItem = existing.get(normalizedKeyword);
+			if (!existingItem) insertKeyword(db, set.id, normalizedKeyword, item, now);
+			else if (updateKeyword(db, set.id, normalizedKeyword, item, existingItem, now)) updated.add(normalizedKeyword);
+			if (addTags(db, set.id, normalizedKeyword, item.tags) && existingItem) {
+				updated.add(normalizedKeyword);
+				db.prepare(`UPDATE keyword_set_items SET updated_at = ?
+           WHERE set_id = ? AND normalized_keyword = ?`).run(now, set.id, normalizedKeyword);
+			}
+		}
+		if (additions > 0 || updated.size > 0) db.prepare("UPDATE keyword_sets SET updated_at = ? WHERE id = ?").run(now, set.id);
+		enforceKeywordSetLogicalBytes(db, options.maxLogicalBytes);
+	}).immediate();
+	return {
+		setId: set.id,
+		requested: input.items.length,
+		normalized: items.size,
+		added: additions,
+		removed: 0,
+		existing: existing.size,
+		updated: updated.size,
+		keywordCount: currentSetCount + additions
+	};
+}
+function insertKeyword(db, setId, normalizedKeyword, item, now) {
+	db.prepare(`INSERT INTO keyword_set_items
+     (set_id, normalized_keyword, display_keyword, metric_json, metric_provider,
+      metric_observed_at, page_kind, page_url, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(setId, normalizedKeyword, item.keyword, item.metricJson, item.metric?.provider ?? null, item.metric?.observedAt ?? null, item.page?.kind ?? null, item.page?.url ?? null, now, now);
+}
+function updateKeyword(db, setId, normalizedKeyword, item, existingItem, now) {
+	const pageChanged = item.page !== void 0 && (existingItem.page_kind !== (item.page?.kind ?? null) || existingItem.page_url !== (item.page?.url ?? null));
+	const metricChanged = item.metric !== void 0 && existingItem.metric_json !== item.metricJson;
+	if (!pageChanged && !metricChanged) return false;
+	db.prepare(`UPDATE keyword_set_items SET
+       page_kind = CASE WHEN ? THEN ? ELSE page_kind END,
+       page_url = CASE WHEN ? THEN ? ELSE page_url END,
+       metric_json = CASE WHEN ? THEN ? ELSE metric_json END,
+       metric_provider = CASE WHEN ? THEN ? ELSE metric_provider END,
+       metric_observed_at = CASE WHEN ? THEN ? ELSE metric_observed_at END,
+       updated_at = ?
+     WHERE set_id = ? AND normalized_keyword = ?`).run(pageChanged ? 1 : 0, item.page?.kind ?? null, pageChanged ? 1 : 0, item.page?.url ?? null, metricChanged ? 1 : 0, item.metricJson, metricChanged ? 1 : 0, item.metric?.provider ?? null, metricChanged ? 1 : 0, item.metric?.observedAt ?? null, now, setId, normalizedKeyword);
+	return true;
+}
+function addTags(db, setId, normalizedKeyword, tags) {
+	let changed = false;
+	for (const tag of tags) {
+		const inserted = db.prepare(`INSERT OR IGNORE INTO keyword_set_tags
+         (set_id, normalized_keyword, tag) VALUES (?, ?, ?)`).run(setId, normalizedKeyword, tag);
+		changed ||= inserted.changes > 0;
+	}
+	return changed;
+}
+function removeKeywordsFromSet(input, options = {}) {
+	if (input.keywords.length < 1 || input.keywords.length > KEYWORD_SET_LIMITS.mutationKeywords) invalid(`Remove 1 to ${KEYWORD_SET_LIMITS.mutationKeywords} keywords per operation.`);
+	const projectId = boundedText(input.projectId, "Project id", KEYWORD_SET_FIELD_LIMITS.projectId);
+	const idOrName = boundedText(input.idOrName, "Keyword set id or name", KEYWORD_SET_FIELD_LIMITS.name);
+	const keywords = [...new Set(input.keywords.map(normalizeSavedKeyword))];
+	const db = storeDatabase(options);
+	const set = requireSetRow(db, projectId, idOrName);
+	const removed = db.prepare(`DELETE FROM keyword_set_items
+       WHERE set_id = ? AND normalized_keyword IN (${keywords.map(() => "?").join(", ")})`).run(set.id, ...keywords).changes;
+	const now = (options.now ?? (() => /* @__PURE__ */ new Date()))().getTime();
+	if (removed > 0) db.prepare("UPDATE keyword_sets SET updated_at = ? WHERE id = ?").run(now, set.id);
+	const keywordCount = rowCount(db, "SELECT COUNT(*) AS count FROM keyword_set_items WHERE set_id = ?", set.id);
+	return {
+		setId: set.id,
+		requested: input.keywords.length,
+		normalized: keywords.length,
+		added: 0,
+		removed,
+		existing: keywords.length - removed,
+		updated: 0,
+		keywordCount
+	};
+}
+function setKeywordSetRefreshTime(input, options = {}) {
+	const projectId = boundedText(input.projectId, "Project id", KEYWORD_SET_FIELD_LIMITS.projectId);
+	const idOrName = boundedText(input.idOrName, "Keyword set id or name", KEYWORD_SET_FIELD_LIMITS.name);
+	const refreshedAt = Date.parse(input.refreshedAt);
+	if (!Number.isFinite(refreshedAt)) invalid("Use a valid refresh timestamp.");
+	const db = storeDatabase(options);
+	const row = requireSetRow(db, projectId, idOrName);
+	const now = (options.now ?? (() => /* @__PURE__ */ new Date()))().getTime();
+	db.prepare("UPDATE keyword_sets SET last_refreshed_at = ?, updated_at = ? WHERE id = ?").run(refreshedAt, now, row.id);
+	return rowToSet(requireSetRow(db, projectId, row.id));
+}
+//#endregion
+//#region packages/core/src/keyword-sets/store.ts
+function createKeywordSet(input, options = {}) {
+	const projectId = boundedText(input.projectId, "Project id", KEYWORD_SET_FIELD_LIMITS.projectId);
+	const name = boundedText(input.name, "Keyword set name", KEYWORD_SET_FIELD_LIMITS.name);
+	const market = searchMarketSchema.safeParse(input.market);
+	if (!market.success) invalid("Use a valid search market.");
+	const provider = input.provider === void 0 ? void 0 : providerIdSchema.safeParse(input.provider);
+	if (provider && !provider.success) invalid("Use a supported keyword provider.");
+	const sourceReport = input.sourceReport ? boundedText(input.sourceReport, "Source report", KEYWORD_SET_FIELD_LIMITS.sourceReport) : null;
+	const db = storeDatabase(options);
+	if (rowCount(db, "SELECT COUNT(*) AS count FROM keyword_sets") >= KEYWORD_SET_LIMITS.totalSets) invalid(`At most ${KEYWORD_SET_LIMITS.totalSets} keyword sets can be saved.`);
+	if (rowCount(db, "SELECT COUNT(*) AS count FROM keyword_sets WHERE project_id = ?", projectId) >= KEYWORD_SET_LIMITS.setsPerProject) invalid(`A project can have at most ${KEYWORD_SET_LIMITS.setsPerProject} keyword sets.`);
+	const now = (options.now ?? (() => /* @__PURE__ */ new Date()))().getTime();
+	const id = (options.id ?? randomUUID)();
+	try {
+		db.transaction(() => {
+			db.prepare(`INSERT INTO keyword_sets
+         (id, project_id, name, market_json, provider, source_report, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(id, projectId, name, JSON.stringify(market.data), provider?.data ?? null, sourceReport, now, now);
+			enforceKeywordSetLogicalBytes(db, options.maxLogicalBytes);
+		}).immediate();
+	} catch (error) {
+		if (/unique constraint/i.test(String(error))) invalid(`A keyword set named ${name} already exists for this project.`);
+		throw error;
+	}
+	return rowToSet(requireSetRow(db, projectId, id));
+}
+function listKeywordSets(input, options = {}) {
+	const projectId = boundedText(input.projectId, "Project id", KEYWORD_SET_FIELD_LIMITS.projectId);
+	const limit = input.limit ?? 100;
+	const offset = input.offset ?? 0;
+	if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100) invalid("Keyword set list limit must be from 1 to 100.");
+	if (!Number.isSafeInteger(offset) || offset < 0) invalid("Keyword set list offset must be zero or greater.");
+	return storeDatabase(options).prepare(`${SET_SELECT}
+         WHERE sets.project_id = ?
+         ORDER BY sets.updated_at DESC, sets.id
+         LIMIT ? OFFSET ?`).all(projectId, limit, offset).map(rowToSet);
+}
+function getKeywordSet(input, options = {}) {
+	const projectId = boundedText(input.projectId, "Project id", KEYWORD_SET_FIELD_LIMITS.projectId);
+	const idOrName = boundedText(input.idOrName, "Keyword set id or name", KEYWORD_SET_FIELD_LIMITS.name);
+	const tag = input.tag ? boundedText(input.tag, "Tag", KEYWORD_SET_FIELD_LIMITS.tag).toLowerCase() : null;
+	const limit = input.limit ?? 100;
+	const offset = input.offset ?? 0;
+	if (!Number.isSafeInteger(limit) || limit < 1 || limit > KEYWORD_SET_LIMITS.outputRows) invalid(`Keyword set output limit must be from 1 to ${KEYWORD_SET_LIMITS.outputRows}.`);
+	if (!Number.isSafeInteger(offset) || offset < 0) invalid("Keyword set output offset must be zero or greater.");
+	const db = storeDatabase(options);
+	const setRow = requireSetRow(db, projectId, idOrName);
+	const filterSql = tag ? `AND EXISTS (
+        SELECT 1 FROM keyword_set_tags filter_tags
+        WHERE filter_tags.set_id = items.set_id
+          AND filter_tags.normalized_keyword = items.normalized_keyword
+          AND filter_tags.tag = ?
+      )` : "";
+	const params = tag ? [setRow.id, tag] : [setRow.id];
+	const total = rowCount(db, `SELECT COUNT(*) AS count FROM keyword_set_items items
+     WHERE items.set_id = ? ${filterSql}`, ...params);
+	const rows = db.prepare(`SELECT items.* FROM keyword_set_items items
+       WHERE items.set_id = ? ${filterSql}
+       ORDER BY items.normalized_keyword
+       LIMIT ? OFFSET ?`).all(...params, limit, offset);
+	const tagsByKeyword = loadTags(db, setRow.id, rows);
+	const items = rows.map((row) => itemFromRow(row, tagsByKeyword.get(row.normalized_keyword) ?? []));
+	return {
+		schemaVersion: 1,
+		set: rowToSet(setRow),
+		items,
+		pagination: {
+			offset,
+			limit,
+			returned: items.length,
+			total,
+			nextOffset: offset + items.length < total ? offset + items.length : null
+		},
+		filter: { tag }
+	};
+}
+function loadTags(db, setId, rows) {
+	if (rows.length === 0) return /* @__PURE__ */ new Map();
+	const tagRows = db.prepare(`SELECT normalized_keyword, tag FROM keyword_set_tags
+       WHERE set_id = ? AND normalized_keyword IN (${rows.map(() => "?").join(", ")})
+       ORDER BY normalized_keyword, tag`).all(setId, ...rows.map((row) => row.normalized_keyword));
+	const tagsByKeyword = /* @__PURE__ */ new Map();
+	for (const row of tagRows) {
+		const tags = tagsByKeyword.get(row.normalized_keyword) ?? [];
+		tags.push(row.tag);
+		tagsByKeyword.set(row.normalized_keyword, tags);
+	}
+	return tagsByKeyword;
+}
+function itemFromRow(row, tags) {
+	const latestMetric = row.metric_json ? parseStoredJson(row.metric_json, savedMetricSchema, "Saved keyword metric") : null;
+	if (latestMetric && (latestMetric.provider !== row.metric_provider || latestMetric.observedAt !== row.metric_observed_at || normalizeSavedKeyword(latestMetric.metric.keyword) !== row.normalized_keyword)) throw new SeoError("INTERNAL_ERROR", "Saved keyword metric metadata is inconsistent.");
+	const page = row.page_kind && row.page_url ? {
+		kind: row.page_kind,
+		url: row.page_url
+	} : null;
+	return {
+		keyword: row.display_keyword,
+		normalizedKeyword: row.normalized_keyword,
+		tags,
+		page,
+		latestMetric,
+		createdAt: new Date(row.created_at).toISOString(),
+		updatedAt: new Date(row.updated_at).toISOString()
+	};
+}
+function deleteKeywordSet(input, options = {}) {
+	const projectId = boundedText(input.projectId, "Project id", KEYWORD_SET_FIELD_LIMITS.projectId);
+	const idOrName = boundedText(input.idOrName, "Keyword set id or name", KEYWORD_SET_FIELD_LIMITS.name);
+	const db = storeDatabase(options);
+	const row = findSetRow(db, projectId, idOrName);
+	if (!row) return false;
+	return db.prepare("DELETE FROM keyword_sets WHERE id = ?").run(row.id).changes > 0;
+}
+//#endregion
+//#region packages/core/src/keyword-sets/refresh.ts
+const REFRESH_BATCH_SIZE = 50;
+function estimator(adapter) {
+	return "estimateKeywordMetricsCost" in adapter && typeof adapter.estimateKeywordMetricsCost === "function" ? adapter : null;
+}
+async function defaultCandidates() {
+	return [{
+		adapter: new DataForSeoKeywordMetricsProvider(),
+		connected: Boolean(await readDataForSeoCredentials()),
+		priority: 10
+	}];
+}
+function providerError(error) {
+	if (!(error instanceof ProviderError)) throw error;
+	throw new SeoError(error.code === "rate-limit" ? "RATE_LIMITED" : "PROVIDER_UNAVAILABLE", error.message);
+}
+function summedCost(values) {
+	return values.length > 0 && values.every((value) => value !== null) ? values.reduce((sum, value) => sum + (value ?? 0), 0) : null;
+}
+async function refreshKeywordSet(input, dependencies = {}) {
+	const limit = input.limit ?? KEYWORD_SET_LIMITS.outputRows;
+	if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1e3) throw new SeoError("INVALID_INPUT", "Refresh limit must be from 1 to 1000.");
+	if (input.provider && !providerIdSchema.safeParse(input.provider).success) throw new SeoError("INVALID_INPUT", "Use a supported keyword provider.");
+	const offset = input.offset ?? 0;
+	if (!Number.isSafeInteger(offset) || offset < 0 || offset > 1e5) throw new SeoError("INVALID_INPUT", "Refresh offset must be from 0 to 100000.");
+	const detail = getKeywordSet({
+		projectId: input.projectId,
+		idOrName: input.idOrName,
+		limit,
+		offset
+	}, dependencies.store);
+	if (detail.items.length === 0) throw new SeoError("INSUFFICIENT_DATA", detail.set.keywordCount === 0 ? "The keyword set is empty." : "No keywords exist in the selected refresh window.");
+	let candidates;
+	try {
+		candidates = dependencies.candidates ?? await defaultCandidates();
+	} catch (error) {
+		return providerError(error);
+	}
+	const resolution = resolveProvider({
+		capability: "keyword-metrics",
+		market: detail.set.market,
+		candidates,
+		provider: input.provider ?? detail.set.provider ?? void 0
+	});
+	if (resolution.status === "unavailable") {
+		const selectedProvider = input.provider ?? detail.set.provider ?? void 0;
+		throw new SeoError(resolution.reason === "market-not-supported" && selectedProvider ? "INVALID_INPUT" : "PROVIDER_UNAVAILABLE", resolution.reason === "provider-not-connected" ? "No connected provider can refresh this keyword set." : resolution.reason === "market-not-supported" && selectedProvider === "dataforseo" ? "DataForSEO keyword estimates require a country-level saved set. Create the set without --location, then use a location-specific serp-results report for local result evidence." : "No configured provider can estimate and refresh this keyword set.");
+	}
+	const costEstimator = estimator(resolution.provider);
+	if (!costEstimator) throw new SeoError("PROVIDER_UNAVAILABLE", `${resolution.provider.provider} cannot preview keyword metric costs.`);
+	let cost;
+	try {
+		cost = await costEstimator.estimateKeywordMetricsCost({
+			requestedRows: detail.items.length,
+			market: detail.set.market
+		});
+	} catch (error) {
+		return providerError(error);
+	}
+	if (cost.estimatedMicros === null) throw new SeoError("PROVIDER_UNAVAILABLE", "The provider did not return a usable cost estimate, so no paid refresh was started.");
+	const now = dependencies.now ?? (() => /* @__PURE__ */ new Date());
+	const generatedAt = now().toISOString();
+	const completeSelection = detail.pagination.offset === 0 && detail.items.length === detail.set.keywordCount;
+	const common = {
+		schemaVersion: 1,
+		generatedAt,
+		set: {
+			id: detail.set.id,
+			name: detail.set.name,
+			projectId: detail.set.projectId,
+			totalKeywords: detail.set.keywordCount
+		},
+		selection: {
+			offset: detail.pagination.offset,
+			limit: detail.pagination.limit,
+			selectedKeywords: detail.items.length,
+			nextOffset: detail.pagination.nextOffset,
+			completeness: completeSelection ? "complete" : "capped"
+		},
+		cost
+	};
+	if (!input.execute) return {
+		...common,
+		mode: "preview",
+		dataStatus: completeSelection ? "complete" : "partial",
+		execution: null,
+		caveats: ["This preview used current provider account pricing and did not start a paid keyword request.", ...completeSelection ? [] : ["The refresh limit covers only part of the saved keyword set."]],
+		nextSteps: ["Review the selected market, keyword count, request count, and estimate before executing the refresh."]
+	};
+	const batches = Array.from({ length: Math.ceil(detail.items.length / REFRESH_BATCH_SIZE) }, (_, index) => detail.items.slice(index * REFRESH_BATCH_SIZE, (index + 1) * REFRESH_BATCH_SIZE));
+	const warnings = [];
+	const errors = [];
+	const actualCosts = [];
+	let savedSnapshots = 0;
+	let completeBatches = 0;
+	let partialBatches = 0;
+	const reportRunId = randomUUID();
+	for (const [index, batch] of batches.entries()) try {
+		const report = await (dependencies.keywordMetrics ?? keywordMetricsReport)({
+			keywords: batch.map((item) => item.keyword),
+			market: detail.set.market,
+			provider: resolution.provider.provider,
+			projectId: detail.set.projectId,
+			refresh: true,
+			context: {
+				reportId: "saved-keyword-refresh",
+				reportRunId
+			}
+		}, {
+			candidates,
+			now
+		});
+		const metrics = new Map(report.evidence.data.map((metric) => [normalizeSavedKeyword(metric.keyword), metric]));
+		const saved = batch.flatMap((item) => {
+			const metric = metrics.get(item.normalizedKeyword);
+			return metric ? [savedMetricItem(metric, report.evidence.provider, report.evidence.observedAt)] : [];
+		});
+		if (saved.length > 0) addKeywordsToSet({
+			projectId: detail.set.projectId,
+			idOrName: detail.set.id,
+			items: saved
+		}, dependencies.store);
+		savedSnapshots += saved.length;
+		actualCosts.push(report.evidence.cost.actualMicros);
+		if (report.dataStatus !== "complete" || report.evidence.coverage.completeness !== "complete" || saved.length !== batch.length) {
+			partialBatches += 1;
+			warnings.push({
+				batch: index + 1,
+				message: saved.length !== batch.length ? `Batch retained ${saved.length} typed snapshots for ${batch.length} keywords.` : `Batch returned ${report.evidence.coverage.completeness} provider coverage for ${batch.length} keywords.`
+			});
+			continue;
+		}
+		completeBatches += 1;
+	} catch (error) {
+		errors.push({
+			batch: index + 1,
+			message: error instanceof Error ? error.message : String(error)
+		});
+		break;
+	}
+	if (errors.length === 0 && partialBatches === 0 && completeSelection) setKeywordSetRefreshTime({
+		projectId: detail.set.projectId,
+		idOrName: detail.set.id,
+		refreshedAt: generatedAt
+	}, dependencies.store);
+	const complete = errors.length === 0 && partialBatches === 0 && completeSelection;
+	return {
+		...common,
+		mode: "executed",
+		dataStatus: complete ? "complete" : savedSnapshots > 0 ? "partial" : "unavailable",
+		execution: {
+			attemptedBatches: completeBatches + partialBatches + errors.length,
+			completeBatches,
+			partialBatches,
+			failedBatches: errors.length,
+			savedSnapshots,
+			actualMicros: summedCost(actualCosts),
+			warnings,
+			errors
+		},
+		caveats: [
+			"Saved metrics are provider estimates for the set market, not first-party rankings or traffic forecasts.",
+			...completeSelection ? [] : ["The refresh limit covered only part of the saved keyword set."],
+			...errors.length ? ["Completed batches were retained; the failed batch and later batches remain stale."] : [],
+			...partialBatches > 0 ? ["Partial provider batches were retained with explicit missing or invalid states; the set was not marked fully refreshed."] : []
+		],
+		nextSteps: [complete ? "Compare changed demand and competition evidence with Search Console before changing priorities." : "Resolve the incomplete coverage before treating the set as fully refreshed."]
+	};
+}
+function savedMetricItem(metric, provider, observedAt) {
+	return {
+		keyword: metric.keyword,
+		latestMetric: {
+			schemaVersion: 1,
+			provider,
+			observedAt,
+			metric
+		}
+	};
+}
+//#endregion
+//#region packages/core/src/analyze/saved-keywords.ts
+const DEFAULT_STALE_DAYS = 45;
+function savedKeywordSetReport(input, dependencies = {}) {
+	const staleDays = input.staleDays ?? DEFAULT_STALE_DAYS;
+	if (!Number.isSafeInteger(staleDays) || staleDays < 1 || staleDays > 365) throw new SeoError("INVALID_INPUT", "Metric freshness must be from 1 to 365 days.");
+	const now = (dependencies.now ?? (() => /* @__PURE__ */ new Date()))();
+	const evidence = (dependencies.getKeywordSet ?? getKeywordSet)(input);
+	const snapshots = evidence.items.filter((item) => item.latestMetric);
+	const observedVolumes = snapshots.filter((item) => item.latestMetric?.metric.monthlySearchVolume.state === "observed");
+	const staleCutoff = now.getTime() - staleDays * 864e5;
+	const staleSnapshots = snapshots.filter((item) => Date.parse(item.latestMetric?.observedAt ?? "") < staleCutoff);
+	const mapped = evidence.items.filter((item) => item.page);
+	const tagGroups = groupedCounts(evidence.items.flatMap((item) => item.tags)).map(([tag, keywordCount]) => ({
+		tag,
+		keywordCount
+	}));
+	const pageMappings = groupedMappings(evidence);
+	const missingMetrics = evidence.items.length - snapshots.length;
+	const unavailableVolumeSnapshots = snapshots.length - observedVolumes.length;
+	const unmapped = evidence.items.length - mapped.length;
+	const partial = evidence.pagination.nextOffset !== null || evidence.pagination.offset > 0 || evidence.pagination.total !== evidence.set.keywordCount;
+	const dataStatus = evidence.items.length === 0 ? "unavailable" : partial ? "partial" : "complete";
+	return {
+		schemaVersion: 1,
+		generatedAt: now.toISOString(),
+		dataStatus,
+		summary: {
+			name: evidence.set.name,
+			totalKeywords: evidence.set.keywordCount,
+			matchedKeywords: evidence.pagination.total,
+			returnedKeywords: evidence.items.length,
+			metricSnapshots: snapshots.length,
+			observedVolumes: observedVolumes.length,
+			observedZeroVolumes: observedVolumes.filter((item) => item.latestMetric?.metric.monthlySearchVolume.value === 0).length,
+			unavailableVolumeSnapshots,
+			staleMetricSnapshots: staleSnapshots.length,
+			mappedKeywords: mapped.length,
+			targetPages: pageMappings.filter((item) => item.kind === "target").length,
+			proposedPages: pageMappings.filter((item) => item.kind === "proposed").length,
+			distinctTags: tagGroups.length,
+			verdict: `${evidence.items.length} saved keywords were returned; search volume is observed for ${observedVolumes.length}, unavailable in ${unavailableVolumeSnapshots} saved snapshot${unavailableVolumeSnapshots === 1 ? "" : "s"}, and ${mapped.length} have page mappings.`
+		},
+		evidence,
+		analysis: {
+			metricFreshnessDays: staleDays,
+			tagGroups,
+			pageMappings
+		},
+		findings: [
+			...missingMetrics > 0 ? [{
+				code: "missing-metrics",
+				evidenceRef: "evidence.items[*].latestMetric",
+				detail: `${missingMetrics} returned keywords have no saved provider metric snapshot.`,
+				action: "Preview a keyword-set refresh before using provider metrics to prioritize them."
+			}] : [],
+			...unavailableVolumeSnapshots > 0 ? [{
+				code: "unavailable-volume-evidence",
+				evidenceRef: "evidence.items[*].latestMetric.metric.monthlySearchVolume",
+				detail: `${unavailableVolumeSnapshots} saved metric snapshot${unavailableVolumeSnapshots === 1 ? "" : "s"} ${unavailableVolumeSnapshots === 1 ? "has" : "have"} no observed search volume. This is not an observed zero.`,
+				action: "Keep these terms separate from observed-zero terms and verify them with another source or a later refresh before using demand as a filter."
+			}] : [],
+			...staleSnapshots.length > 0 ? [{
+				code: "stale-metrics",
+				evidenceRef: "evidence.items[*].latestMetric.observedAt",
+				detail: `${staleSnapshots.length} saved metric snapshots are older than ${staleDays} days.`,
+				action: "Preview and selectively refresh the stale provider evidence."
+			}] : [],
+			...unmapped > 0 ? [{
+				code: "unmapped-keywords",
+				evidenceRef: "evidence.items[*].page",
+				detail: `${unmapped} returned keywords have no existing or proposed page mapping.`,
+				action: "Review shared intent and current results before mapping terms to an existing page or a proposed page."
+			}] : []
+		],
+		caveats: [
+			"Tags are user-managed research labels, not proof that keywords share one intent or should use one page.",
+			"Provider metrics are market estimates; missing evidence differs from an observed zero.",
+			"Page mappings record planning state and do not prove that a page ranks, is indexed, or should be created.",
+			...partial ? ["This view is filtered or paginated and cannot support a complete-set all-clear."] : []
+		],
+		nextSteps: [
+			"Compare relevant saved terms with Search Console evidence for the project before changing priorities.",
+			"Inspect current results in the same market before turning a tag group into a page or programmatic template.",
+			"Use the refresh preview to check provider cost before updating saved metric snapshots."
+		]
+	};
+}
+function groupedCounts(values) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const value of values) counts.set(value, (counts.get(value) ?? 0) + 1);
+	return [...counts].sort(([left, leftCount], [right, rightCount]) => rightCount - leftCount || (left < right ? -1 : left > right ? 1 : 0)).slice(0, 50);
+}
+function groupedMappings(evidence) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const item of evidence.items) {
+		if (!item.page) continue;
+		const key = `${item.page.kind}\u0000${item.page.url}`;
+		const current = counts.get(key);
+		counts.set(key, {
+			...item.page,
+			count: (current?.count ?? 0) + 1
+		});
+	}
+	return [...counts.values()].sort((left, right) => right.count - left.count || (left.url < right.url ? -1 : left.url > right.url ? 1 : 0)).slice(0, 50).map(({ count, ...mapping }) => ({
+		...mapping,
+		keywordCount: count
+	}));
+}
+//#endregion
 //#region packages/core/src/analyze/second-page.ts
 const MAX_SOURCE_ROWS = 1e5;
 const defaultDependencies = {
@@ -37546,6 +38373,7 @@ const TELEMETRY_REPORTS = [
 	"keyword-metrics",
 	"keyword-opportunities",
 	"keyword-research",
+	"saved-keywords",
 	"link-evidence",
 	"server-log-analysis",
 	"link-recovery",
@@ -37891,6 +38719,6 @@ function isoDate(daysAgo = 0) {
 	return date.toISOString().slice(0, 10);
 }
 //#endregion
-export { AI_REFERRAL_SOURCES, AI_REFERRAL_SOURCES_VERSION, AI_SEARCH_SCORECARD_METHODOLOGY_ID, AI_SEARCH_SCORECARD_METHODOLOGY_VERSION, AUDIT_PAGE_RULE_IDS, AUTOMATIC_BASELINE_SITE_RETENTION, AUTOMATIC_BASELINE_TOTAL_RETENTION, BING_API_KEY_ENV, BING_API_KEY_SECRET, BROWSER_USER_AGENT, BingWebmasterClient, CANNIBAL_MAXIMUM_DOMINANT_SHARE, CANNIBAL_MINIMUM_PAGE_SHARE, CRAWL_REPORT_STORAGE_VERSION, CRAWL_RUN_RETENTION, CRAWL_SKIP_REASONS, CTR_DEFAULT_LIMIT, CTR_DEFAULT_MIN_IMPRESSIONS, CTR_MAX_LIMIT, CTR_MAX_MIN_IMPRESSIONS, DATAFORSEO_CREDENTIAL_SECRET, DATAFORSEO_LOGIN_ENV, DATAFORSEO_PASSWORD_ENV, DEFAULT_PROVIDER_SPEND_LIMITS, DataForSeoClient, DataForSeoKeywordDiscoveryProvider, DataForSeoKeywordMetricsProvider, DataForSeoProvider, DataForSeoSerpSnapshotProvider, GSC_FINAL_DATA_LAG_DAYS, GSC_TIME_ZONE, INDEXNOW_ENDPOINT, INDEXNOW_KEYS_SECRET, INDEXNOW_KEY_ENV, INDEXNOW_MAX_URLS, INDEX_WATCH_ATTEMPT_RETENTION, INTERNAL_LINK_LEXICAL_TARGET_LIMIT, INTERNAL_LINK_MATCH_EVIDENCE_LIMIT, JsonFileStorageAdapter, LINK_RECOVER_RUN_RETENTION, LOG_MAX_AGE_MS, LOG_MAX_FILE_BYTES, LOG_MAX_TOTAL_BYTES, LocalCredentialsProvider, MAX_CRAWL_CONCURRENCY, MAX_CRAWL_DEPTH, MAX_CRAWL_PAGES, MAX_CRAWL_TIMEOUT_MS, OKF_DEFAULT_CONCEPTS, OKF_MAX_CONCEPTS, PROVIDER_SPEND_MAX_BYTES, PROVIDER_SPEND_MAX_ROWS, PROVIDER_SPEND_RETENTION_DAYS, ProviderError, REPORT_BASELINE_MAX_AGE_MS, REPORT_BASELINE_MAX_DEPTH, REPORT_BASELINE_MAX_PAGES, ResponseSizeLimitError, SCORECARD_CHECK_WEIGHTS, SCORECARD_STATUS_CREDIT, SEO_CRAWLER_IDENTITY, SEO_CRAWLER_TOKEN, SEO_CRAWLER_USER_AGENT, SEO_VERSION, SERP_TITLE_REFERENCE_WIDTH_PX, SERP_TITLE_WIDTH_PROFILE, SemrushProvider, SeoError, ServiceAccountAccessTokenClient, SessionLedger, TELEMETRY_AGENTS, TELEMETRY_ENDPOINT, TELEMETRY_ERROR_CATEGORIES, TELEMETRY_EVENTS, TELEMETRY_NOTICE, TELEMETRY_REPORTS, TELEMETRY_SCHEMA_VERSION, TELEMETRY_TIMEOUT_MS, acquirePseoAuditEvidence, addStatus, affectedUrls, agentReadiness, aiPromptsForQuery, aiReadiness, aiReferralSourceForValue, aiReferralsReport, aiSearchScorecard, allocateIndexUrlsToProperties, analyticsConnectionsSchema, analyzeAiReferralRows, analyzeBingCrawl, analyzeBingDimensions, analyzeBingTraffic, analyzeCannibalRows, analyzeCtrUnderperformersFromRows, analyzeDecay, analyzeIndexCoverageSignals, analyzeInternalLinksFromRows, analyzeKeywordTrend, analyzePageOpportunitiesFromRows, analyzeQueryClustersFromRows, analyzeQuickWinsFromRows, analyzeSecondPageRows, analyzeSegmentRows, analyzeStrikingDistanceRows, analyzeTrafficAnomalyRows, assertCrawlConfigLimits, assertUrlMatchesGscProperty, attachCrawlRecommendations, auditCrawlPages, auditCrawlRequests, auditLlmsTxt, auditPage, authStatus, bingAnalysisDefaults, bingWebmasterOverview, bingWebmasterSiteUrl, boundedSitemapInventory, buildOkfBundle, buildPseoAuditFromAcquisition, buildPseoAuditReportFromRows, buildQueryClusterReportFromRows, buildTelemetryPayload, cannibalReport, changeMeasurementCsvRows, checkDatabaseReadiness, classifyCommunityIntent, classifyCrawler, clearCache, clientProfileSchema, clusterPseoTemplates, clusterQueryRows, collectAgentDiscovery, collectBingLinkEvidence, combineRobotsValues, communityIntentReport, compareCrawlPages, compareCrawlReports, compareLinkEvidence, compareSegmentRows, configSchema, contentCoverageRecommendation, contentCoverageType, contentOptimizationFromPageOpportunities, contentOptimizationReport, countLabel, crawlConfigHash, crawlConfigSchema, crawlDefinitionId, crawlDiff, crawlFixToQueueItem, crawlImplementationQueueWorkflow, crawlIssueGroupSchema, crawlIssueSchema, crawlOne, crawlPageSnapshotSchema, crawlReportSchema, crawlReportStore, crawlReportSummarySchema, crawlRequestObservationSchema, crawlRunId, crawlSite, crawlSkipImpact, crawlSkipReasonCountsFromRecord, crawlStatusOnly, crawlTopFixSchema, crawlerJsonSchemas, crawlerRuleCategorySchema, crawlerRuleIdSchema, crawlerRuleInfoSchema, crawlerRuleRecommendationSchema, crawlerRuleSeveritySchema, crawlerSchemas, createAuthorizedClient, createBingWebmasterClient, createContentGroup, createCrawlReport, createCtrBenchmarkContext, createGoogleAccessTokenClient, createIndexNowKey, createIndexNowKeyRecord, createLogger, createPageRenderer, ctrUnderperformersReport, decayClusterDrafts, decayComparisonRange, decayingReport, deleteChange, deleteClient, deleteContentGroup, deleteCrawlReport, deleteDataForSeoCredentials, deleteProviderSecret, deleteTokens, deriveBrandTerms, detectBrandTerms, detectTelemetryAgent, diagnoseCsvFiles, diagnoseProperty, diagnosePropertyWorkflow, effectiveRobotsDirectives, effectiveSnippetControl, emptyStatusBreakdown, ensurePrivateDatabaseFiles, ensureSeoCliDirs, entityReadiness, estimateSerpTitleWidth, expectedCtrForPosition, explainOkfValidation, explainRule, fetchCruxFieldData, fetchPage, fetchPageStatus, fetchSearchStatusIncidents, fetchSitemapUrls, fetchText, fileSize, finalGscDateRange, finalizeProviderSpend, findOverlappingSearchUpdates, formatRelativeExpiry, ga4MatchReason, ga4PropertyIdFromName, ga4ReportQualityWarnings, ga4RequestCanUseCache, ga4RowsToObjects, generateLlmsTxt, geoGaps, geoGapsReport, getAuthModeStatus, getCacheStats, getChange, getClient, getClientConfig, getContentGroup, getDb, getKeywordProvider, getPreviousRun, getPrivacySnapshot, getProviderSpendLimits, getProviderSpendSummary, getRepeatedLinkRecoverUrls, getRunPages, getSeoCliPaths, getServiceAccountConfig, getServiceAccountStatus, getTelemetryStatus, getTokenStorageStatus, googleAnalyticsPropertyId, groupCrawlIssues, hasMetaRobotsDirective, hasRule, hasXRobotsDirective, hashKey, importLinkEvidence, importServerLog, indexCoveragePlan, indexCoverageSignals, indexMonitor, indexWatch, inferPseoTemplate, inferTemplateMovement, initializeTelemetry, insertCrawlRun, insertLinkRecoverRun, inspectUrl, internalLinksReport, interpretUpdateCorrelation, isBrandQuery, isCompatibleTechnicalBaseline, isCurrentTechnicalBaseline, isEntityEvidenceSchemaType, isSiteIdentitySchemaType, isSkippableReportError, isTelemetryCi, isTelemetryReport, isoDate, isoWeek, keywordDiscoverySourceSchema, keywordMetricsReport, keywordOpportunitiesReport, keywordResearchReport, latestCrawlReport, latestCrawlSummaries, latestFinalGscDate, latestIndexWatchSummary, latestLinkRecoverSummary, linkEntries, linkEvidenceKey, linkEvidenceReport, linkRecover, linkRecoverRecommendation, listChanges, listClients, listContentGroups, listCrawlReports, listGa4AccountSummaries, listGa4DataStreams, listIndexNowKeys, listRules, listSearchUpdates, listSites, loadCrawlReport, localCredentialsProvider, loginWithLoopback, makeRunId, matchGa4WebStreams, measureChange, measureCoverage, metaRobotsDirectives, migrateLegacyMacConfig, missingOAuthClientMessage, missingSharedClientLoginMessage, monitoringStatus, monthlyReport, monthlyReportWorkflow, narrativeCsvFiles, normalizeCrawlConfig, normalizeCrawlSkipReasonCounts, normalizeForCoverage, normalizeHttpUrl, normalizeJavaScriptRenderingMode, normalizeLinkEvidenceRow, normalizeLoadedCrawlReport, noteCacheWrite, observedValue, okfConceptLimit, pageEvidenceRecommendation, pageOpportunitiesReport, parseCombinedLogLine, parseIndexNowSite, parseJsonLogLine, parseOlderThan, parsePseoPath, performanceAudit, performanceReportIsCacheable, planDueIndexUrls, planIndexCoverageFromUrls, plural, propertyMatchesUrl, providerCapabilitySchema, providerIdSchema, providerPreferenceSchema, providerRequestJson, providerRequestText, providerSpendLimitOverridesSchema, pruneIndexWatchSnapshots, pruneLogs, pseoAuditOptions, pseoAuditReport, pseoCsvFiles, pseoIndexStatus, pseoOpportunitiesReport, pseoPresentation, publicHttpFetch, queryClusterReport, queryClusterTokens, queryContentCoverageFromPage, queryContentFieldsFromPage, queryFieldCoverage, queryOpportunityRecommendation, queryPageMetrics, queryPageTopQuery, queryPagesMetrics, queryPagesMetricsBatch, queryPagesTopQueries, queryPagesTopQueriesBatch, querySearchAnalytics, quickWinsCsvRows, quickWinsReport, readBoundedResponseText, readConfig, readDataForSeoCredentials, readOauthClient, readProviderSecret, readTokens, recommendCrawlDiffItem, recommendationForRule, recordChange, redirectTrace, refreshAuthToken, refreshPrioritiesCsvFiles, refreshPrioritiesWorkflow, removeIndexNowKey, renderCrawlCsv, renderCrawlHtml, renderCrawlJunit, renderCrawlMarkdownTickets, renderCrawlPagesCsv, renderCrawlPretty, renderCsv, renderPresentationTablesMarkdown, renderPseoMarkdown, renderReportHtml, renderWorkflowMarkdown, reportNarrative, reportPresentation, requestHeaders, reserveProviderSpend, resolveIndexNowKey, resolveProvider, resolveSegmentRanges, resolveSeoCliPaths, resolveTechnicalBaseline, reviewObservations, roundedPosition, runDoctor, runGa4Report, safeError, saveClient, saveCrawlReport, saveIndexNowKey, searchMarketSchema, secondPage, segmentComparisonRange, segmentImpact, segmentRangeDays, selectAffectedUrls, selectDueIndexUrls, seoErrorEnvelope, seoToAiQueryReport, serpResultsReport, serverLogReport, sessionSourceInListFilter, setClientBingSite, setDefaultClient, setProviderSpendLimits, setTelemetryEnabled, setTokenStorageMode, shiftIsoDate, shouldExcludeBrandQuery, siteSchema, sqliteCrawlReportStore, strikingDistance, submitIndexNow, summarizeCrawlReport, pageTechnicalSignals as technicalPageSignals, technicalWatchWorkflow, telemetryErrorCategory, templateForUrl, toSeoError, tokenSchema, topCrawlRecommendations, topFixes, trackTelemetryReportComplete, trackTelemetryReportFailed, trackTelemetryReportStart, trackTelemetrySetupComplete, trafficAnomaly, unavailableSegmentImpactReport, unavailableValue, unicodeTokens, updateCorrelation, updatePostmortemCsvFiles, updatePostmortemWorkflow, validateIndexNowKey, validateIndexNowKeyRecord, validateOkfFiles, verifyIndexNowKey, verifyQueryContent, workflowPresentation, writeConfig, writeDataForSeoCredentials, writeOauthClient, writeProviderSecret, writeTokens, xRobotsDirectives };
+export { AI_REFERRAL_SOURCES, AI_REFERRAL_SOURCES_VERSION, AI_SEARCH_SCORECARD_METHODOLOGY_ID, AI_SEARCH_SCORECARD_METHODOLOGY_VERSION, AUDIT_PAGE_RULE_IDS, AUTOMATIC_BASELINE_SITE_RETENTION, AUTOMATIC_BASELINE_TOTAL_RETENTION, BING_API_KEY_ENV, BING_API_KEY_SECRET, BROWSER_USER_AGENT, BingWebmasterClient, CANNIBAL_MAXIMUM_DOMINANT_SHARE, CANNIBAL_MINIMUM_PAGE_SHARE, CRAWL_REPORT_STORAGE_VERSION, CRAWL_RUN_RETENTION, CRAWL_SKIP_REASONS, CTR_DEFAULT_LIMIT, CTR_DEFAULT_MIN_IMPRESSIONS, CTR_MAX_LIMIT, CTR_MAX_MIN_IMPRESSIONS, DATAFORSEO_CREDENTIAL_SECRET, DATAFORSEO_LOGIN_ENV, DATAFORSEO_PASSWORD_ENV, DEFAULT_PROVIDER_SPEND_LIMITS, DataForSeoClient, DataForSeoKeywordDiscoveryProvider, DataForSeoKeywordMetricsProvider, DataForSeoProvider, DataForSeoSerpSnapshotProvider, GSC_FINAL_DATA_LAG_DAYS, GSC_TIME_ZONE, INDEXNOW_ENDPOINT, INDEXNOW_KEYS_SECRET, INDEXNOW_KEY_ENV, INDEXNOW_MAX_URLS, INDEX_WATCH_ATTEMPT_RETENTION, INTERNAL_LINK_LEXICAL_TARGET_LIMIT, INTERNAL_LINK_MATCH_EVIDENCE_LIMIT, JsonFileStorageAdapter, KEYWORD_SET_FIELD_LIMITS, KEYWORD_SET_LIMITS, KEYWORD_SET_SCHEMA_SQL, LINK_RECOVER_RUN_RETENTION, LOG_MAX_AGE_MS, LOG_MAX_FILE_BYTES, LOG_MAX_TOTAL_BYTES, LocalCredentialsProvider, MAX_CRAWL_CONCURRENCY, MAX_CRAWL_DEPTH, MAX_CRAWL_PAGES, MAX_CRAWL_TIMEOUT_MS, OKF_DEFAULT_CONCEPTS, OKF_MAX_CONCEPTS, PROVIDER_SPEND_MAX_BYTES, PROVIDER_SPEND_MAX_ROWS, PROVIDER_SPEND_RETENTION_DAYS, ProviderError, REPORT_BASELINE_MAX_AGE_MS, REPORT_BASELINE_MAX_DEPTH, REPORT_BASELINE_MAX_PAGES, ResponseSizeLimitError, SCORECARD_CHECK_WEIGHTS, SCORECARD_STATUS_CREDIT, SEO_CRAWLER_IDENTITY, SEO_CRAWLER_TOKEN, SEO_CRAWLER_USER_AGENT, SEO_VERSION, SERP_TITLE_REFERENCE_WIDTH_PX, SERP_TITLE_WIDTH_PROFILE, SemrushProvider, SeoError, ServiceAccountAccessTokenClient, SessionLedger, TELEMETRY_AGENTS, TELEMETRY_ENDPOINT, TELEMETRY_ERROR_CATEGORIES, TELEMETRY_EVENTS, TELEMETRY_NOTICE, TELEMETRY_REPORTS, TELEMETRY_SCHEMA_VERSION, TELEMETRY_TIMEOUT_MS, acquirePseoAuditEvidence, addKeywordsToSet, addStatus, affectedUrls, agentReadiness, aiPromptsForQuery, aiReadiness, aiReferralSourceForValue, aiReferralsReport, aiSearchScorecard, allocateIndexUrlsToProperties, analyticsConnectionsSchema, analyzeAiReferralRows, analyzeBingCrawl, analyzeBingDimensions, analyzeBingTraffic, analyzeCannibalRows, analyzeCtrUnderperformersFromRows, analyzeDecay, analyzeIndexCoverageSignals, analyzeInternalLinksFromRows, analyzeKeywordTrend, analyzePageOpportunitiesFromRows, analyzeQueryClustersFromRows, analyzeQuickWinsFromRows, analyzeSecondPageRows, analyzeSegmentRows, analyzeStrikingDistanceRows, analyzeTrafficAnomalyRows, assertCrawlConfigLimits, assertUrlMatchesGscProperty, attachCrawlRecommendations, auditCrawlPages, auditCrawlRequests, auditLlmsTxt, auditPage, authStatus, bingAnalysisDefaults, bingWebmasterOverview, bingWebmasterSiteUrl, boundedSitemapInventory, buildOkfBundle, buildPseoAuditFromAcquisition, buildPseoAuditReportFromRows, buildQueryClusterReportFromRows, buildTelemetryPayload, cannibalReport, changeMeasurementCsvRows, checkDatabaseReadiness, classifyCommunityIntent, classifyCrawler, clearCache, clientProfileSchema, clusterPseoTemplates, clusterQueryRows, collectAgentDiscovery, collectBingLinkEvidence, combineRobotsValues, communityIntentReport, compareCrawlPages, compareCrawlReports, compareLinkEvidence, compareSegmentRows, configSchema, contentCoverageRecommendation, contentCoverageType, contentOptimizationFromPageOpportunities, contentOptimizationReport, countLabel, crawlConfigHash, crawlConfigSchema, crawlDefinitionId, crawlDiff, crawlFixToQueueItem, crawlImplementationQueueWorkflow, crawlIssueGroupSchema, crawlIssueSchema, crawlOne, crawlPageSnapshotSchema, crawlReportSchema, crawlReportStore, crawlReportSummarySchema, crawlRequestObservationSchema, crawlRunId, crawlSite, crawlSkipImpact, crawlSkipReasonCountsFromRecord, crawlStatusOnly, crawlTopFixSchema, crawlerJsonSchemas, crawlerRuleCategorySchema, crawlerRuleIdSchema, crawlerRuleInfoSchema, crawlerRuleRecommendationSchema, crawlerRuleSeveritySchema, crawlerSchemas, createAuthorizedClient, createBingWebmasterClient, createContentGroup, createCrawlReport, createCtrBenchmarkContext, createGoogleAccessTokenClient, createIndexNowKey, createIndexNowKeyRecord, createKeywordSet, createLogger, createPageRenderer, ctrUnderperformersReport, decayClusterDrafts, decayComparisonRange, decayingReport, deleteChange, deleteClient, deleteContentGroup, deleteCrawlReport, deleteDataForSeoCredentials, deleteKeywordSet, deleteProviderSecret, deleteTokens, deriveBrandTerms, detectBrandTerms, detectTelemetryAgent, diagnoseCsvFiles, diagnoseProperty, diagnosePropertyWorkflow, effectiveRobotsDirectives, effectiveSnippetControl, emptyStatusBreakdown, ensurePrivateDatabaseFiles, ensureSeoCliDirs, entityReadiness, estimateSerpTitleWidth, expectedCtrForPosition, explainOkfValidation, explainRule, fetchCruxFieldData, fetchPage, fetchPageStatus, fetchSearchStatusIncidents, fetchSitemapUrls, fetchText, fileSize, finalGscDateRange, finalizeProviderSpend, findOverlappingSearchUpdates, formatRelativeExpiry, ga4MatchReason, ga4PropertyIdFromName, ga4ReportQualityWarnings, ga4RequestCanUseCache, ga4RowsToObjects, generateLlmsTxt, geoGaps, geoGapsReport, getAuthModeStatus, getCacheStats, getChange, getClient, getClientConfig, getContentGroup, getDb, getKeywordProvider, getKeywordSet, getPreviousRun, getPrivacySnapshot, getProviderSpendLimits, getProviderSpendSummary, getRepeatedLinkRecoverUrls, getRunPages, getSeoCliPaths, getServiceAccountConfig, getServiceAccountStatus, getTelemetryStatus, getTokenStorageStatus, googleAnalyticsPropertyId, groupCrawlIssues, hasMetaRobotsDirective, hasRule, hasXRobotsDirective, hashKey, importLinkEvidence, importServerLog, indexCoveragePlan, indexCoverageSignals, indexMonitor, indexWatch, inferPseoTemplate, inferTemplateMovement, initializeTelemetry, insertCrawlRun, insertLinkRecoverRun, inspectUrl, internalLinksReport, interpretUpdateCorrelation, isBrandQuery, isCompatibleTechnicalBaseline, isCurrentTechnicalBaseline, isEntityEvidenceSchemaType, isSiteIdentitySchemaType, isSkippableReportError, isTelemetryCi, isTelemetryReport, isoDate, isoWeek, keywordDiscoverySourceSchema, keywordMetricsReport, keywordOpportunitiesReport, keywordResearchReport, keywordSetLogicalBytes, latestCrawlReport, latestCrawlSummaries, latestFinalGscDate, latestIndexWatchSummary, latestLinkRecoverSummary, linkEntries, linkEvidenceKey, linkEvidenceReport, linkRecover, linkRecoverRecommendation, listChanges, listClients, listContentGroups, listCrawlReports, listGa4AccountSummaries, listGa4DataStreams, listIndexNowKeys, listKeywordSets, listRules, listSearchUpdates, listSites, loadCrawlReport, localCredentialsProvider, loginWithLoopback, makeRunId, matchGa4WebStreams, measureChange, measureCoverage, metaRobotsDirectives, migrateLegacyMacConfig, missingOAuthClientMessage, missingSharedClientLoginMessage, monitoringStatus, monthlyReport, monthlyReportWorkflow, narrativeCsvFiles, normalizeCrawlConfig, normalizeCrawlSkipReasonCounts, normalizeForCoverage, normalizeHttpUrl, normalizeJavaScriptRenderingMode, normalizeLinkEvidenceRow, normalizeLoadedCrawlReport, normalizeSavedKeyword, noteCacheWrite, observedValue, okfConceptLimit, pageEvidenceRecommendation, pageOpportunitiesReport, parseCombinedLogLine, parseIndexNowSite, parseJsonLogLine, parseOlderThan, parsePseoPath, performanceAudit, performanceReportIsCacheable, planDueIndexUrls, planIndexCoverageFromUrls, plural, propertyMatchesUrl, providerCapabilitySchema, providerIdSchema, providerPreferenceSchema, providerRequestJson, providerRequestText, providerSpendLimitOverridesSchema, pruneIndexWatchSnapshots, pruneLogs, pseoAuditOptions, pseoAuditReport, pseoCsvFiles, pseoIndexStatus, pseoOpportunitiesReport, pseoPresentation, publicHttpFetch, queryClusterReport, queryClusterTokens, queryContentCoverageFromPage, queryContentFieldsFromPage, queryFieldCoverage, queryOpportunityRecommendation, queryPageMetrics, queryPageTopQuery, queryPagesMetrics, queryPagesMetricsBatch, queryPagesTopQueries, queryPagesTopQueriesBatch, querySearchAnalytics, quickWinsCsvRows, quickWinsReport, readBoundedResponseText, readConfig, readDataForSeoCredentials, readOauthClient, readProviderSecret, readTokens, recommendCrawlDiffItem, recommendationForRule, recordChange, redirectTrace, refreshAuthToken, refreshKeywordSet, refreshPrioritiesCsvFiles, refreshPrioritiesWorkflow, removeIndexNowKey, removeKeywordsFromSet, renderCrawlCsv, renderCrawlHtml, renderCrawlJunit, renderCrawlMarkdownTickets, renderCrawlPagesCsv, renderCrawlPretty, renderCsv, renderPresentationTablesMarkdown, renderPseoMarkdown, renderReportHtml, renderWorkflowMarkdown, reportNarrative, reportPresentation, requestHeaders, reserveProviderSpend, resolveIndexNowKey, resolveProvider, resolveSegmentRanges, resolveSeoCliPaths, resolveTechnicalBaseline, reviewObservations, roundedPosition, runDoctor, runGa4Report, safeError, saveClient, saveCrawlReport, saveIndexNowKey, savedKeywordSetReport, searchMarketSchema, secondPage, segmentComparisonRange, segmentImpact, segmentRangeDays, selectAffectedUrls, selectDueIndexUrls, seoErrorEnvelope, seoToAiQueryReport, serpResultsReport, serverLogReport, sessionSourceInListFilter, setClientBingSite, setDefaultClient, setKeywordSetRefreshTime, setProviderSpendLimits, setTelemetryEnabled, setTokenStorageMode, shiftIsoDate, shouldExcludeBrandQuery, siteSchema, sqliteCrawlReportStore, strikingDistance, submitIndexNow, summarizeCrawlReport, pageTechnicalSignals as technicalPageSignals, technicalWatchWorkflow, telemetryErrorCategory, templateForUrl, toSeoError, tokenSchema, topCrawlRecommendations, topFixes, trackTelemetryReportComplete, trackTelemetryReportFailed, trackTelemetryReportStart, trackTelemetrySetupComplete, trafficAnomaly, unavailableSegmentImpactReport, unavailableValue, unicodeTokens, updateCorrelation, updatePostmortemCsvFiles, updatePostmortemWorkflow, validateIndexNowKey, validateIndexNowKeyRecord, validateOkfFiles, verifyIndexNowKey, verifyQueryContent, workflowPresentation, writeConfig, writeDataForSeoCredentials, writeOauthClient, writeProviderSecret, writeTokens, xRobotsDirectives };
 
 //# sourceMappingURL=index.js.map