seo 0.2.15 → 0.2.17

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-C-Oa9Mgz.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,157 @@ 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/rank-tracking/schema.ts
+const RANK_TRACKING_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS rank_tracking_configs (
+  id TEXT PRIMARY KEY,
+  config_key TEXT NOT NULL UNIQUE,
+  project_id TEXT NOT NULL,
+  keyword_set_id TEXT NOT NULL,
+  target_domain TEXT NOT NULL,
+  tag TEXT,
+  market_json TEXT NOT NULL,
+  devices_json TEXT NOT NULL,
+  provider TEXT NOT NULL CHECK(provider IN ('dataforseo', 'semrush', 'ahrefs')),
+  collection_method TEXT NOT NULL CHECK(collection_method IN ('live', 'queued')),
+  cadence TEXT NOT NULL CHECK(cadence IN ('manual', 'daily', 'weekly', 'monthly')),
+  depth INTEGER NOT NULL CHECK(depth BETWEEN 1 AND 100),
+  keyword_limit INTEGER NOT NULL CHECK(keyword_limit BETWEEN 1 AND 1000),
+  next_run_at INTEGER,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  FOREIGN KEY(keyword_set_id) REFERENCES keyword_sets(id) ON DELETE CASCADE
+);
+CREATE INDEX IF NOT EXISTS idx_rank_tracking_configs_project
+  ON rank_tracking_configs(project_id, updated_at DESC, id);
+CREATE INDEX IF NOT EXISTS idx_rank_tracking_configs_due
+  ON rank_tracking_configs(cadence, next_run_at, id);
+
+CREATE TABLE IF NOT EXISTS rank_tracking_runs (
+  id TEXT PRIMARY KEY,
+  config_id TEXT NOT NULL,
+  idempotency_key TEXT NOT NULL UNIQUE,
+  state TEXT NOT NULL CHECK(state IN ('pending', 'partial', 'failed', 'complete')),
+  collection_method TEXT NOT NULL CHECK(collection_method IN ('live', 'queued')),
+  scheduled_for INTEGER NOT NULL,
+  started_at INTEGER NOT NULL,
+  completed_at INTEGER,
+  keyword_count INTEGER NOT NULL,
+  task_count INTEGER NOT NULL,
+  snapshot_count INTEGER NOT NULL DEFAULT 0,
+  pending_count INTEGER NOT NULL,
+  failed_count INTEGER NOT NULL DEFAULT 0,
+  estimated_cost_micros INTEGER,
+  actual_cost_micros INTEGER,
+  config_snapshot_json TEXT NOT NULL,
+  error_summary TEXT,
+  FOREIGN KEY(config_id) REFERENCES rank_tracking_configs(id) ON DELETE CASCADE
+);
+CREATE INDEX IF NOT EXISTS idx_rank_tracking_runs_config
+  ON rank_tracking_runs(config_id, started_at DESC, id DESC);
+DROP INDEX IF EXISTS idx_rank_tracking_active_run;
+CREATE UNIQUE INDEX idx_rank_tracking_active_run
+  ON rank_tracking_runs(config_id)
+  WHERE completed_at IS NULL;
+
+CREATE TABLE IF NOT EXISTS rank_tracking_tasks (
+  id TEXT PRIMARY KEY,
+  run_id TEXT NOT NULL,
+  normalized_keyword TEXT NOT NULL,
+  display_keyword TEXT NOT NULL,
+  device TEXT NOT NULL CHECK(device IN ('desktop', 'mobile')),
+  state TEXT NOT NULL CHECK(state IN ('pending', 'posting', 'posted', 'complete', 'failed')),
+  provider_task_id TEXT,
+  attempt_count INTEGER NOT NULL DEFAULT 0,
+  posted_at INTEGER,
+  collected_at INTEGER,
+  error_code TEXT,
+  error_message TEXT,
+  UNIQUE(run_id, normalized_keyword, device),
+  UNIQUE(provider_task_id),
+  FOREIGN KEY(run_id) REFERENCES rank_tracking_runs(id) ON DELETE CASCADE
+);
+CREATE INDEX IF NOT EXISTS idx_rank_tracking_tasks_run
+  ON rank_tracking_tasks(run_id, state, normalized_keyword, device);
+CREATE INDEX IF NOT EXISTS idx_rank_tracking_tasks_provider
+  ON rank_tracking_tasks(provider_task_id, state);
+
+CREATE TABLE IF NOT EXISTS rank_tracking_snapshots (
+  task_id TEXT PRIMARY KEY,
+  run_id TEXT NOT NULL,
+  normalized_keyword TEXT NOT NULL,
+  display_keyword TEXT NOT NULL,
+  device TEXT NOT NULL CHECK(device IN ('desktop', 'mobile')),
+  observation_state TEXT NOT NULL CHECK(observation_state IN ('observed', 'not_observed_within_depth')),
+  organic_position INTEGER,
+  absolute_position INTEGER,
+  ranking_url TEXT,
+  observed_features_json TEXT NOT NULL,
+  checked_at TEXT NOT NULL,
+  provider TEXT NOT NULL CHECK(provider IN ('dataforseo', 'semrush', 'ahrefs')),
+  provider_task_id TEXT,
+  requested_depth INTEGER NOT NULL,
+  returned_rows INTEGER,
+  retained_rows INTEGER,
+  invalid_rows INTEGER NOT NULL,
+  completeness TEXT NOT NULL,
+  estimated_cost_micros INTEGER,
+  actual_cost_micros INTEGER,
+  warnings_json TEXT NOT NULL,
+  created_at INTEGER NOT NULL,
+  FOREIGN KEY(task_id) REFERENCES rank_tracking_tasks(id) ON DELETE CASCADE,
+  FOREIGN KEY(run_id) REFERENCES rank_tracking_runs(id) ON DELETE CASCADE
+);
+CREATE INDEX IF NOT EXISTS idx_rank_tracking_snapshots_run
+  ON rank_tracking_snapshots(run_id, normalized_keyword, device);
+`;
+//#endregion
 //#region packages/core/src/storage/cache-maintenance.ts
 const MEBIBYTE$2 = 1024 * 1024;
 const CACHE_MAX_BYTES = 256 * MEBIBYTE$2;
@@ -1657,6 +1808,8 @@ 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(RANK_TRACKING_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 +5043,7 @@ async function fetchPage(url, opts = {}, dependencies = {}) {
 }
 //#endregion
 //#region packages/core/src/gsc/property-url.ts
-function invalid(message) {
+function invalid$2(message) {
 	throw new SeoError("INVALID_INPUT", message);
 }
 function normalizeHttpUrl(value) {
@@ -4898,10 +5051,10 @@ function normalizeHttpUrl(value) {
 	try {
 		url = new URL(value.trim());
 	} catch {
-		return invalid(`Invalid URL: ${value}`);
+		return invalid$2(`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$2("The report URL must use http:// or https://.");
+	if (url.username || url.password) return invalid$2("The report URL must not contain embedded credentials.");
 	url.hash = "";
 	return url.toString();
 }
@@ -4910,13 +5063,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$2(`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$2(`${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$2(`${url} is outside the Search Console property ${property}.`);
 	return url;
 }
 //#endregion
@@ -7123,7 +7276,7 @@ function selectBenchmarkRows$1(input) {
 function compareText$15(left, right) {
 	return left < right ? -1 : left > right ? 1 : 0;
 }
-function compareItems$1(left, right) {
+function compareItems$2(left, right) {
 	return (right.estimatedCtrClickShortfall ?? -1) - (left.estimatedCtrClickShortfall ?? -1) || right.impressions - left.impressions || left.position - right.position || compareText$15(left.query, right.query) || compareText$15(left.url, right.url);
 }
 function analyzeRow(input) {
@@ -7188,7 +7341,7 @@ function analyzePageOpportunitiesFromRows(input) {
 		reportInput: input,
 		benchmarkContext,
 		excludedTargetRows
-	})).sort(compareItems$1).slice(0, limit);
+	})).sort(compareItems$2).slice(0, limit);
 	const estimatedCtrClickShortfall = Number(items.reduce((sum, item) => sum + (item.estimatedCtrClickShortfall ?? 0), 0).toFixed(2));
 	return {
 		site: input.site,
@@ -18717,7 +18870,7 @@ function compareRetainedSegmentRows(input) {
 }
 //#endregion
 //#region packages/core/src/analyze/segment-impact-analysis.ts
-function verdict$4(input) {
+function verdict$5(input) {
 	if (input.status === "empty") return "Search Console returned no retained segment rows for either window.";
 	if (!input.matchedRows) return "No segment was retained in both windows, so no movement delta was inferred.";
 	const suffix = input.unmatchedRows ? ` ${input.unmatchedRows} one-window rows were kept as unmatched evidence and not converted to zero.` : "";
@@ -18810,7 +18963,7 @@ function analyzeSegmentRows(input) {
 			matchedRows: matched.length,
 			returnedRows: selection.returnedRows,
 			unmatchedRows: unmatched.length,
-			verdict: verdict$4({
+			verdict: verdict$5({
 				status: dataStatus,
 				matchedRows: matched.length,
 				returnedRows: selection.returnedRows,
@@ -19623,7 +19776,7 @@ const defaultDependencies$10 = {
 	searchAnalytics: querySearchAnalytics,
 	now: () => /* @__PURE__ */ new Date()
 };
-function verdict$3(input) {
+function verdict$4(input) {
 	if (input.status === "empty") return "Search Console returned no retained query/page rows for this window.";
 	if (!input.eligible) {
 		if (input.status === "partial") return "No material multi-URL query candidates remained in the validated retained rows, but partial evidence prevents an all-clear.";
@@ -19750,7 +19903,7 @@ async function cannibalReport(input, dependencies = defaultDependencies$10) {
 			returnedClusters: analysis.selection.returnedClusters,
 			suppressedQueries: analysis.selection.suppressedQueries,
 			brandFiltering: input.includeBrand ? "included" : "excluded",
-			verdict: verdict$3({
+			verdict: verdict$4({
 				status: dataStatus,
 				eligible: analysis.selection.eligibleClusters,
 				returned: analysis.selection.returnedClusters
@@ -20036,7 +20189,7 @@ const defaultDependencies$9 = {
 	searchAnalytics: querySearchAnalytics,
 	now: () => /* @__PURE__ */ new Date()
 };
-function verdict$2(report) {
+function verdict$3(report) {
 	if (report.dataStatus === "empty") return "Search Console returned no retained query/page rows for either comparison window.";
 	if (report.dataStatus === "partial" && report.selection.currentAggregatedRows === 0) return "The current retained-row window is empty, so no query/page losses were inferred.";
 	if (report.dataStatus === "partial" && report.selection.previousAggregatedRows === 0) return "The comparison retained-row window is empty, so query/page decay could not be measured.";
@@ -20181,7 +20334,7 @@ async function decayingReport(input, dependencies = defaultDependencies$9) {
 			observedRetainedQueryClickLoss: analysis.totals.eligibleObservedRetainedQueryClickLoss,
 			returnedObservedRetainedQueryClickLoss: analysis.totals.returnedObservedRetainedQueryClickLoss,
 			brandFiltering: input.includeBrand ? "included" : "excluded",
-			verdict: verdict$2(reportBase)
+			verdict: verdict$3(reportBase)
 		},
 		caveats: [
 			`Current window: ${currentRange.startDate} to ${currentRange.endDate}; comparison: ${previousRange.startDate} to ${previousRange.endDate}.`,
@@ -20975,7 +21128,7 @@ function templatesFromGroups(groups) {
 		sampleUrls: group.sampleUrls
 	}));
 }
-function verdict$1(analysis) {
+function verdict$2(analysis) {
 	if (analysis.dataStatus === "empty") return "Search Console returned no retained query/page rows for this date window.";
 	if (analysis.dataStatus === "filtered") return "No retained query/page rows met the report filters.";
 	return `${countLabel(analysis.summary.eligibleRows, "eligible query/page row")} found; ${countLabel(analysis.summary.returnedRows, "row")} returned for review.`;
@@ -21059,7 +21212,7 @@ async function strikingDistance(input, dependencies = defaultDependencies$7) {
 		summary: {
 			...analysis.summary,
 			brandFiltering: input.includeBrand ? "included" : "excluded",
-			verdict: verdict$1(analysis)
+			verdict: verdict$2(analysis)
 		},
 		caveats: [
 			`Date window: ${range.startDate} to ${range.endDate}, using final GSC data where available.`,
@@ -23807,7 +23960,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 +24057,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 +24097,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(() => {
@@ -24245,7 +24398,10 @@ const userDataPriceSchema = z.object({
 		keyword_suggestions: livePriceSchema.optional(),
 		related_keywords: livePriceSchema.optional()
 	}).passthrough().optional(),
-	serp: z.object({ live: z.object({ advanced: normalPriorityPriceSchema.optional() }).passthrough().optional() }).passthrough().optional()
+	serp: z.object({
+		task_post: normalPriorityPriceSchema.optional(),
+		live: z.object({ advanced: normalPriorityPriceSchema.optional() }).passthrough().optional()
+	}).passthrough().optional()
 }).passthrough();
 const userDataResultSchema = z.object({
 	login: z.string().min(1).max(320),
@@ -24277,7 +24433,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 +24444,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 +24458,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(),
@@ -24363,19 +24519,19 @@ const dataForSeoDiscoveryResponseSchema = z.object({
 }).passthrough();
 //#endregion
 //#region packages/core/src/providers/dataforseo/paid-request.ts
-function usdToMicros$1(value) {
+function usdToMicros(value) {
 	if (value === void 0) return null;
 	return Math.round(value * 1e6);
 }
 function responseTaskIds$1(response) {
 	return [...new Set(response.tasks.flatMap((task) => task.id ? [task.id] : []))].sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
 }
-function responseCostMicros$1(response) {
-	if (response.cost !== void 0) return usdToMicros$1(response.cost);
+function responseCostMicros(response) {
+	if (response.cost !== void 0) return usdToMicros(response.cost);
 	if (response.tasks.some((task) => task.cost === void 0)) return null;
-	return response.tasks.reduce((sum, task) => sum + (usdToMicros$1(task.cost) ?? 0), 0);
+	return response.tasks.reduce((sum, task) => sum + (usdToMicros(task.cost) ?? 0), 0);
 }
-function taskErrorCode$1(statusCode) {
+function taskErrorCode(statusCode) {
 	if (statusCode >= 40100 && statusCode < 40200) return "authentication";
 	if (statusCode === 40202) return "rate-limit";
 	return "remote-error";
@@ -24465,7 +24621,7 @@ async function dataForSeoPaidPost(input) {
 		});
 		throw error;
 	}
-	const actualCostMicros = responseCostMicros$1(response);
+	const actualCostMicros = responseCostMicros(response);
 	const returnedRows = input.rowCount(response);
 	const taskIds = responseTaskIds$1(response);
 	const failedTasks = response.tasks.filter((task) => task.status_code !== 2e4);
@@ -24487,7 +24643,7 @@ async function dataForSeoPaidPost(input) {
 		throw new ProviderError({
 			provider: "dataforseo",
 			operation: input.operation,
-			code: taskErrorCode$1(statusCode),
+			code: taskErrorCode(statusCode),
 			message: `DataForSEO could not complete ${input.operation} (${statusCode}).`,
 			retryable: statusCode === 40202
 		});
@@ -24530,6 +24686,22 @@ async function dataForSeoPaidPost(input) {
 	};
 }
 //#endregion
+//#region packages/core/src/providers/dataforseo/response.ts
+function dataForSeoUsdToMicros(value) {
+	if (value === void 0) return null;
+	return Math.round(value * 1e6);
+}
+function dataForSeoTaskErrorCode(statusCode) {
+	if (statusCode >= 40100 && statusCode < 40200) return "authentication";
+	if (statusCode === 40202) return "rate-limit";
+	return "remote-error";
+}
+function dataForSeoResponseCostMicros(response) {
+	if (response.cost !== void 0) return dataForSeoUsdToMicros(response.cost);
+	if (response.tasks.some((task) => task.cost === void 0)) return null;
+	return response.tasks.reduce((sum, task) => sum + (dataForSeoUsdToMicros(task.cost) ?? 0), 0);
+}
+//#endregion
 //#region packages/core/src/providers/dataforseo/serp-schema.ts
 const serpItemSchema = z.object({
 	type: z.string().trim().min(1).max(100),
@@ -24574,6 +24746,237 @@ const dataForSeoSerpResponseSchema = z.object({
 	tasks: z.array(serpTaskSchema).max(10)
 }).passthrough();
 //#endregion
+//#region packages/core/src/providers/dataforseo/serp-task-schema.ts
+const taskPostItemSchema = z.object({
+	id: z.string().trim().min(1).max(100).optional(),
+	status_code: z.number().int(),
+	status_message: z.string().max(1e3),
+	cost: z.number().finite().nonnegative().optional(),
+	result_count: z.number().int().nonnegative().optional(),
+	data: z.object({ tag: z.string().trim().min(1).max(255).optional() }).passthrough().optional()
+}).passthrough();
+const dataForSeoSerpTaskPostResponseSchema = z.object({
+	status_code: z.number().int(),
+	status_message: z.string().max(1e3),
+	cost: z.number().finite().nonnegative().optional(),
+	tasks_count: z.number().int().nonnegative(),
+	tasks_error: z.number().int().nonnegative(),
+	tasks: z.array(taskPostItemSchema).max(100)
+}).passthrough();
+const readyResultSchema = z.object({
+	id: z.string().trim().min(1).max(100),
+	tag: z.string().trim().max(255).nullable().optional(),
+	se: z.string().trim().max(100).optional(),
+	se_type: z.string().trim().max(100).optional(),
+	endpoint_advanced: z.string().trim().max(2048).nullable().optional()
+}).passthrough();
+const readyTaskSchema = z.object({
+	id: z.string().trim().min(1).max(100).optional(),
+	status_code: z.number().int(),
+	status_message: z.string().max(1e3),
+	cost: z.number().finite().nonnegative().optional(),
+	result: z.array(readyResultSchema).max(1e3).nullable().optional()
+}).passthrough();
+const dataForSeoSerpTasksReadyResponseSchema = z.object({
+	status_code: z.number().int(),
+	status_message: z.string().max(1e3),
+	cost: z.number().finite().nonnegative().optional(),
+	tasks_count: z.number().int().nonnegative(),
+	tasks_error: z.number().int().nonnegative(),
+	tasks: z.array(readyTaskSchema).max(10)
+}).passthrough();
+//#endregion
+//#region packages/core/src/providers/dataforseo/serp-tasks.ts
+const SERP_TASK_POST_PATH = "v3/serp/google/organic/task_post";
+const SERP_TASKS_READY_PATH = "v3/serp/google/organic/tasks_ready";
+const SERP_TASK_GET_ADVANCED_PATH = "v3/serp/google/organic/task_get/advanced/";
+function dataForSeoSerpRows(response) {
+	return response.tasks.reduce((taskTotal, task) => taskTotal + (task.result ?? []).reduce((resultTotal, result) => resultTotal + (result.items?.length ?? 0), 0), 0);
+}
+function validateDataForSeoSerpTaskId(providerTaskId) {
+	if (!/^[a-zA-Z0-9-]{1,100}$/u.test(providerTaskId)) throw new ProviderError({
+		provider: "dataforseo",
+		operation: "serp-task-get",
+		code: "configuration",
+		message: "Use a valid queued SERP task id."
+	});
+}
+async function postDataForSeoSerpTasks(input, transport) {
+	const { price, requests } = input;
+	if (price.perRequestMicros === null || price.perResultMicros === null) throw new ProviderError({
+		provider: "dataforseo",
+		operation: "serp-task-post",
+		code: "invalid-response",
+		message: "DataForSEO Standard SERP pricing is unavailable, so queued tasks were not posted."
+	});
+	const requestUnits = requests.reduce((total, request) => total + Math.ceil(request.depth / 10), 0);
+	const estimatedCostMicros = price.perRequestMicros * requestUnits + price.perResultMicros * requests.length;
+	const reservation = reserveProviderSpend({
+		provider: "dataforseo",
+		capability: "serp-snapshot",
+		endpoint: SERP_TASK_POST_PATH,
+		projectId: input.context.projectId,
+		reportId: input.context.reportId,
+		reportRunId: input.context.reportRunId,
+		requestedRows: requests.length,
+		estimatedCostMicros
+	}, {
+		database: transport.database,
+		limits: transport.spendLimits,
+		now: transport.now().getTime()
+	});
+	let response;
+	try {
+		response = await providerRequestJson({
+			provider: "dataforseo",
+			operation: "serp-task-post",
+			url: new URL(SERP_TASK_POST_PATH, transport.baseUrl),
+			fetch: transport.fetch,
+			maxResponseBytes: transport.maxResponseBytes,
+			timeoutMs: transport.timeoutMs,
+			retry: "never",
+			schema: dataForSeoSerpTaskPostResponseSchema,
+			init: {
+				method: "POST",
+				headers: {
+					authorization: transport.authorization,
+					"content-type": "application/json"
+				},
+				body: JSON.stringify(requests)
+			}
+		});
+	} catch (error) {
+		finalizeProviderSpend(reservation.id, {
+			provider: "dataforseo",
+			state: "failed",
+			actualCostMicros: null,
+			returnedRows: null,
+			taskIds: []
+		}, {
+			database: transport.database,
+			limits: transport.spendLimits,
+			now: transport.now().getTime()
+		});
+		throw error;
+	}
+	const taskReceipts = response.tasks.flatMap((task) => task.id && task.data?.tag ? [{
+		providerTaskId: task.id,
+		tag: task.data.tag
+	}] : []);
+	const taskIds = taskReceipts.map((receipt) => receipt.providerTaskId);
+	const expectedTags = new Set(requests.map((request) => request.tag));
+	const returnedTags = new Set(taskReceipts.map((receipt) => receipt.tag));
+	const receiptsMatch = expectedTags.size === requests.length && returnedTags.size === expectedTags.size && [...expectedTags].every((tag) => returnedTags.has(tag));
+	const failedTasks = response.tasks.filter((task) => task.status_code !== 20100 || !task.id || !task.data?.tag);
+	const actualCostMicros = dataForSeoResponseCostMicros(response);
+	const state = failedTasks.length === 0 && response.tasks_error === 0 ? "succeeded" : failedTasks.length < response.tasks.length ? "partial" : "failed";
+	const spendNotice = finalizeProviderSpend(reservation.id, {
+		provider: "dataforseo",
+		state,
+		actualCostMicros,
+		returnedRows: taskIds.length,
+		taskIds
+	}, {
+		database: transport.database,
+		limits: transport.spendLimits,
+		now: transport.now().getTime()
+	});
+	if (response.status_code !== 2e4 || failedTasks.length > 0 || taskIds.length !== requests.length || !receiptsMatch) {
+		const statusCode = failedTasks[0]?.status_code ?? response.status_code;
+		throw new ProviderError({
+			provider: "dataforseo",
+			operation: "serp-task-post",
+			code: dataForSeoTaskErrorCode(statusCode),
+			message: `DataForSEO accepted ${taskIds.length} of ${requests.length} queued SERP tasks (${statusCode}).`
+		});
+	}
+	return {
+		taskIds,
+		taskReceipts,
+		estimatedCostMicros,
+		actualCostMicros,
+		spendNotice,
+		warnings: [],
+		observedAt: transport.now().toISOString()
+	};
+}
+async function listReadyDataForSeoSerpTasks(transport) {
+	const response = await providerRequestJson({
+		provider: "dataforseo",
+		operation: "serp-tasks-ready",
+		url: new URL(SERP_TASKS_READY_PATH, transport.baseUrl),
+		fetch: transport.fetch,
+		maxResponseBytes: transport.maxResponseBytes,
+		timeoutMs: transport.timeoutMs,
+		retry: "safe",
+		schema: dataForSeoSerpTasksReadyResponseSchema,
+		init: {
+			method: "GET",
+			headers: { authorization: transport.authorization }
+		}
+	});
+	const failedTask = response.tasks.find((task) => task.status_code !== 2e4);
+	if (response.status_code !== 2e4 || failedTask) {
+		const statusCode = failedTask?.status_code ?? response.status_code;
+		throw new ProviderError({
+			provider: "dataforseo",
+			operation: "serp-tasks-ready",
+			code: dataForSeoTaskErrorCode(statusCode),
+			message: `DataForSEO could not list ready SERP tasks (${statusCode}).`,
+			retryable: statusCode === 40202
+		});
+	}
+	return response.tasks.flatMap((task) => (task.result ?? []).map((result) => ({
+		providerTaskId: result.id,
+		tag: result.tag ?? null
+	})));
+}
+async function getDataForSeoSerpTask(providerTaskId, transport) {
+	const response = await providerRequestJson({
+		provider: "dataforseo",
+		operation: "serp-task-get",
+		url: new URL(`${SERP_TASK_GET_ADVANCED_PATH}${providerTaskId}`, transport.baseUrl),
+		fetch: transport.fetch,
+		maxResponseBytes: transport.maxResponseBytes,
+		timeoutMs: transport.timeoutMs,
+		retry: "safe",
+		schema: dataForSeoSerpResponseSchema,
+		init: {
+			method: "GET",
+			headers: { authorization: transport.authorization }
+		}
+	});
+	const failedTask = response.tasks.find((task) => task.status_code !== 2e4);
+	if (response.status_code !== 2e4 || failedTask) {
+		const statusCode = failedTask?.status_code ?? response.status_code;
+		throw new ProviderError({
+			provider: "dataforseo",
+			operation: "serp-task-get",
+			code: dataForSeoTaskErrorCode(statusCode),
+			message: `DataForSEO could not collect queued SERP task ${providerTaskId} (${statusCode}).`,
+			retryable: statusCode === 40202
+		});
+	}
+	return {
+		response,
+		observedAt: transport.now().toISOString(),
+		returnedRows: dataForSeoSerpRows(response),
+		cache: {
+			status: "bypass",
+			storedAt: null,
+			expiresAt: null
+		},
+		cost: {
+			currency: "USD",
+			estimatedMicros: 0,
+			actualMicros: dataForSeoResponseCostMicros(response) ?? 0,
+			taskIds: [providerTaskId]
+		},
+		spendNotice: null,
+		warnings: []
+	};
+}
+//#endregion
 //#region packages/core/src/providers/dataforseo/client.ts
 const DEFAULT_BASE_URL$1 = "https://api.dataforseo.com/";
 const USER_DATA_PATH = "v3/appendix/user_data";
@@ -24596,9 +24999,43 @@ const MAX_KEYWORD_WORDS = 10;
 const MAX_DISCOVERY_SEEDS$1 = 5;
 const MAX_DISCOVERY_ROWS$1 = 100;
 const MAX_SERP_DEPTH$1 = 100;
-function usdToMicros(value) {
-	if (value === void 0) return null;
-	return Math.round(value * 1e6);
+function validateSerpInput(input) {
+	const keyword = input.keyword.trim().replace(/\s+/gu, " ");
+	if (keyword.length < 1 || keyword.length > MAX_KEYWORD_CHARACTERS || keyword.split(/\s+/u).length > MAX_KEYWORD_WORDS) throw new ProviderError({
+		provider: "dataforseo",
+		operation: "serp-snapshot",
+		code: "configuration",
+		message: `SERP snapshots require a keyword of at most ${MAX_KEYWORD_CHARACTERS} characters and ${MAX_KEYWORD_WORDS} words.`
+	});
+	if (/(?:^|\s)(?:allinanchor|allintext|allintitle|allinurl|cache|define|definition|filetype|id|inanchor|info|intext|intitle|inurl|link|site):/iu.test(keyword)) throw new ProviderError({
+		provider: "dataforseo",
+		operation: "serp-snapshot",
+		code: "configuration",
+		message: "SERP snapshot keywords cannot contain search operators with multiplied provider pricing."
+	});
+	if (!Number.isSafeInteger(input.depth) || input.depth < 1 || input.depth > MAX_SERP_DEPTH$1) throw new ProviderError({
+		provider: "dataforseo",
+		operation: "serp-snapshot",
+		code: "configuration",
+		message: `SERP depth must be from 1 to ${MAX_SERP_DEPTH$1}.`
+	});
+	if (!/^[a-z]{2}$/.test(input.languageCode)) throw new ProviderError({
+		provider: "dataforseo",
+		operation: "serp-snapshot",
+		code: "configuration",
+		message: "DataForSEO language code must contain two lowercase letters."
+	});
+	const locationName = input.locationName?.trim();
+	if (input.locationCode !== void 0 === Boolean(locationName)) throw new ProviderError({
+		provider: "dataforseo",
+		operation: "serp-snapshot",
+		code: "configuration",
+		message: "DataForSEO SERP snapshots require exactly one location code or location name."
+	});
+	return {
+		keyword,
+		locationName
+	};
 }
 function unitPrice(components) {
 	const prices = components ?? [];
@@ -24624,19 +25061,12 @@ function keywordDiscoveryPrices(account) {
 function serpLiveAdvancedPrice(account) {
 	return unitPrice(account.price?.serp?.live?.advanced?.priority_normal);
 }
-function taskErrorCode(statusCode) {
-	if (statusCode >= 40100 && statusCode < 40200) return "authentication";
-	if (statusCode === 40202) return "rate-limit";
-	return "remote-error";
+function serpTaskPostPrice(account) {
+	return unitPrice(account.price?.serp?.task_post?.priority_normal);
 }
 function responseTaskIds(response) {
 	return [...new Set(response.tasks.flatMap((task) => task.id ? [task.id] : []))].sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
 }
-function responseCostMicros(response) {
-	if (response.cost !== void 0) return usdToMicros(response.cost);
-	if (response.tasks.some((task) => task.cost === void 0)) return null;
-	return response.tasks.reduce((sum, task) => sum + (usdToMicros(task.cost) ?? 0), 0);
-}
 function responseRows$1(response) {
 	return response.tasks.reduce((taskTotal, task) => taskTotal + (task.result ?? []).reduce((resultTotal, result) => resultTotal + (result.items?.length ?? 0), 0), 0);
 }
@@ -24651,9 +25081,6 @@ function discoveryNextCursor(response) {
 	const cursors = response.tasks.flatMap((task) => (task.result ?? []).flatMap((result) => result.offset_token ? [result.offset_token] : []));
 	return cursors.length === 1 ? cursors[0] ?? null : null;
 }
-function serpRows(response) {
-	return response.tasks.reduce((taskTotal, task) => taskTotal + (task.result ?? []).reduce((resultTotal, result) => resultTotal + (result.items?.length ?? 0), 0), 0);
-}
 var DataForSeoClient = class {
 	fetch;
 	credentials;
@@ -24696,6 +25123,18 @@ var DataForSeoClient = class {
 	authorization(credentials) {
 		return `Basic ${Buffer.from(`${credentials.login}:${credentials.password}`).toString("base64")}`;
 	}
+	serpTaskTransport(credentials) {
+		return {
+			authorization: this.authorization(credentials),
+			baseUrl: this.baseUrl,
+			fetch: this.fetch,
+			maxResponseBytes: this.maxResponseBytes,
+			timeoutMs: this.timeoutMs,
+			now: this.now,
+			database: this.database,
+			spendLimits: this.spendLimits
+		};
+	}
 	async userDataForCredentials(credentials) {
 		let response;
 		try {
@@ -24730,7 +25169,7 @@ var DataForSeoClient = class {
 			throw new ProviderError({
 				provider: "dataforseo",
 				operation: "account-status",
-				code: taskErrorCode(statusCode),
+				code: dataForSeoTaskErrorCode(statusCode),
 				message: `DataForSEO could not return account status (${statusCode}).`,
 				retryable: statusCode === 40202
 			});
@@ -24746,18 +25185,19 @@ var DataForSeoClient = class {
 			provider: "dataforseo",
 			login: account.login,
 			timezone: account.timezone ?? null,
-			balanceMicros: usdToMicros(account.money?.balance),
-			depositedMicros: usdToMicros(account.money?.total),
-			accountDailySpendMicros: usdToMicros(account.money?.statistics?.day?.total),
+			balanceMicros: dataForSeoUsdToMicros(account.money?.balance),
+			depositedMicros: dataForSeoUsdToMicros(account.money?.total),
+			accountDailySpendMicros: dataForSeoUsdToMicros(account.money?.statistics?.day?.total),
 			accountDailySpendPeriod: account.money?.statistics?.day?.value ?? null,
-			accountDailyLimitMicros: usdToMicros(account.money?.limits?.day?.total),
+			accountDailyLimitMicros: dataForSeoUsdToMicros(account.money?.limits?.day?.total),
 			keywordOverviewPrice: keywordOverviewPrice(account),
 			keywordDiscoveryPrices: keywordDiscoveryPrices(account),
 			serpLiveAdvancedPrice: serpLiveAdvancedPrice(account),
+			serpTaskPostPrice: serpTaskPostPrice(account),
 			backlinksSubscriptionExpiresAt: account.backlinks_subscription_expiry_date ?? null,
 			aiMentionsSubscriptionExpiresAt: account.llm_mentions_subscription_expiry_date ?? null,
 			apiVersion: response.version ?? null,
-			requestCostMicros: usdToMicros(response.cost) ?? 0,
+			requestCostMicros: dataForSeoUsdToMicros(response.cost) ?? 0,
 			taskIds: response.tasks.flatMap((task) => task.id ? [task.id] : []),
 			observedAt: this.now().toISOString()
 		};
@@ -24933,7 +25373,7 @@ var DataForSeoClient = class {
 			});
 			throw error;
 		}
-		const actualCostMicros = responseCostMicros(response);
+		const actualCostMicros = dataForSeoResponseCostMicros(response);
 		const returnedRows = responseRows$1(response);
 		const taskIds = responseTaskIds(response);
 		const failedTasks = response.tasks.filter((task) => task.status_code !== 2e4);
@@ -24955,7 +25395,7 @@ var DataForSeoClient = class {
 			throw new ProviderError({
 				provider: "dataforseo",
 				operation: "keyword-metrics",
-				code: taskErrorCode(statusCode),
+				code: dataForSeoTaskErrorCode(statusCode),
 				message: `DataForSEO could not complete the keyword metrics task (${statusCode}).`,
 				retryable: statusCode === 40202
 			});
@@ -25067,38 +25507,7 @@ var DataForSeoClient = class {
 		};
 	}
 	async serpLive(input) {
-		const keyword = input.keyword.trim();
-		if (keyword.length < 1 || keyword.length > MAX_KEYWORD_CHARACTERS || keyword.split(/\s+/u).length > MAX_KEYWORD_WORDS) throw new ProviderError({
-			provider: "dataforseo",
-			operation: "serp-snapshot",
-			code: "configuration",
-			message: `SERP snapshots require a keyword of at most ${MAX_KEYWORD_CHARACTERS} characters and ${MAX_KEYWORD_WORDS} words.`
-		});
-		if (/(?:^|\s)(?:allinanchor|allintext|allintitle|allinurl|cache|define|definition|filetype|id|inanchor|info|intext|intitle|inurl|link|site):/iu.test(keyword)) throw new ProviderError({
-			provider: "dataforseo",
-			operation: "serp-snapshot",
-			code: "configuration",
-			message: "SERP snapshot keywords cannot contain search operators with multiplied provider pricing."
-		});
-		if (!Number.isSafeInteger(input.depth) || input.depth < 1 || input.depth > MAX_SERP_DEPTH$1) throw new ProviderError({
-			provider: "dataforseo",
-			operation: "serp-snapshot",
-			code: "configuration",
-			message: `SERP depth must be from 1 to ${MAX_SERP_DEPTH$1}.`
-		});
-		if (!/^[a-z]{2}$/.test(input.languageCode)) throw new ProviderError({
-			provider: "dataforseo",
-			operation: "serp-snapshot",
-			code: "configuration",
-			message: "DataForSEO language code must contain two lowercase letters."
-		});
-		const locationName = input.locationName?.trim();
-		if (input.locationCode !== void 0 === Boolean(locationName)) throw new ProviderError({
-			provider: "dataforseo",
-			operation: "serp-snapshot",
-			code: "configuration",
-			message: "DataForSEO SERP snapshots require exactly one location code or location name."
-		});
+		const { keyword, locationName } = validateSerpInput(input);
 		const request = {
 			keyword,
 			language_code: input.languageCode,
@@ -25119,9 +25528,56 @@ var DataForSeoClient = class {
 			context: input.context,
 			ttlMs: this.serpTtlMs,
 			refresh: input.refresh,
-			rowCount: serpRows
+			rowCount: dataForSeoSerpRows
 		});
 	}
+	async serpTaskPost(input) {
+		if (input.tasks.length < 1 || input.tasks.length > 100) throw new ProviderError({
+			provider: "dataforseo",
+			operation: "serp-task-post",
+			code: "configuration",
+			message: `A queued SERP post requires 1 to 100 tasks.`
+		});
+		const requests = input.tasks.map((task) => {
+			const validated = validateSerpInput(task);
+			return {
+				keyword: validated.keyword,
+				language_code: task.languageCode,
+				...task.locationCode !== void 0 ? { location_code: task.locationCode } : { location_name: validated.locationName },
+				device: task.device,
+				depth: task.depth,
+				tag: task.tag,
+				priority: 1,
+				remove_from_url: ["srsltid"]
+			};
+		});
+		const credentials = await this.getCredentials("serp-task-post");
+		const credentialScope = providerCredentialScope("dataforseo", credentials.login);
+		const price = (await this.pricingForCredentials(credentials, credentialScope)).serpTaskPostPrice;
+		return postDataForSeoSerpTasks({
+			requests,
+			context: input.context,
+			price
+		}, {
+			authorization: this.authorization(credentials),
+			baseUrl: this.baseUrl,
+			fetch: this.fetch,
+			maxResponseBytes: this.maxResponseBytes,
+			timeoutMs: this.timeoutMs,
+			now: this.now,
+			database: this.database,
+			spendLimits: this.spendLimits
+		});
+	}
+	async serpTasksReady() {
+		const credentials = await this.getCredentials("serp-tasks-ready");
+		return listReadyDataForSeoSerpTasks(this.serpTaskTransport(credentials));
+	}
+	async serpTaskGet(providerTaskId) {
+		validateDataForSeoSerpTaskId(providerTaskId);
+		const credentials = await this.getCredentials("serp-task-get");
+		return getDataForSeoSerpTask(providerTaskId, this.serpTaskTransport(credentials));
+	}
 };
 //#endregion
 //#region packages/core/src/providers/dataforseo/keyword-mapping.ts
@@ -25253,13 +25709,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 +25766,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 +25978,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 +25987,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 +26033,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);
 	}
@@ -26359,7 +26864,7 @@ function pageItem(url, rows) {
 		recommendation: nextRecommendation
 	};
 }
-function compareItems(left, right) {
+function compareItems$1(left, right) {
 	return right.priority.score - left.priority.score || right.impressions - left.impressions || left.position - right.position || compareText$4(left.url, right.url);
 }
 function analyzeSecondPageRows(input) {
@@ -26404,7 +26909,7 @@ function analyzeSecondPageRows(input) {
 		if (item.impressions >= minImpressions) return true;
 		selection.belowMinimumPages++;
 		return false;
-	}).sort(compareItems);
+	}).sort(compareItems$1);
 	const items = eligibleItems.slice(0, limit);
 	selection.eligiblePages = eligibleItems.length;
 	selection.returnedPages = items.length;
@@ -27087,7 +27592,7 @@ var DataForSeoKeywordDiscoveryProvider = class {
 		status: "available",
 		markets: [{
 			searchEngines: ["google"],
-			location: "any"
+			location: "country-only"
 		}]
 	}];
 	client;
@@ -27102,6 +27607,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 +27728,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$3(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 +27801,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$3(error);
 	}
 	const resolution = resolveProvider({
 		capability: "keyword-discovery",
@@ -27300,7 +27811,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 +27832,7 @@ async function keywordResearchReport(input, dependencies = {}) {
 			}
 		});
 	} catch (error) {
-		return providerError$1(error);
+		return providerError$3(error);
 	}
 	const analysis = evidence.data.map((idea) => ({
 		keyword: idea.keyword,
@@ -31955,6 +32469,96 @@ function checkedAt(value, fallback) {
 	const timestamp = Date.parse(value);
 	return Number.isFinite(timestamp) ? new Date(timestamp).toISOString() : fallback;
 }
+function mapDataForSeoSerpSnapshot(input, snapshot, endpoint = SERP_ENDPOINT) {
+	const market = searchMarketSchema.parse(input.market);
+	const keyword = normalizedKeyword$1(input.keyword);
+	const location = locationRequest(market, "serp-snapshot");
+	const result = snapshot.response.tasks.flatMap((task) => task.result ?? []).find((item) => normalizedKeyword$1(item.keyword) === keyword);
+	if (!result) throw new ProviderError({
+		provider: "dataforseo",
+		operation: "serp-snapshot",
+		code: "invalid-response",
+		message: "DataForSEO returned no matching SERP result."
+	});
+	const warnings = [...snapshot.warnings];
+	const items = result.items ?? [];
+	const organicItems = items.filter((item) => item.type === "organic");
+	const mappedOrganicResults = organicItems.flatMap((item) => {
+		const mapped = organicResult(item);
+		return mapped ? [mapped] : [];
+	}).sort((left, right) => left.rankAbsolute - right.rankAbsolute || left.rankGroup - right.rankGroup || compareCodepoints$3(left.url, right.url));
+	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",
+		message: `DataForSEO returned ${invalidRows} organic result${invalidRows === 1 ? "" : "s"} without a valid rank, domain, or URL.`
+	});
+	if (!Number.isFinite(Date.parse(result.datetime))) warnings.push({
+		code: "invalid-serp-observation-time",
+		field: "checkedAt",
+		message: "DataForSEO returned an invalid SERP observation time; the local response time was retained."
+	});
+	const checkUrl = safeUrl(result.check_url);
+	if (result.check_url && !checkUrl) warnings.push({
+		code: "invalid-serp-check-url",
+		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,
+		provider: "dataforseo",
+		capability: "serp-snapshot",
+		data: {
+			keyword,
+			effectiveKeyword: normalizedKeyword$1(result.spell?.keyword ?? result.keyword),
+			searchEngineDomain: result.se_domain?.trim().toLowerCase() ?? null,
+			checkedAt: checkedAt(result.datetime, snapshot.observedAt),
+			checkUrl,
+			resultCount: invalidResultCount ? null : result.se_results_count ?? null,
+			pagesCount: result.pages_count === void 0 ? null : result.pages_count,
+			features,
+			organicResults
+		},
+		observedAt: snapshot.observedAt,
+		market: {
+			...market,
+			device: market.device ?? "desktop"
+		},
+		coverage: {
+			requestedRows: input.depth,
+			returnedRows: snapshot.returnedRows,
+			retainedRows: organicResults.length,
+			invalidRows,
+			providerTotalRows: invalidResultCount ? null : result.se_results_count ?? null,
+			completeness: invalidRows > 0 || invalidResultCount ? "partial" : resultCapped ? "capped" : "complete",
+			nextCursor: null
+		},
+		cache: snapshot.cache,
+		cost: snapshot.cost,
+		request: {
+			operation: "serp-snapshot",
+			endpoint,
+			limit: input.depth,
+			filters: {
+				countryCode: market.countryCode,
+				languageCode: market.languageCode,
+				device: market.device ?? "desktop",
+				...location.locationCode !== void 0 ? { locationCode: location.locationCode } : { locationName: location.locationName }
+			},
+			sort: ["rankAbsolute:ascending", "url:codepoint-ascending"]
+		},
+		warnings
+	};
+}
 var DataForSeoSerpSnapshotProvider = class {
 	provider = "dataforseo";
 	capabilitySupport = [{
@@ -31996,7 +32600,7 @@ var DataForSeoSerpSnapshotProvider = class {
 			reportRunId: randomUUID()
 		};
 		const location = locationRequest(market, "serp-snapshot");
-		const snapshot = await this.client.serpLive({
+		return mapDataForSeoSerpSnapshot(input, await this.client.serpLive({
 			keyword,
 			languageCode: market.languageCode.split("-")[0],
 			...location,
@@ -32004,86 +32608,7 @@ var DataForSeoSerpSnapshotProvider = class {
 			depth: input.depth,
 			refresh: input.refresh,
 			context
-		});
-		const result = snapshot.response.tasks.flatMap((task) => task.result ?? []).find((item) => normalizedKeyword$1(item.keyword) === keyword);
-		if (!result) throw new ProviderError({
-			provider: "dataforseo",
-			operation: "serp-snapshot",
-			code: "invalid-response",
-			message: "DataForSEO returned no matching SERP result."
-		});
-		const warnings = [...snapshot.warnings];
-		const items = result.items ?? [];
-		const organicItems = items.filter((item) => item.type === "organic");
-		const mappedOrganicResults = organicItems.flatMap((item) => {
-			const mapped = organicResult(item);
-			return mapped ? [mapped] : [];
-		}).sort((left, right) => left.rankAbsolute - right.rankAbsolute || left.rankGroup - right.rankGroup || compareCodepoints$3(left.url, right.url));
-		const organicResults = mappedOrganicResults.slice(0, input.depth);
-		const invalidRows = organicItems.length - mappedOrganicResults.length;
-		const resultCapped = mappedOrganicResults.length > input.depth;
-		if (invalidRows > 0) warnings.push({
-			code: "invalid-organic-results",
-			field: "organicResults",
-			message: `DataForSEO returned ${invalidRows} organic result${invalidRows === 1 ? "" : "s"} without a valid rank, domain, or URL.`
-		});
-		if (!Number.isFinite(Date.parse(result.datetime))) warnings.push({
-			code: "invalid-serp-observation-time",
-			field: "checkedAt",
-			message: "DataForSEO returned an invalid SERP observation time; the local response time was retained."
-		});
-		const checkUrl = safeUrl(result.check_url);
-		if (result.check_url && !checkUrl) warnings.push({
-			code: "invalid-serp-check-url",
-			field: "checkUrl",
-			message: "DataForSEO returned an invalid SERP check URL."
-		});
-		const features = [.../* @__PURE__ */ new Set([...result.item_types ?? [], ...items.map((item) => item.type)])].sort(compareCodepoints$3);
-		return {
-			schemaVersion: 1,
-			provider: "dataforseo",
-			capability: "serp-snapshot",
-			data: {
-				keyword,
-				effectiveKeyword: normalizedKeyword$1(result.spell?.keyword ?? result.keyword),
-				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,
-				pagesCount: result.pages_count === void 0 ? null : result.pages_count,
-				features,
-				organicResults
-			},
-			observedAt: snapshot.observedAt,
-			market: {
-				...market,
-				device: market.device ?? "desktop"
-			},
-			coverage: {
-				requestedRows: input.depth,
-				returnedRows: snapshot.returnedRows,
-				retainedRows: organicResults.length,
-				invalidRows,
-				providerTotalRows: result.se_results_count ?? null,
-				completeness: invalidRows > 0 ? "partial" : resultCapped ? "capped" : "complete",
-				nextCursor: null
-			},
-			cache: snapshot.cache,
-			cost: snapshot.cost,
-			request: {
-				operation: "serp-snapshot",
-				endpoint: SERP_ENDPOINT,
-				limit: input.depth,
-				filters: {
-					countryCode: market.countryCode,
-					languageCode: market.languageCode,
-					device: market.device ?? "desktop",
-					...location.locationCode !== void 0 ? { locationCode: location.locationCode } : { locationName: location.locationName }
-				},
-				sort: ["rankAbsolute:ascending", "url:codepoint-ascending"]
-			},
-			warnings
-		};
+		}));
 	}
 };
 //#endregion
@@ -32095,14 +32620,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$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);
@@ -32162,9 +32687,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$2(error);
 	}
 	const resolution = resolveProvider({
 		capability: "serp-snapshot",
@@ -32189,7 +32714,7 @@ async function serpResultsReport(input, dependencies = {}) {
 			}
 		});
 	} catch (error) {
-		return providerError(error);
+		return providerError$2(error);
 	}
 	const domains = domainSummaries(evidence.data);
 	const dataStatus = reportStatus$1(evidence);
@@ -32439,6 +32964,1228 @@ async function pseoOpportunitiesReport(input, dependencies = {}) {
 	};
 }
 //#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$1(message) {
+	throw new SeoError("INVALID_INPUT", message);
+}
+function boundedText(value, label, max) {
+	const normalized = value.trim();
+	if (!normalized || normalized.length > max) invalid$1(`${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$1(`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$1(`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$1(`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$1("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$1("Page mapping must use an absolute HTTP or HTTPS URL.");
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") invalid$1("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$1("Use a valid normalized keyword metric snapshot.");
+	if (normalizeSavedKeyword(parsed.data.metric.keyword) !== normalizedKeyword) invalid$1("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$1(`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$1(`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$1(`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$1(`Saved keyword data cannot exceed ${maxLogicalBytes} logical bytes. Remove an unused set before adding more.`);
+}
+//#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$1("Use a valid search market.");
+	const provider = input.provider === void 0 ? void 0 : providerIdSchema.safeParse(input.provider);
+	if (provider && !provider.success) invalid$1("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$1(`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$1(`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$1(`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$1("Keyword set list limit must be from 1 to 100.");
+	if (!Number.isSafeInteger(offset) || offset < 0) invalid$1("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$1(`Keyword set output limit must be from 1 to ${KEYWORD_SET_LIMITS.outputRows}.`);
+	if (!Number.isSafeInteger(offset) || offset < 0) invalid$1("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/rank-tracking/dataforseo-collector.ts
+const QUEUED_RESULT_ENDPOINT = "v3/serp/google/organic/task_get/advanced/{taskId}";
+var DataForSeoRankTrackingCollector = class {
+	provider = "dataforseo";
+	client;
+	liveProvider;
+	constructor(options = {}) {
+		this.client = new DataForSeoClient(options);
+		this.liveProvider = new DataForSeoSerpSnapshotProvider({ client: this.client });
+	}
+	live(input) {
+		return this.liveProvider.serpSnapshot(input);
+	}
+	async post(input) {
+		const snapshot = await this.client.serpTaskPost({
+			tasks: input.tasks.map(({ taskKey, request }) => {
+				const market = request.market;
+				return {
+					tag: taskKey,
+					keyword: normalizedKeyword$1(request.keyword),
+					languageCode: market.languageCode.split("-")[0],
+					...locationRequest(market, "serp-snapshot"),
+					device: market.device ?? "desktop",
+					depth: request.depth
+				};
+			}),
+			context: input.context
+		});
+		return {
+			provider: this.provider,
+			receipts: snapshot.taskReceipts.map((receipt) => ({
+				taskKey: receipt.tag,
+				providerTaskId: receipt.providerTaskId
+			})),
+			estimatedCostMicros: snapshot.estimatedCostMicros,
+			actualCostMicros: snapshot.actualCostMicros,
+			warnings: snapshot.warnings
+		};
+	}
+	ready() {
+		return this.client.serpTasksReady().then((tasks) => tasks.map((task) => ({
+			providerTaskId: task.providerTaskId,
+			taskKey: task.tag
+		})));
+	}
+	async collect(input) {
+		const snapshot = await this.client.serpTaskGet(input.providerTaskId);
+		return mapDataForSeoSerpSnapshot(input.request, snapshot, QUEUED_RESULT_ENDPOINT);
+	}
+};
+//#endregion
+//#region packages/core/src/rank-tracking/limits.ts
+const RANK_TRACKING_LIMITS = {
+	configurationsPerProject: 25,
+	totalConfigurations: 100,
+	liveKeywordsPerRun: 50,
+	queuedKeywordsPerRun: 1e3,
+	devicesPerRun: 2,
+	tasksPerProviderPost: 100,
+	retainedRunsPerConfiguration: 90,
+	outputRows: 250,
+	logicalBytes: 256 * 1024 * 1024
+};
+//#endregion
+//#region packages/core/src/rank-tracking/configuration-store.ts
+function invalid(message) {
+	throw new SeoError("INVALID_INPUT", message);
+}
+function database(options) {
+	return options.database ?? getDb();
+}
+function parseJson(value, label) {
+	try {
+		return JSON.parse(value);
+	} catch {
+		throw new SeoError("INTERNAL_ERROR", `${label} is corrupt.`);
+	}
+}
+function normalizeDomain(value) {
+	const raw = value.trim().toLowerCase();
+	if (!raw || raw.length > 253) invalid("Use a valid target domain.");
+	let hostname;
+	try {
+		hostname = new URL(raw.includes("://") ? raw : `https://${raw}`).hostname;
+	} catch {
+		invalid("Use a valid target domain.");
+	}
+	if (!hostname || hostname.length > 253 || hostname.includes("..") || !/^[a-z0-9.-]+$/u.test(hostname)) invalid("Use a valid target domain.");
+	return hostname.replace(/\.$/u, "");
+}
+function targetMatchesDomain(targetDomain, candidate) {
+	const target = normalizeDomain(targetDomain);
+	const host = normalizeDomain(candidate);
+	return host === target || host.endsWith(`.${target}`);
+}
+function configFromRow(row) {
+	const market = searchMarketSchema.safeParse(parseJson(row.market_json, "Saved rank market"));
+	const devices = parseJson(row.devices_json, "Saved rank devices");
+	const provider = providerIdSchema.safeParse(row.provider);
+	if (!market.success || market.data.device !== void 0 || !Array.isArray(devices) || devices.length < 1 || devices.length > 2 || devices.some((item) => item !== "desktop" && item !== "mobile") || !provider.success) throw new SeoError("INTERNAL_ERROR", "Saved rank tracking configuration is invalid.");
+	return {
+		schemaVersion: 1,
+		id: row.id,
+		projectId: row.project_id,
+		keywordSetId: row.keyword_set_id,
+		targetDomain: row.target_domain,
+		tag: row.tag,
+		market: market.data,
+		devices,
+		provider: provider.data,
+		collectionMethod: row.collection_method,
+		cadence: row.cadence,
+		depth: row.depth,
+		keywordLimit: row.keyword_limit,
+		nextRunAt: row.next_run_at === null ? null : new Date(row.next_run_at).toISOString(),
+		createdAt: new Date(row.created_at).toISOString(),
+		updatedAt: new Date(row.updated_at).toISOString()
+	};
+}
+function runFromRow(row) {
+	return {
+		schemaVersion: 1,
+		id: row.id,
+		configId: row.config_id,
+		state: row.state,
+		collectionMethod: row.collection_method,
+		scheduledFor: new Date(row.scheduled_for).toISOString(),
+		startedAt: new Date(row.started_at).toISOString(),
+		completedAt: row.completed_at === null ? null : new Date(row.completed_at).toISOString(),
+		keywordCount: row.keyword_count,
+		taskCount: row.task_count,
+		snapshotCount: row.snapshot_count,
+		pendingCount: row.pending_count,
+		failedCount: row.failed_count,
+		estimatedCostMicros: row.estimated_cost_micros,
+		actualCostMicros: row.actual_cost_micros,
+		errorSummary: row.error_summary
+	};
+}
+function taskFromRow(row) {
+	return {
+		id: row.id,
+		runId: row.run_id,
+		normalizedKeyword: row.normalized_keyword,
+		displayKeyword: row.display_keyword,
+		device: row.device,
+		state: row.state,
+		providerTaskId: row.provider_task_id,
+		attemptCount: row.attempt_count,
+		errorCode: row.error_code,
+		errorMessage: row.error_message
+	};
+}
+function observationFromRow(row) {
+	const provider = providerIdSchema.safeParse(row.provider);
+	if (!provider.success) throw new SeoError("INTERNAL_ERROR", "Saved rank provider is invalid.");
+	return {
+		taskId: row.task_id,
+		runId: row.run_id,
+		keyword: row.display_keyword,
+		normalizedKeyword: row.normalized_keyword,
+		device: row.device,
+		state: row.observation_state,
+		organicPosition: row.organic_position,
+		absolutePosition: row.absolute_position,
+		rankingUrl: row.ranking_url,
+		observedFeatures: parseJson(row.observed_features_json, "Saved rank features"),
+		checkedAt: row.checked_at,
+		provider: provider.data,
+		providerTaskId: row.provider_task_id,
+		requestedDepth: row.requested_depth,
+		returnedRows: row.returned_rows,
+		retainedRows: row.retained_rows,
+		invalidRows: row.invalid_rows,
+		completeness: row.completeness,
+		estimatedCostMicros: row.estimated_cost_micros,
+		actualCostMicros: row.actual_cost_micros,
+		warnings: parseJson(row.warnings_json, "Saved rank warnings")
+	};
+}
+function stableConfigKey(value) {
+	return createHash("sha256").update(JSON.stringify(value)).digest("hex");
+}
+function nextRunAt(cadence, scheduledFor) {
+	if (cadence === "manual") return null;
+	const next = new Date(scheduledFor);
+	if (cadence === "daily") next.setUTCDate(next.getUTCDate() + 1);
+	if (cadence === "weekly") next.setUTCDate(next.getUTCDate() + 7);
+	if (cadence === "monthly") {
+		const desiredDay = next.getUTCDate();
+		next.setUTCDate(1);
+		next.setUTCMonth(next.getUTCMonth() + 1);
+		const lastDay = new Date(Date.UTC(next.getUTCFullYear(), next.getUTCMonth() + 1, 0)).getUTCDate();
+		next.setUTCDate(Math.min(desiredDay, lastDay));
+	}
+	return next.getTime();
+}
+function getOrCreateRankTrackingConfiguration(input, options = {}) {
+	const projectId = input.projectId.trim();
+	const keywordSetId = input.keywordSetId.trim();
+	const tag = input.tag?.trim().toLowerCase() || null;
+	if (!projectId || projectId.length > 80) invalid("Use a valid project id.");
+	if (!keywordSetId || keywordSetId.length > 80) invalid("Use a valid keyword set id.");
+	if (tag && tag.length > 40) invalid("Rank tracking tag is too long.");
+	const market = searchMarketSchema.safeParse(input.market);
+	if (!market.success) invalid("Use a valid rank tracking market.");
+	const { device: _ignoredDevice, ...marketWithoutDevice } = market.data;
+	const devices = [...new Set(input.devices)].sort();
+	if (devices.length < 1 || devices.length > 2 || devices.some((item) => item !== "desktop" && item !== "mobile")) invalid("Track desktop, mobile, or both devices.");
+	const provider = providerIdSchema.safeParse(input.provider);
+	if (!provider.success) invalid("Use a supported rank tracking provider.");
+	if (!["live", "queued"].includes(input.collectionMethod)) invalid("Use live or queued rank collection.");
+	if (![
+		"manual",
+		"daily",
+		"weekly",
+		"monthly"
+	].includes(input.cadence)) invalid("Use a supported rank tracking cadence.");
+	if (!Number.isSafeInteger(input.depth) || input.depth < 1 || input.depth > 100) invalid("Rank tracking depth must be from 1 to 100.");
+	const maxKeywords = input.collectionMethod === "live" ? RANK_TRACKING_LIMITS.liveKeywordsPerRun : RANK_TRACKING_LIMITS.queuedKeywordsPerRun;
+	if (!Number.isSafeInteger(input.keywordLimit) || input.keywordLimit < 1 || input.keywordLimit > maxKeywords) invalid(`${input.collectionMethod === "live" ? "Live" : "Queued"} rank tracking can collect 1 to ${maxKeywords} keywords per run.`);
+	const targetDomain = normalizeDomain(input.targetDomain);
+	const db = database(options);
+	const set = getKeywordSet({
+		projectId,
+		idOrName: keywordSetId,
+		limit: 1
+	}, { database: db }).set;
+	if (set.market.searchEngine !== marketWithoutDevice.searchEngine) invalid("The rank tracking search engine must match the keyword set.");
+	const configKey = stableConfigKey({
+		projectId,
+		keywordSetId: set.id,
+		targetDomain,
+		tag,
+		market: marketWithoutDevice,
+		devices,
+		provider: provider.data,
+		collectionMethod: input.collectionMethod,
+		cadence: input.cadence,
+		depth: input.depth,
+		keywordLimit: input.keywordLimit
+	});
+	const existing = db.prepare("SELECT * FROM rank_tracking_configs WHERE config_key = ?").get(configKey);
+	if (existing) return configFromRow(existing);
+	const total = db.prepare("SELECT COUNT(*) AS count FROM rank_tracking_configs").get().count;
+	const projectTotal = db.prepare("SELECT COUNT(*) AS count FROM rank_tracking_configs WHERE project_id = ?").get(projectId).count;
+	if (total >= RANK_TRACKING_LIMITS.totalConfigurations) invalid("Remove an unused rank tracking configuration before adding more.");
+	if (projectTotal >= RANK_TRACKING_LIMITS.configurationsPerProject) invalid("This project already has the maximum rank tracking configurations.");
+	const now = (options.now ?? (() => /* @__PURE__ */ new Date()))().getTime();
+	const id = (options.id ?? randomUUID)();
+	db.prepare(`INSERT INTO rank_tracking_configs
+     (id, config_key, project_id, keyword_set_id, target_domain, tag,
+      market_json, devices_json, provider, collection_method, cadence, depth,
+      keyword_limit, next_run_at, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, configKey, projectId, set.id, targetDomain, tag, JSON.stringify(marketWithoutDevice), JSON.stringify(devices), provider.data, input.collectionMethod, input.cadence, input.depth, input.keywordLimit, input.cadence === "manual" ? null : now, now, now);
+	return configFromRow(db.prepare("SELECT * FROM rank_tracking_configs WHERE id = ?").get(id));
+}
+//#endregion
+//#region packages/core/src/rank-tracking/store.ts
+function activeRankTrackingRun(configId, options = {}) {
+	const row = database(options).prepare(`SELECT * FROM rank_tracking_runs
+       WHERE config_id = ? AND completed_at IS NULL
+       ORDER BY scheduled_for DESC, id DESC LIMIT 1`).get(configId);
+	return row ? runFromRow(row) : null;
+}
+function startRankTrackingRun(input, options = {}) {
+	const db = database(options);
+	const active = activeRankTrackingRun(input.configuration.id, { database: db });
+	if (active) return active;
+	if (input.keywords.length < 1) invalid("The selected keyword set view is empty.");
+	const now = (options.now ?? (() => /* @__PURE__ */ new Date()))().getTime();
+	const scheduledFor = input.scheduledFor?.getTime() ?? now;
+	const runId = (options.id ?? randomUUID)();
+	const idempotencyKey = `${input.configuration.id}:${scheduledFor}`;
+	const taskCount = input.keywords.length * input.configuration.devices.length;
+	const create = db.transaction(() => {
+		db.prepare(`INSERT INTO rank_tracking_runs
+       (id, config_id, idempotency_key, state, collection_method, scheduled_for,
+        started_at, keyword_count, task_count, pending_count, config_snapshot_json)
+       VALUES (?, ?, ?, 'pending', ?, ?, ?, ?, ?, ?, ?)`).run(runId, input.configuration.id, idempotencyKey, input.configuration.collectionMethod, scheduledFor, now, input.keywords.length, taskCount, taskCount, JSON.stringify(input.configuration));
+		const insertTask = db.prepare(`INSERT INTO rank_tracking_tasks
+       (id, run_id, normalized_keyword, display_keyword, device, state)
+       VALUES (?, ?, ?, ?, ?, 'pending')`);
+		for (const keyword of input.keywords) for (const device of input.configuration.devices) insertTask.run((options.id ?? randomUUID)(), runId, keyword.normalizedKeyword, keyword.keyword, device);
+		db.prepare(`UPDATE rank_tracking_configs
+       SET next_run_at = ?, updated_at = ? WHERE id = ?`).run(nextRunAt(input.configuration.cadence, scheduledFor), now, input.configuration.id);
+	});
+	try {
+		create.immediate();
+	} catch (error) {
+		if (/unique constraint/i.test(String(error))) {
+			const recovered = activeRankTrackingRun(input.configuration.id, { database: db });
+			if (recovered) return recovered;
+		}
+		throw error;
+	}
+	return getRankTrackingRun(runId, { database: db });
+}
+function getRankTrackingRun(runId, options = {}) {
+	const row = database(options).prepare("SELECT * FROM rank_tracking_runs WHERE id = ?").get(runId);
+	if (!row) throw new SeoError("INTERNAL_ERROR", "Rank tracking run is missing.");
+	return runFromRow(row);
+}
+function rankTrackingTasks(runId, states, options = {}) {
+	const filter = states?.length ? ` AND state IN (${states.map(() => "?").join(", ")})` : "";
+	return database(options).prepare(`SELECT * FROM rank_tracking_tasks WHERE run_id = ?${filter}
+         ORDER BY normalized_keyword, device, id`).all(runId, ...states ?? []).map(taskFromRow);
+}
+function markRankTasksPosted(runId, receipts, cost, options = {}) {
+	const db = database(options);
+	const now = (options.now ?? (() => /* @__PURE__ */ new Date()))().getTime();
+	db.transaction(() => {
+		const statement = db.prepare(`UPDATE rank_tracking_tasks
+       SET state = 'posted', provider_task_id = ?, posted_at = ?,
+           attempt_count = attempt_count + 1, error_code = NULL,
+           error_message = NULL
+       WHERE id = ? AND run_id = ? AND state IN ('pending', 'posting')`);
+		for (const receipt of receipts) if (statement.run(receipt.providerTaskId, now, receipt.taskId, runId).changes !== 1) throw new SeoError("INTERNAL_ERROR", "A queued rank task changed before its receipt was saved.");
+		db.prepare(`UPDATE rank_tracking_runs
+       SET estimated_cost_micros = CASE
+             WHEN ? IS NULL THEN estimated_cost_micros
+             ELSE COALESCE(estimated_cost_micros, 0) + ? END,
+           actual_cost_micros = CASE
+             WHEN ? IS NULL THEN actual_cost_micros
+             ELSE COALESCE(actual_cost_micros, 0) + ? END
+       WHERE id = ?`).run(cost.estimatedMicros, cost.estimatedMicros, cost.actualMicros, cost.actualMicros, runId);
+	}).immediate();
+}
+function markRankTasksPosting(runId, taskIds, options = {}) {
+	if (taskIds.length === 0) return;
+	const db = database(options);
+	db.transaction(() => {
+		const statement = db.prepare(`UPDATE rank_tracking_tasks
+       SET state = 'posting', attempt_count = attempt_count + 1
+       WHERE id = ? AND run_id = ? AND state = 'pending'`);
+		for (const taskId of taskIds) if (statement.run(taskId, runId).changes !== 1) throw new SeoError("INTERNAL_ERROR", "A queued rank task changed before posting started.");
+	}).immediate();
+}
+function recoverRankTaskReceipt(input, options = {}) {
+	const now = (options.now ?? (() => /* @__PURE__ */ new Date()))().getTime();
+	database(options).prepare(`UPDATE rank_tracking_tasks
+       SET state = 'posted', provider_task_id = ?, posted_at = ?
+       WHERE id = ? AND state = 'posting'`).run(input.providerTaskId, now, input.taskId);
+}
+function saveRankObservation(observation, options = {}) {
+	saveRankObservations([observation], options);
+}
+function saveRankObservations(observations, options = {}) {
+	if (observations.length === 0) return;
+	const runId = observations[0]?.runId;
+	if (!runId || observations.some((observation) => observation.runId !== runId)) throw new SeoError("INTERNAL_ERROR", "A rank observation batch must belong to one run.");
+	const db = database(options);
+	const now = (options.now ?? (() => /* @__PURE__ */ new Date()))().getTime();
+	db.transaction(() => {
+		const insertSnapshot = db.prepare(`INSERT OR IGNORE INTO rank_tracking_snapshots
+       (task_id, run_id, normalized_keyword, display_keyword, device,
+        observation_state, organic_position, absolute_position, ranking_url,
+        observed_features_json, checked_at, provider, provider_task_id,
+        requested_depth, returned_rows, retained_rows, invalid_rows,
+        completeness, estimated_cost_micros, actual_cost_micros, warnings_json,
+        created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+		const completeTask = db.prepare(`UPDATE rank_tracking_tasks
+       SET state = 'complete', collected_at = ?, error_code = NULL,
+           error_message = NULL WHERE id = ?`);
+		const addLiveCost = db.prepare(`UPDATE rank_tracking_runs
+       SET estimated_cost_micros = CASE
+             WHEN ? IS NULL THEN estimated_cost_micros
+             ELSE COALESCE(estimated_cost_micros, 0) + ? END,
+           actual_cost_micros = CASE
+             WHEN ? IS NULL THEN actual_cost_micros
+             ELSE COALESCE(actual_cost_micros, 0) + ? END
+       WHERE id = ? AND collection_method = 'live'`);
+		for (const observation of observations) {
+			const inserted = insertSnapshot.run(observation.taskId, observation.runId, observation.normalizedKeyword, observation.keyword, observation.device, observation.state, observation.organicPosition, observation.absolutePosition, observation.rankingUrl, JSON.stringify(observation.observedFeatures), observation.checkedAt, observation.provider, observation.providerTaskId, observation.requestedDepth, observation.returnedRows, observation.retainedRows, observation.invalidRows, observation.completeness, observation.estimatedCostMicros, observation.actualCostMicros, JSON.stringify(observation.warnings), now);
+			completeTask.run(now, observation.taskId);
+			if (inserted.changes === 1) addLiveCost.run(observation.estimatedCostMicros, observation.estimatedCostMicros, observation.actualCostMicros, observation.actualCostMicros, observation.runId);
+		}
+	}).immediate();
+	refreshRankTrackingRun(runId, {
+		database: db,
+		now: options.now
+	});
+}
+function failRankTrackingTask(input, options = {}) {
+	const db = database(options);
+	const row = db.prepare("SELECT run_id FROM rank_tracking_tasks WHERE id = ?").get(input.taskId);
+	if (!row) return;
+	db.prepare(`UPDATE rank_tracking_tasks
+     SET state = 'failed', attempt_count = attempt_count + 1,
+         error_code = ?, error_message = ? WHERE id = ?`).run(input.code.slice(0, 100), input.message.slice(0, 1e3), input.taskId);
+	refreshRankTrackingRun(row.run_id, {
+		database: db,
+		now: options.now
+	});
+}
+function refreshRankTrackingRun(runId, options = {}) {
+	const db = database(options);
+	const counts = db.prepare(`SELECT
+         SUM(CASE WHEN state = 'complete' THEN 1 ELSE 0 END) AS snapshots,
+         SUM(CASE WHEN state IN ('pending', 'posting', 'posted') THEN 1 ELSE 0 END) AS pending,
+         SUM(CASE WHEN state = 'failed' THEN 1 ELSE 0 END) AS failed
+       FROM rank_tracking_tasks WHERE run_id = ?`).get(runId);
+	const state = counts.pending > 0 ? counts.snapshots > 0 || counts.failed > 0 ? "partial" : "pending" : counts.failed > 0 ? counts.snapshots > 0 ? "partial" : "failed" : "complete";
+	const now = (options.now ?? (() => /* @__PURE__ */ new Date()))().getTime();
+	db.prepare(`UPDATE rank_tracking_runs
+     SET state = ?, snapshot_count = ?, pending_count = ?, failed_count = ?,
+         completed_at = CASE WHEN ? = 0 THEN ? ELSE NULL END,
+         error_summary = CASE WHEN ? > 0 THEN ? ELSE NULL END
+     WHERE id = ?`).run(state, counts.snapshots, counts.pending, counts.failed, counts.pending, now, counts.failed, `${counts.failed} rank task${counts.failed === 1 ? "" : "s"} failed.`, runId);
+	if (counts.pending === 0) pruneRankTrackingRuns(runId, {
+		...options,
+		database: db
+	});
+	return getRankTrackingRun(runId, { database: db });
+}
+function pruneRankTrackingRuns(runId, options = {}) {
+	const db = database(options);
+	const row = db.prepare("SELECT config_id FROM rank_tracking_runs WHERE id = ?").get(runId);
+	if (!row) return;
+	db.prepare(`DELETE FROM rank_tracking_runs
+     WHERE config_id = ? AND id IN (
+       SELECT id FROM rank_tracking_runs
+       WHERE config_id = ? AND completed_at IS NOT NULL
+       ORDER BY scheduled_for DESC, id DESC LIMIT -1 OFFSET ?
+     )`).run(row.config_id, row.config_id, RANK_TRACKING_LIMITS.retainedRunsPerConfiguration);
+	const maxBytes = options.maxLogicalBytes ?? RANK_TRACKING_LIMITS.logicalBytes;
+	while (rankTrackingLogicalBytes(db) > maxBytes) {
+		const oldest = db.prepare(`SELECT id FROM rank_tracking_runs
+         WHERE config_id = ? AND id <> ?
+           AND completed_at IS NOT NULL
+         ORDER BY scheduled_for, id LIMIT 1`).get(row.config_id, runId);
+		if (!oldest) break;
+		db.prepare("DELETE FROM rank_tracking_runs WHERE id = ?").run(oldest.id);
+	}
+	enforceRankTrackingLogicalBytes(db, maxBytes);
+}
+function latestRankTrackingRun(configId, options = {}) {
+	const row = database(options).prepare(`SELECT * FROM rank_tracking_runs WHERE config_id = ?
+       ORDER BY scheduled_for DESC, id DESC LIMIT 1`).get(configId);
+	return row ? runFromRow(row) : null;
+}
+function priorComparableRankTrackingRun(configId, currentRunId, options = {}) {
+	const row = database(options).prepare(`SELECT previous.* FROM rank_tracking_runs previous
+       JOIN rank_tracking_runs current ON current.id = ?
+       WHERE previous.config_id = ? AND previous.id <> current.id
+         AND previous.scheduled_for < current.scheduled_for
+         AND previous.snapshot_count > 0
+       ORDER BY previous.scheduled_for DESC, previous.id DESC LIMIT 1`).get(currentRunId, configId);
+	return row ? runFromRow(row) : null;
+}
+function rankObservations(runId, options = {}) {
+	return database(options).prepare(`SELECT * FROM rank_tracking_snapshots WHERE run_id = ?
+         ORDER BY normalized_keyword, device, task_id`).all(runId).map(observationFromRow);
+}
+function rankTrackingLogicalBytes(db = getDb()) {
+	return db.prepare(`SELECT
+       COALESCE((SELECT SUM(length(id) + length(config_key) + length(project_id) + length(keyword_set_id) + length(target_domain) + COALESCE(length(tag), 0) + length(market_json) + length(devices_json) + length(provider) + length(collection_method) + length(cadence)) FROM rank_tracking_configs), 0) +
+       COALESCE((SELECT SUM(length(id) + length(config_id) + length(idempotency_key) + length(state) + length(collection_method) + length(config_snapshot_json) + COALESCE(length(error_summary), 0)) FROM rank_tracking_runs), 0) +
+       COALESCE((SELECT SUM(length(id) + length(run_id) + length(normalized_keyword) + length(display_keyword) + length(device) + length(state) + COALESCE(length(provider_task_id), 0) + COALESCE(length(error_code), 0) + COALESCE(length(error_message), 0)) FROM rank_tracking_tasks), 0) +
+       COALESCE((SELECT SUM(length(task_id) + length(run_id) + length(normalized_keyword) + length(display_keyword) + length(device) + length(observation_state) + COALESCE(length(ranking_url), 0) + length(observed_features_json) + length(checked_at) + length(provider) + COALESCE(length(provider_task_id), 0) + length(completeness) + length(warnings_json)) FROM rank_tracking_snapshots), 0)
+       AS bytes`).get().bytes;
+}
+function enforceRankTrackingLogicalBytes(db, maxBytes = RANK_TRACKING_LIMITS.logicalBytes) {
+	if (rankTrackingLogicalBytes(db) > maxBytes) throw new SeoError("INVALID_INPUT", "Saved rank history reached its local storage limit. Remove an unused tracking configuration before collecting more.");
+}
+//#endregion
+//#region packages/core/src/rank-tracking/run.ts
+function providerError$1(error) {
+	if (!(error instanceof ProviderError)) return error instanceof SeoError ? error : new SeoError("INTERNAL_ERROR", "Rank collection failed unexpectedly.");
+	if (error.code === "rate-limit") return new SeoError("RATE_LIMITED", error.message);
+	if (error.code === "configuration") return new SeoError("INVALID_INPUT", error.message);
+	return new SeoError("PROVIDER_UNAVAILABLE", error.message);
+}
+async function defaultCollector(provider) {
+	if (provider !== "dataforseo") throw new SeoError("PROVIDER_UNAVAILABLE", `${provider} does not yet implement exact rank collection. Use DataForSEO for this report.`);
+	if (!await readDataForSeoCredentials()) throw new SeoError("PROVIDER_UNAVAILABLE", "DataForSEO is not connected. Run `seo providers dataforseo connect` first.");
+	return new DataForSeoRankTrackingCollector();
+}
+function requestForTask(configuration, task) {
+	return {
+		keyword: task.displayKeyword,
+		market: {
+			...configuration.market,
+			device: task.device
+		},
+		depth: configuration.depth,
+		refresh: true,
+		context: {
+			projectId: configuration.projectId,
+			reportId: "rank-tracking",
+			reportRunId: task.runId
+		}
+	};
+}
+function observationFromEvidence(configuration, task, evidence) {
+	const match = evidence.data.organicResults.find((result) => {
+		try {
+			return targetMatchesDomain(configuration.targetDomain, result.domain);
+		} catch {
+			return false;
+		}
+	});
+	return {
+		taskId: task.id,
+		runId: task.runId,
+		keyword: task.displayKeyword,
+		normalizedKeyword: task.normalizedKeyword,
+		device: task.device,
+		state: match ? "observed" : "not_observed_within_depth",
+		organicPosition: match?.rankGroup ?? null,
+		absolutePosition: match?.rankAbsolute ?? null,
+		rankingUrl: match?.url ?? null,
+		observedFeatures: evidence.data.features,
+		checkedAt: evidence.data.checkedAt,
+		provider: evidence.provider,
+		providerTaskId: task.providerTaskId,
+		requestedDepth: configuration.depth,
+		returnedRows: evidence.coverage.returnedRows,
+		retainedRows: evidence.coverage.retainedRows,
+		invalidRows: evidence.coverage.invalidRows,
+		completeness: evidence.coverage.completeness,
+		estimatedCostMicros: evidence.cost.estimatedMicros,
+		actualCostMicros: evidence.cost.actualMicros,
+		warnings: evidence.warnings
+	};
+}
+async function inBoundedParallel(items, concurrency, operation) {
+	let next = 0;
+	const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+		while (next < items.length) {
+			const index = next;
+			next += 1;
+			const item = items[index];
+			if (item) await operation(item);
+		}
+	});
+	await Promise.all(workers);
+}
+async function collectLive(configuration, run, collector, dependencies) {
+	const tasks = rankTrackingTasks(run.id, ["pending"], dependencies);
+	const observations = [];
+	const warnings = [];
+	await inBoundedParallel(tasks, 3, async (task) => {
+		try {
+			const evidence = await collector.live(requestForTask(configuration, task));
+			observations.push(observationFromEvidence(configuration, task, evidence));
+		} catch (error) {
+			const mapped = providerError$1(error);
+			failRankTrackingTask({
+				taskId: task.id,
+				code: mapped.code,
+				message: mapped.message
+			}, dependencies);
+			warnings.push(`${task.displayKeyword} (${task.device}): ${mapped.message}`);
+		}
+	});
+	saveRankObservations(observations, dependencies);
+	return {
+		collected: observations.length,
+		warnings
+	};
+}
+async function collectQueued(configuration, run, collector, dependencies) {
+	if (!collector.post || !collector.ready || !collector.collect) throw new SeoError("PROVIDER_UNAVAILABLE", `${collector.provider} does not support queued rank collection. Use live collection or another provider.`);
+	const warnings = [];
+	const observations = [];
+	let posted = 0;
+	let ready = [];
+	try {
+		ready = await collector.ready();
+	} catch (error) {
+		const mapped = providerError$1(error);
+		warnings.push(`The provider ready list was unavailable; saved task IDs will still be checked: ${mapped.message}`);
+	}
+	const byTaskKey = new Map(ready.flatMap((item) => item.taskKey ? [[item.taskKey, item.providerTaskId]] : []));
+	for (const task of rankTrackingTasks(run.id, ["posting"], dependencies)) {
+		const providerTaskId = byTaskKey.get(task.id);
+		if (providerTaskId) recoverRankTaskReceipt({
+			taskId: task.id,
+			providerTaskId
+		}, dependencies);
+	}
+	await inBoundedParallel(rankTrackingTasks(run.id, ["posted"], dependencies).filter((task) => task.providerTaskId), 5, async (task) => {
+		try {
+			const evidence = await collector.collect?.({
+				providerTaskId: task.providerTaskId,
+				request: requestForTask(configuration, task)
+			});
+			if (!evidence) return;
+			observations.push(observationFromEvidence(configuration, task, evidence));
+		} catch (error) {
+			const mapped = providerError$1(error);
+			warnings.push(`${task.displayKeyword} (${task.device}): ${mapped.message}`);
+		}
+	});
+	saveRankObservations(observations, dependencies);
+	const pending = rankTrackingTasks(run.id, ["pending"], dependencies);
+	for (let offset = 0; offset < pending.length; offset += RANK_TRACKING_LIMITS.tasksPerProviderPost) {
+		const batch = pending.slice(offset, offset + RANK_TRACKING_LIMITS.tasksPerProviderPost);
+		markRankTasksPosting(run.id, batch.map((task) => task.id), dependencies);
+		try {
+			const result = await collector.post({
+				tasks: batch.map((task) => ({
+					taskKey: task.id,
+					request: requestForTask(configuration, task)
+				})),
+				context: {
+					projectId: configuration.projectId,
+					reportId: "rank-tracking",
+					reportRunId: run.id
+				}
+			});
+			const receiptByKey = new Map(result.receipts.map((receipt) => [receipt.taskKey, receipt]));
+			if (receiptByKey.size !== batch.length) throw new SeoError("PROVIDER_UNAVAILABLE", "The provider did not return one receipt for every queued rank task.");
+			markRankTasksPosted(run.id, batch.map((task) => ({
+				taskId: task.id,
+				providerTaskId: receiptByKey.get(task.id)?.providerTaskId ?? ""
+			})), {
+				estimatedMicros: result.estimatedCostMicros,
+				actualMicros: result.actualCostMicros
+			}, dependencies);
+			posted += batch.length;
+			warnings.push(...result.warnings.map((warning) => warning.message));
+		} catch (error) {
+			const mapped = providerError$1(error);
+			warnings.push(`${batch.length} queued task${batch.length === 1 ? "" : "s"} remain in recovery after posting was interrupted: ${mapped.message}`);
+			break;
+		}
+	}
+	return {
+		collected: observations.length,
+		posted,
+		warnings
+	};
+}
+function due(configuration, now) {
+	return configuration.cadence === "manual" || configuration.nextRunAt === null || Date.parse(configuration.nextRunAt) <= now.getTime();
+}
+async function executeRankTracking(input, dependencies = {}) {
+	const cadence = input.cadence ?? "manual";
+	const collectionMethod = input.collectionMethod ?? (cadence === "manual" ? "live" : "queued");
+	const keywordLimit = input.keywordLimit ?? (collectionMethod === "live" ? 25 : 100);
+	const set = getKeywordSet({
+		projectId: input.projectId,
+		idOrName: input.set,
+		tag: input.tag,
+		limit: keywordLimit
+	}, dependencies);
+	const provider = input.provider ?? set.set.provider ?? "dataforseo";
+	const defaultDevice = set.set.market.device ?? "desktop";
+	const configuration = getOrCreateRankTrackingConfiguration({
+		projectId: input.projectId,
+		keywordSetId: set.set.id,
+		targetDomain: input.targetDomain,
+		tag: input.tag,
+		market: set.set.market,
+		devices: input.devices ?? [defaultDevice],
+		provider,
+		collectionMethod,
+		cadence,
+		depth: input.depth ?? 100,
+		keywordLimit
+	}, dependencies);
+	const warnings = [];
+	let run = activeRankTrackingRun(configuration.id, dependencies);
+	let startedRun = false;
+	let collectedTasks = 0;
+	let postedTasks = 0;
+	if (!run && (input.start ?? true) && due(configuration, dependencies.now?.() ?? /* @__PURE__ */ new Date())) {
+		run = startRankTrackingRun({
+			configuration,
+			keywords: set.items.map((item) => ({
+				keyword: item.keyword,
+				normalizedKeyword: item.normalizedKeyword
+			}))
+		}, {
+			...dependencies,
+			id: dependencies.id ?? randomUUID
+		});
+		startedRun = true;
+	}
+	if (run) {
+		const collector = dependencies.collector ?? await (dependencies.collectorFactory ?? defaultCollector)(provider);
+		if (collector.provider !== provider) throw new SeoError("INTERNAL_ERROR", "The selected rank collector does not match the saved provider.");
+		if (configuration.collectionMethod === "live") {
+			const result = await collectLive(configuration, run, collector, dependencies);
+			collectedTasks += result.collected;
+			warnings.push(...result.warnings);
+		} else {
+			const result = await collectQueued(configuration, run, collector, dependencies);
+			collectedTasks += result.collected;
+			postedTasks += result.posted;
+			warnings.push(...result.warnings);
+		}
+		run = latestRankTrackingRun(configuration.id, dependencies);
+	} else run = latestRankTrackingRun(configuration.id, dependencies);
+	return {
+		configuration,
+		run,
+		startedRun,
+		collectedTasks,
+		postedTasks,
+		operationalWarnings: warnings.slice(0, 20)
+	};
+}
+//#endregion
+//#region packages/core/src/analyze/rank-tracking.ts
+function key$1(item) {
+	return `${item.normalizedKeyword}\u0000${item.device}`;
+}
+function changeFor(current, previous) {
+	if (!previous) return {
+		change: "no-history",
+		organicPositionDelta: null,
+		rankingUrlChanged: false
+	};
+	const rankingUrlChanged = current.state === "observed" && previous.state === "observed" && current.rankingUrl !== previous.rankingUrl;
+	if (current.state === "observed" && previous.state === "not_observed_within_depth") return {
+		change: "new",
+		organicPositionDelta: null,
+		rankingUrlChanged
+	};
+	if (current.state === "not_observed_within_depth" && previous.state === "observed") return {
+		change: "lost",
+		organicPositionDelta: null,
+		rankingUrlChanged
+	};
+	if (current.organicPosition !== null && previous.organicPosition !== null) {
+		const delta = previous.organicPosition - current.organicPosition;
+		return {
+			change: delta > 0 ? "improved" : delta < 0 ? "declined" : "unchanged",
+			organicPositionDelta: delta,
+			rankingUrlChanged
+		};
+	}
+	return {
+		change: "unchanged",
+		organicPositionDelta: null,
+		rankingUrlChanged
+	};
+}
+const CHANGE_ORDER = {
+	lost: 0,
+	declined: 1,
+	new: 2,
+	improved: 3,
+	unchanged: 4,
+	"no-history": 5
+};
+function compareItems(left, right) {
+	return CHANGE_ORDER[left.change] - CHANGE_ORDER[right.change] || Math.abs(right.organicPositionDelta ?? 0) - Math.abs(left.organicPositionDelta ?? 0) || (left.normalizedKeyword < right.normalizedKeyword ? -1 : left.normalizedKeyword > right.normalizedKeyword ? 1 : left.device < right.device ? -1 : left.device > right.device ? 1 : 0);
+}
+function reportItems(current, previous, pending) {
+	const previousByKey = new Map(previous.map((item) => [key$1(item), item]));
+	const items = current.map((item) => {
+		const prior = previousByKey.get(key$1(item));
+		const change = changeFor(item, prior);
+		return {
+			keyword: item.keyword,
+			normalizedKeyword: item.normalizedKeyword,
+			device: item.device,
+			state: item.state,
+			organicPosition: item.organicPosition,
+			absolutePosition: item.absolutePosition,
+			rankingUrl: item.rankingUrl,
+			checkedAt: item.checkedAt,
+			previous: prior ? {
+				state: prior.state,
+				organicPosition: prior.organicPosition,
+				absolutePosition: prior.absolutePosition,
+				rankingUrl: prior.rankingUrl,
+				checkedAt: prior.checkedAt
+			} : null,
+			...change,
+			error: null
+		};
+	});
+	const observedKeys = new Set(current.map(key$1));
+	for (const task of pending) {
+		if (observedKeys.has(key$1(task))) continue;
+		const prior = previousByKey.get(key$1(task));
+		items.push({
+			keyword: task.displayKeyword,
+			normalizedKeyword: task.normalizedKeyword,
+			device: task.device,
+			state: task.state === "failed" ? "failed" : "pending",
+			organicPosition: null,
+			absolutePosition: null,
+			rankingUrl: null,
+			checkedAt: null,
+			previous: prior ? {
+				state: prior.state,
+				organicPosition: prior.organicPosition,
+				absolutePosition: prior.absolutePosition,
+				rankingUrl: prior.rankingUrl,
+				checkedAt: prior.checkedAt
+			} : null,
+			change: "no-history",
+			organicPositionDelta: null,
+			rankingUrlChanged: false,
+			error: task.state === "failed" ? {
+				code: task.errorCode,
+				message: task.errorMessage
+			} : null
+		});
+	}
+	return items.sort(compareItems);
+}
+function verdict$1(run, counts) {
+	if (!run) return "No rank tracking run has started for this configuration.";
+	if (run.pendingCount > 0) return `${run.snapshotCount} of ${run.taskCount} market and device-specific snapshots are collected; ${run.pendingCount} remain pending.`;
+	if (run.failedCount > 0) return `${run.snapshotCount} snapshots were collected and ${run.failedCount} failed; use the completed rows as partial evidence.`;
+	if (counts.improved + counts.declined + counts.newCount + counts.lost > 0) return `${counts.improved} improved, ${counts.declined} declined, ${counts.newCount} became observed, and ${counts.lost} were no longer observed within the tracked depth.`;
+	return `${counts.observed} rankings were observed and ${counts.notObserved} were not observed within the tracked depth.`;
+}
+async function rankTrackingReport(input, dependencies = {}) {
+	const outputLimit = input.outputLimit ?? 100;
+	if (!Number.isSafeInteger(outputLimit) || outputLimit < 1 || outputLimit > 250) throw new SeoError("INVALID_INPUT", "Rank tracking output limit must be from 1 to 250.");
+	const execution = await executeRankTracking(input, dependencies);
+	const { configuration, run } = execution;
+	const current = run ? rankObservations(run.id, dependencies) : [];
+	const priorRun = run ? priorComparableRankTrackingRun(configuration.id, run.id, dependencies) : null;
+	const allItems = reportItems(current, priorRun ? rankObservations(priorRun.id, dependencies) : [], run ? rankTrackingTasks(run.id, void 0, dependencies) : []);
+	const count = (change) => allItems.filter((item) => item.change === change).length;
+	const observed = current.filter((item) => item.state === "observed").length;
+	const notObserved = current.length - observed;
+	const improved = count("improved");
+	const declined = count("declined");
+	const newCount = count("new");
+	const lost = count("lost");
+	const unchanged = count("unchanged");
+	const rankingUrlChanges = allItems.filter((item) => item.rankingUrlChanged).length;
+	const items = allItems.slice(0, outputLimit);
+	const dataStatus = !run ? "unavailable" : run.state === "complete" ? "complete" : run.state === "pending" ? "pending" : "partial";
+	return {
+		schemaVersion: 1,
+		generatedAt: (dependencies.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
+		dataStatus,
+		configuration,
+		run,
+		comparison: {
+			priorRunId: priorRun?.id ?? null,
+			priorStartedAt: priorRun?.startedAt ?? null,
+			comparableItems: allItems.filter((item) => item.previous !== null).length
+		},
+		summary: {
+			trackedKeywords: run?.keywordCount ?? 0,
+			trackedDevices: configuration.devices.length,
+			expectedSnapshots: run?.taskCount ?? 0,
+			completedSnapshots: run?.snapshotCount ?? 0,
+			pendingSnapshots: run?.pendingCount ?? 0,
+			failedSnapshots: run?.failedCount ?? 0,
+			observed,
+			notObservedWithinDepth: notObserved,
+			new: newCount,
+			lost,
+			improved,
+			declined,
+			unchanged,
+			rankingUrlChanges,
+			verdict: verdict$1(run, {
+				observed,
+				notObserved,
+				improved,
+				declined,
+				newCount,
+				lost
+			})
+		},
+		items,
+		coverage: {
+			totalItems: allItems.length,
+			returnedItems: items.length,
+			outputLimit,
+			omittedItems: allItems.length - items.length,
+			requestedDepth: configuration.depth,
+			collectionMethod: configuration.collectionMethod,
+			runState: run?.state ?? "not-started"
+		},
+		cost: {
+			currency: "USD",
+			estimatedMicros: run?.estimatedCostMicros ?? null,
+			actualMicros: run?.actualCostMicros ?? null
+		},
+		operationalWarnings: execution.operationalWarnings,
+		caveats: [
+			`Not observed means the target domain was not retained within the first ${configuration.depth} organic results for that exact market and device. It is not proof that the domain does not rank elsewhere.`,
+			"Exact snapshots and Search Console average position answer different questions and should not be substituted for one another.",
+			"Local, national, desktop, and mobile snapshots remain separate configurations and are never blended into one position.",
+			"Search results can change between checks and may differ from signed-in or personalized results.",
+			...run?.state === "partial" || run?.state === "failed" ? ["Failed or pending tasks make this run partial; do not treat missing rows as losses."] : []
+		],
+		nextSteps: [
+			...run?.pendingCount ? ["Run the same report parameters again after queued tasks are ready; collection is free and resumes from saved task IDs."] : [],
+			"Use Search Console opportunity reports to add clicks, impressions, and average-position context before prioritising a ranking change.",
+			"Inspect ranking URL changes for intent drift or competing templates before changing content.",
+			configuration.cadence === "manual" ? "Use queued collection with a daily, weekly, or monthly cadence when this set needs recurring local tracking." : "Run this report from local cron at the configured cadence; overlapping runs are refused and schedule advancement is deterministic."
+		]
+	};
+}
+//#endregion
 //#region packages/core/src/analyze/reports/dates.ts
 function rangeDays(range) {
 	const start = Date.parse(`${range.startDate}T00:00:00Z`);
@@ -32904,6 +34651,402 @@ function reportPresentation(report) {
 	};
 }
 //#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$1(`A keyword set can contain at most ${KEYWORD_SET_LIMITS.keywordsPerSet} keywords.`);
+	if (currentTotalCount + additions > KEYWORD_SET_LIMITS.totalKeywords) invalid$1(`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$1(`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$1("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/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 +39689,7 @@ const TELEMETRY_REPORTS = [
 	"keyword-metrics",
 	"keyword-opportunities",
 	"keyword-research",
+	"saved-keywords",
 	"link-evidence",
 	"server-log-analysis",
 	"link-recovery",
@@ -37563,6 +39707,7 @@ const TELEMETRY_REPORTS = [
 	"pseo-opportunities",
 	"query-clusters",
 	"quick-wins",
+	"rank-tracking",
 	"redirect-trace",
 	"narrative-report",
 	"second-page",
@@ -37891,6 +40036,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, DataForSeoRankTrackingCollector, 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, RANK_TRACKING_LIMITS, RANK_TRACKING_SCHEMA_SQL, 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, activeRankTrackingRun, 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, enforceRankTrackingLogicalBytes, ensurePrivateDatabaseFiles, ensureSeoCliDirs, entityReadiness, estimateSerpTitleWidth, executeRankTracking, expectedCtrForPosition, explainOkfValidation, explainRule, failRankTrackingTask, 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, getOrCreateRankTrackingConfiguration, getPreviousRun, getPrivacySnapshot, getProviderSpendLimits, getProviderSpendSummary, getRankTrackingRun, 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, latestRankTrackingRun, linkEntries, linkEvidenceKey, linkEvidenceReport, linkRecover, linkRecoverRecommendation, listChanges, listClients, listContentGroups, listCrawlReports, listGa4AccountSummaries, listGa4DataStreams, listIndexNowKeys, listKeywordSets, listRules, listSearchUpdates, listSites, loadCrawlReport, localCredentialsProvider, loginWithLoopback, makeRunId, mapDataForSeoSerpSnapshot, markRankTasksPosted, markRankTasksPosting, 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, priorComparableRankTrackingRun, 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, rankObservations, rankTrackingLogicalBytes, rankTrackingReport, rankTrackingTasks, readBoundedResponseText, readConfig, readDataForSeoCredentials, readOauthClient, readProviderSecret, readTokens, recommendCrawlDiffItem, recommendationForRule, recordChange, recoverRankTaskReceipt, redirectTrace, refreshAuthToken, refreshKeywordSet, refreshPrioritiesCsvFiles, refreshPrioritiesWorkflow, refreshRankTrackingRun, 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, saveRankObservation, saveRankObservations, savedKeywordSetReport, searchMarketSchema, secondPage, segmentComparisonRange, segmentImpact, segmentRangeDays, selectAffectedUrls, selectDueIndexUrls, seoErrorEnvelope, seoToAiQueryReport, serpResultsReport, serverLogReport, sessionSourceInListFilter, setClientBingSite, setDefaultClient, setKeywordSetRefreshTime, setProviderSpendLimits, setTelemetryEnabled, setTokenStorageMode, shiftIsoDate, shouldExcludeBrandQuery, siteSchema, sqliteCrawlReportStore, startRankTrackingRun, strikingDistance, submitIndexNow, summarizeCrawlReport, targetMatchesDomain, 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