seo 0.2.19 → 0.2.21

package/dist/mcp.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-Dl66IhTH.js";
+import { n as version, t as load } from "./esm-CSE-hgHf.js";
 import { Headers, fetch as fetch$1 } from "undici";
 import { chmodSync, createReadStream, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { arch, homedir, platform, totalmem } from "node:os";
@@ -115,6 +115,86 @@ function seoErrorEnvelope(error) {
 	};
 }
 //#endregion
+//#region packages/core/dist/version.js
+const SEO_VERSION = version;
+//#endregion
+//#region packages/core/dist/fetch/crawler-identity.js
+const SEO_CRAWLER_TOKEN = "SEO-Skill";
+const SEO_CRAWLER_USER_AGENT = `${SEO_CRAWLER_TOKEN}/${SEO_VERSION} (+https://seoskill.dev)`;
+const SEO_CRAWLER_IDENTITY = {
+	name: "SEO Skill",
+	robotsToken: SEO_CRAWLER_TOKEN,
+	version: SEO_VERSION,
+	userAgent: SEO_CRAWLER_USER_AGENT,
+	documentationUrl: "https://seoskill.dev/docs/crawler/"
+};
+//#endregion
+//#region packages/core/dist/fetch/http-client.js
+var ResponseSizeLimitError = class extends Error {
+	maxBytes;
+	constructor(maxBytes, label = "Response") {
+		super(`${label} exceeds the ${maxBytes}-byte response limit.`);
+		this.maxBytes = maxBytes;
+		this.name = "ResponseSizeLimitError";
+	}
+};
+function requestHeaders(profile) {
+	if (profile === "bot") return new Headers({
+		accept: "text/plain,*/*;q=0.8",
+		"accept-language": "en-US,en;q=0.9",
+		connection: "close",
+		"user-agent": SEO_CRAWLER_USER_AGENT
+	});
+	return new Headers({
+		accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+		"accept-language": "en-US,en;q=0.9",
+		connection: "close",
+		"sec-ch-ua-mobile": "?0",
+		"sec-ch-ua-platform": "\"macOS\"",
+		"upgrade-insecure-requests": "1",
+		"user-agent": SEO_CRAWLER_USER_AGENT
+	});
+}
+function publicHttpFetch(url, input = {}) {
+	const { profile = "browser", headers, ...init } = input;
+	const base = requestHeaders(profile);
+	if (headers instanceof Headers) for (const [key, value] of headers.entries()) base.set(key, value);
+	else if (Array.isArray(headers)) for (const [key, value] of headers) base.set(key, value);
+	else if (headers) {
+		for (const [key, value] of Object.entries(headers)) if (value !== void 0) base.set(key, value);
+	}
+	return fetch$1(url, {
+		...init,
+		headers: base
+	});
+}
+async function readBoundedResponseText(response, maxBytes, label = "Response") {
+	const declaredLength = Number(response.headers.get("content-length"));
+	if (Number.isFinite(declaredLength) && declaredLength > maxBytes) {
+		await response.body?.cancel().catch(() => void 0);
+		throw new ResponseSizeLimitError(maxBytes, label);
+	}
+	const reader = response.body?.getReader();
+	if (!reader) return "";
+	const chunks = [];
+	let total = 0;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			total += value.byteLength;
+			if (total > maxBytes) {
+				await reader.cancel().catch(() => void 0);
+				throw new ResponseSizeLimitError(maxBytes, label);
+			}
+			chunks.push(value);
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	return Buffer.concat(chunks, total).toString("utf8");
+}
+//#endregion
 //#region packages/core/dist/paths.js
 let memoizedPaths;
 function defaultConfigDir(input) {
@@ -1558,6 +1638,22 @@ function hashKey(parts) {
 	return Buffer.from(json).toString("base64url");
 }
 //#endregion
+//#region packages/core/dist/ga4/account-summaries.js
+const propertySummarySchema = z.object({
+	property: z.string().trim().min(1),
+	displayName: z.string().optional(),
+	propertyType: z.string().optional(),
+	parent: z.string().optional()
+}).strip();
+z.object({
+	accountSummaries: z.array(z.object({
+		account: z.string().trim().min(1),
+		displayName: z.string().optional(),
+		propertySummaries: z.array(propertySummarySchema).optional()
+	}).strip()).max(200).optional(),
+	nextPageToken: z.string().optional()
+}).strip();
+//#endregion
 //#region packages/core/dist/ga4/client.js
 function ga4RequestCanUseCache(body) {
 	return body.dateRanges.every((range) => /^\d{4}-\d{2}-\d{2}$/.test(range.startDate) && /^\d{4}-\d{2}-\d{2}$/.test(range.endDate));
@@ -1718,7 +1814,7 @@ function aiReferralSourceForValue(value) {
 function compareText$18(left, right) {
 	return left < right ? -1 : left > right ? 1 : 0;
 }
-function metric(row, name) {
+function metric$1(row, name) {
 	const value = row[name];
 	const parsed = Number(value);
 	if (value === void 0 || value.trim() === "" || !Number.isInteger(parsed) || parsed < 0) throw new SeoError("PROVIDER_UNAVAILABLE", `Google Analytics returned an invalid ${name} value.`);
@@ -1753,8 +1849,8 @@ function analyzeAiReferralRows(input) {
 			...emptyMetrics()
 		};
 		addMetrics(total, {
-			sessions: metric(row, "sessions"),
-			eventCount: metric(row, "eventCount")
+			sessions: metric$1(row, "sessions"),
+			eventCount: metric$1(row, "eventCount")
 		});
 		total.observedSessionSources.add(row.sessionSource ?? "");
 		sourceTotals.set(definition.id, total);
@@ -1766,8 +1862,8 @@ function analyzeAiReferralRows(input) {
 		const definition = aiReferralSourceForValue(row.sessionSource ?? "");
 		if (!definition || !sourceTotals.has(definition.id)) throw new SeoError("PROVIDER_UNAVAILABLE", "Google Analytics detail rows contained an unexpected session source.");
 		const metrics = {
-			sessions: metric(row, "sessions"),
-			eventCount: metric(row, "eventCount")
+			sessions: metric$1(row, "sessions"),
+			eventCount: metric$1(row, "eventCount")
 		};
 		addMetrics(detailTotal, metrics);
 		const landingPage = row.landingPagePlusQueryString || "(not set)";
@@ -3410,20 +3506,6 @@ async function extractPage(fetchResult, extractor = "defuddle", dependencies = {
 	};
 }
 //#endregion
-//#region packages/core/dist/version.js
-const SEO_VERSION = version;
-//#endregion
-//#region packages/core/dist/fetch/crawler-identity.js
-const SEO_CRAWLER_TOKEN = "SEO-Skill";
-const SEO_CRAWLER_USER_AGENT = `${SEO_CRAWLER_TOKEN}/${SEO_VERSION} (+https://seoskill.dev)`;
-const SEO_CRAWLER_IDENTITY = {
-	name: "SEO Skill",
-	robotsToken: SEO_CRAWLER_TOKEN,
-	version: SEO_VERSION,
-	userAgent: SEO_CRAWLER_USER_AGENT,
-	documentationUrl: "https://seoskill.dev/docs/crawler/"
-};
-//#endregion
 //#region packages/core/dist/fetch/access-block.js
 const CLOUDFLARE_SKIP_DOCS = "https://developers.cloudflare.com/waf/custom-rules/skip/";
 function isHeadersLike(headers) {
@@ -3495,72 +3577,6 @@ function detectAccessBlock(input) {
 	};
 }
 //#endregion
-//#region packages/core/dist/fetch/http-client.js
-var ResponseSizeLimitError = class extends Error {
-	maxBytes;
-	constructor(maxBytes, label = "Response") {
-		super(`${label} exceeds the ${maxBytes}-byte response limit.`);
-		this.maxBytes = maxBytes;
-		this.name = "ResponseSizeLimitError";
-	}
-};
-function requestHeaders(profile) {
-	if (profile === "bot") return new Headers({
-		accept: "text/plain,*/*;q=0.8",
-		"accept-language": "en-US,en;q=0.9",
-		connection: "close",
-		"user-agent": SEO_CRAWLER_USER_AGENT
-	});
-	return new Headers({
-		accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-		"accept-language": "en-US,en;q=0.9",
-		connection: "close",
-		"sec-ch-ua-mobile": "?0",
-		"sec-ch-ua-platform": "\"macOS\"",
-		"upgrade-insecure-requests": "1",
-		"user-agent": SEO_CRAWLER_USER_AGENT
-	});
-}
-function publicHttpFetch(url, input = {}) {
-	const { profile = "browser", headers, ...init } = input;
-	const base = requestHeaders(profile);
-	if (headers instanceof Headers) for (const [key, value] of headers.entries()) base.set(key, value);
-	else if (Array.isArray(headers)) for (const [key, value] of headers) base.set(key, value);
-	else if (headers) {
-		for (const [key, value] of Object.entries(headers)) if (value !== void 0) base.set(key, value);
-	}
-	return fetch$1(url, {
-		...init,
-		headers: base
-	});
-}
-async function readBoundedResponseText(response, maxBytes, label = "Response") {
-	const declaredLength = Number(response.headers.get("content-length"));
-	if (Number.isFinite(declaredLength) && declaredLength > maxBytes) {
-		await response.body?.cancel().catch(() => void 0);
-		throw new ResponseSizeLimitError(maxBytes, label);
-	}
-	const reader = response.body?.getReader();
-	if (!reader) return "";
-	const chunks = [];
-	let total = 0;
-	try {
-		while (true) {
-			const { done, value } = await reader.read();
-			if (done) break;
-			total += value.byteLength;
-			if (total > maxBytes) {
-				await reader.cancel().catch(() => void 0);
-				throw new ResponseSizeLimitError(maxBytes, label);
-			}
-			chunks.push(value);
-		}
-	} finally {
-		reader.releaseLock();
-	}
-	return Buffer.concat(chunks, total).toString("utf8");
-}
-//#endregion
 //#region packages/core/dist/fetch/page-fetcher/rate-controls.js
 const HOST_QUEUES = /* @__PURE__ */ new Map();
 const HOST_HEALTH = /* @__PURE__ */ new Map();
@@ -5307,7 +5323,7 @@ function estimateSerpTitleWidth(title) {
 }
 //#endregion
 //#region packages/core/dist/analyze/audit-page.js
-const defaultDependencies$15 = {
+const defaultDependencies$16 = {
 	fetchPage,
 	queryPageMetrics,
 	now: () => /* @__PURE__ */ new Date()
@@ -5338,7 +5354,7 @@ function buildRecommendations(report) {
 	});
 	return recommendations;
 }
-async function auditPage(input, dependencies = defaultDependencies$15) {
+async function auditPage(input, dependencies = defaultDependencies$16) {
 	const fetched = await dependencies.fetchPage(input.url, {
 		js: input.js,
 		refresh: input.refresh
@@ -6912,7 +6928,7 @@ function pageOpportunityRecommendations(analysis) {
 //#endregion
 //#region packages/core/dist/analyze/page-opportunities.js
 const MAX_BENCHMARK_ROWS = 1e5;
-const defaultDependencies$14 = {
+const defaultDependencies$15 = {
 	searchAnalytics: querySearchAnalytics,
 	fetch: fetchPage,
 	extract: extractPage,
@@ -6984,7 +7000,7 @@ function reportCaveats$1(input) {
 		input.benchmarkTruncated ? `The site-wide benchmark reached its ${MAX_BENCHMARK_ROWS.toLocaleString("en-US")}-row cap, so provenance is complete but the peer sample is truncated.` : ""
 	].filter(Boolean);
 }
-async function pageOpportunitiesReport(input, dependencies = defaultDependencies$14) {
+async function pageOpportunitiesReport(input, dependencies = defaultDependencies$15) {
 	const url = assertUrlMatchesGscProperty(input.site, input.url);
 	const days = reportDays$1(input.days);
 	const range = defaultDateRange$1(days);
@@ -10771,7 +10787,7 @@ function absoluteHttpUrl(value) {
 		return false;
 	}
 }
-function urlKey(value) {
+function urlKey$1(value) {
 	if (!value) return void 0;
 	try {
 		const url = new URL(value);
@@ -10970,7 +10986,7 @@ function auditCrawlPages(pages, opts = {}) {
 	for (const page of pages) {
 		if (!isAuditableHtmlPage(page)) continue;
 		for (const value of [page.url, page.finalUrl]) {
-			const key = urlKey(value);
+			const key = urlKey$1(value);
 			if (key) pageByUrl.set(key, page);
 		}
 	}
@@ -11112,7 +11128,7 @@ function auditCrawlPages(pages, opts = {}) {
 				canonicalRaw: page.canonicalRaw,
 				canonical: page.canonical
 			}));
-			const canonicalTarget = pageByUrl.get(urlKey(page.canonical) ?? "");
+			const canonicalTarget = pageByUrl.get(urlKey$1(page.canonical) ?? "");
 			if (canonicalTarget?.canonical && !sameUrl(canonicalTarget.canonical, page.canonical)) issues.push(issue("canonical_chain", page, page.canonical, {
 				canonical: page.canonical,
 				nextCanonical: canonicalTarget.canonical,
@@ -11286,7 +11302,7 @@ const SENSITIVE_FIELD_NAMES = /* @__PURE__ */ new Set([
 	"refresh-token"
 ]);
 const SENSITIVE_PARAM_PATTERN = /^(access_?token|auth|api_?key|client_?secret|code|jwt|key|password|refresh_?token|secret|session|sig|signature|token)$/i;
-function uniqueSorted(values = []) {
+function uniqueSorted$1(values = []) {
 	return [...new Set(values.filter(Boolean))].sort();
 }
 function normalizeFetchRate(input, strategy) {
@@ -11306,13 +11322,13 @@ function normalizeCrawlConfig(input) {
 		mode: input.mode ?? (strategy === "health" ? "sitemap" : "site"),
 		strategy,
 		...input.sitemapUrl ? { sitemapUrl: new URL(input.sitemapUrl).toString() } : {},
-		urls: uniqueSorted(input.urls ?? []),
+		urls: uniqueSorted$1(input.urls ?? []),
 		maxPages: input.maxPages ?? 500,
 		maxDepth: input.maxDepth ?? 16,
 		concurrency,
 		timeoutMs: input.timeoutMs ?? 2e4,
-		include: uniqueSorted(input.include ?? []),
-		exclude: uniqueSorted(input.exclude ?? []),
+		include: uniqueSorted$1(input.include ?? []),
+		exclude: uniqueSorted$1(input.exclude ?? []),
 		respectRobots: input.respectRobots ?? true,
 		useSitemap: input.useSitemap ?? true,
 		checkExternal: strategy === "health" ? false : input.checkExternal ?? true,
@@ -13557,7 +13573,7 @@ async function fetchSitemapUrls(input) {
 }
 //#endregion
 //#region packages/core/dist/analyze/workflows/analytics-value.js
-const defaultDependencies$13 = { runGa4Report };
+const defaultDependencies$14 = { runGa4Report };
 function normalizePath(value) {
 	if (!value || value === "(not set)") return "";
 	const [path = ""] = value.split("?");
@@ -13617,7 +13633,7 @@ function landingPageRankingPolicy(input) {
 		warnings
 	};
 }
-async function fetchLandingPageValues(input, dependencies = defaultDependencies$13) {
+async function fetchLandingPageValues(input, dependencies = defaultDependencies$14) {
 	const retainedRowLimit = input.limit ?? 5e3;
 	if (!input.propertyId) return {
 		values: /* @__PURE__ */ new Map(),
@@ -16585,15 +16601,15 @@ function analyzeCtrUnderperformersFromRows(input) {
 }
 //#endregion
 //#region packages/core/dist/analyze/ctr-underperformers.js
-const MAX_GSC_ROWS$4 = 1e5;
+const MAX_GSC_ROWS$5 = 1e5;
 function plural$3(count, singular, pluralLabel = `${singular}s`) {
 	return count === 1 ? singular : pluralLabel;
 }
-const defaultDependencies$12 = {
+const defaultDependencies$13 = {
 	searchAnalytics: querySearchAnalytics,
 	now: () => /* @__PURE__ */ new Date()
 };
-async function ctrUnderperformersReport(input, dependencies = defaultDependencies$12) {
+async function ctrUnderperformersReport(input, dependencies = defaultDependencies$13) {
 	const minImpressions = integerOption$2({
 		value: input.minImpressions,
 		fallback: 200,
@@ -16615,7 +16631,7 @@ async function ctrUnderperformersReport(input, dependencies = defaultDependencie
 		dimensions: ["query", "page"],
 		type: "web",
 		dataState: "final",
-		maxRows: MAX_GSC_ROWS$4
+		maxRows: MAX_GSC_ROWS$5
 	}, { refresh: input.refresh });
 	const { items, totalClickShortfall, returnedClickShortfall, selection } = analyzeCtrUnderperformersFromRows({
 		rows: source.rows,
@@ -16626,7 +16642,7 @@ async function ctrUnderperformersReport(input, dependencies = defaultDependencie
 		includeBrand: input.includeBrand
 	});
 	const top = items[0];
-	const possiblyTruncated = source.rowsFetched >= MAX_GSC_ROWS$4;
+	const possiblyTruncated = source.rowsFetched >= MAX_GSC_ROWS$5;
 	const partialValidation = selection.invalidRows > 0;
 	const dataStatus = selection.sourceRows === 0 ? "empty" : possiblyTruncated || partialValidation ? "partial" : selection.eligibleUnderperformers === 0 ? "filtered" : "complete";
 	const completeness = possiblyTruncated && partialValidation ? "partial-and-possibly-truncated" : possiblyTruncated ? "possibly-truncated" : partialValidation ? "partial" : "complete";
@@ -16643,7 +16659,7 @@ async function ctrUnderperformersReport(input, dependencies = defaultDependencie
 			dataState: "final",
 			rowsFetched: source.rowsFetched,
 			calls: source.calls,
-			maxRows: MAX_GSC_ROWS$4,
+			maxRows: MAX_GSC_ROWS$5,
 			possiblyTruncated,
 			completeness,
 			validation: {
@@ -16673,7 +16689,7 @@ async function ctrUnderperformersReport(input, dependencies = defaultDependencie
 			"CTR benchmarks and calculated click shortfalls are directional heuristics, not forecasts or proof that clicks are available. Validate the search intent and live SERP before editing.",
 			...selection.invalidRows ? [`${selection.invalidRows} invalid provider ${plural$3(selection.invalidRows, "row")} ${selection.invalidRows === 1 ? "was" : "were"} excluded, so this report is partial.`] : [],
 			...selection.duplicateRows ? [`${selection.duplicateRows} repeated query/page ${plural$3(selection.duplicateRows, "row")} ${selection.duplicateRows === 1 ? "was" : "were"} aggregated before CTR and average position were calculated.`] : [],
-			...possiblyTruncated ? [`The retained-row limit of ${MAX_GSC_ROWS$4} was reached, so lower-ranked source rows may be absent.`] : [],
+			...possiblyTruncated ? [`The retained-row limit of ${MAX_GSC_ROWS$5} was reached, so lower-ranked source rows may be absent.`] : [],
 			...selection.limitedUnderperformers ? [`${selection.limitedUnderperformers} eligible ${plural$3(selection.limitedUnderperformers, "underperformer")} ${selection.limitedUnderperformers === 1 ? "was" : "were"} omitted by the output limit.`] : []
 		],
 		recommendations: top ? [
@@ -17186,11 +17202,11 @@ function unavailableSegmentImpactReport(input) {
 //#endregion
 //#region packages/core/dist/analyze/segment-impact.js
 const DEFAULT_MAX_ROWS = 1e5;
-const defaultDependencies$11 = {
+const defaultDependencies$12 = {
 	searchAnalytics: querySearchAnalytics,
 	now: () => /* @__PURE__ */ new Date()
 };
-async function segmentImpact(input, dependencies = defaultDependencies$11) {
+async function segmentImpact(input, dependencies = defaultDependencies$12) {
 	validateSegmentSite(input.site);
 	const now = dependencies.now();
 	const ranges = resolveSegmentRanges({
@@ -17743,8 +17759,8 @@ function analyzeCannibalRows(input) {
 }
 //#endregion
 //#region packages/core/dist/analyze/site-diagnostics/cannibal.js
-const MAX_GSC_ROWS$3 = 1e5;
-const defaultDependencies$10 = {
+const MAX_GSC_ROWS$4 = 1e5;
+const defaultDependencies$11 = {
 	searchAnalytics: querySearchAnalytics,
 	now: () => /* @__PURE__ */ new Date()
 };
@@ -17757,7 +17773,7 @@ function verdict$4(input) {
 	const result = `${input.returned} of ${input.eligible} multi-URL query candidate${input.eligible === 1 ? "" : "s"} returned for intent and technical review.`;
 	return input.status === "partial" ? `${result} Provider evidence is partial.` : result;
 }
-async function cannibalReport(input, dependencies = defaultDependencies$10) {
+async function cannibalReport(input, dependencies = defaultDependencies$11) {
 	const days = integerOption$2({
 		value: input.days,
 		fallback: 28,
@@ -17787,7 +17803,7 @@ async function cannibalReport(input, dependencies = defaultDependencies$10) {
 		...range,
 		type: "web",
 		dataState: "final",
-		maxRows: MAX_GSC_ROWS$3
+		maxRows: MAX_GSC_ROWS$4
 	};
 	const [pageExposure, propertyDemand] = await Promise.all([dependencies.searchAnalytics(input.site, {
 		...requestBase,
@@ -17810,8 +17826,8 @@ async function cannibalReport(input, dependencies = defaultDependencies$10) {
 		brandTerms: input.brandTerms,
 		includeBrand: input.includeBrand
 	});
-	const pageTruncated = pageExposure.rowsFetched >= MAX_GSC_ROWS$3;
-	const propertyTruncated = propertyDemand.rowsFetched >= MAX_GSC_ROWS$3;
+	const pageTruncated = pageExposure.rowsFetched >= MAX_GSC_ROWS$4;
+	const propertyTruncated = propertyDemand.rowsFetched >= MAX_GSC_ROWS$4;
 	const possiblyTruncated = pageTruncated || propertyTruncated;
 	const partialValidation = analysis.selection.invalidRows + analysis.selection.propertyInvalidRows > 0;
 	const completeness = possiblyTruncated && partialValidation ? "partial-and-possibly-truncated" : possiblyTruncated ? "possibly-truncated" : partialValidation ? "partial" : "complete";
@@ -17836,7 +17852,7 @@ async function cannibalReport(input, dependencies = defaultDependencies$10) {
 					invalidRows: analysis.selection.invalidRows
 				},
 				calls: pageExposure.calls,
-				maxRows: MAX_GSC_ROWS$3,
+				maxRows: MAX_GSC_ROWS$4,
 				possiblyTruncated: pageTruncated
 			},
 			propertyDemand: {
@@ -17848,7 +17864,7 @@ async function cannibalReport(input, dependencies = defaultDependencies$10) {
 					invalidRows: analysis.selection.propertyInvalidRows
 				},
 				calls: propertyDemand.calls,
-				maxRows: MAX_GSC_ROWS$3,
+				maxRows: MAX_GSC_ROWS$4,
 				possiblyTruncated: propertyTruncated
 			},
 			completeness
@@ -18156,8 +18172,8 @@ function analyzeDecay(input) {
 }
 //#endregion
 //#region packages/core/dist/analyze/site-diagnostics/decaying.js
-const MAX_GSC_ROWS$2 = 1e5;
-const defaultDependencies$9 = {
+const MAX_GSC_ROWS$3 = 1e5;
+const defaultDependencies$10 = {
 	searchAnalytics: querySearchAnalytics,
 	now: () => /* @__PURE__ */ new Date()
 };
@@ -18168,7 +18184,7 @@ function verdict$3(report) {
 	if (!report.selection.eligibleRows) return "No observed retained query/page declines matched the report filters.";
 	return `${report.selection.returnedRows} of ${report.selection.eligibleRows} observed retained query/page declines returned for review.`;
 }
-async function decayingReport(input, dependencies = defaultDependencies$9) {
+async function decayingReport(input, dependencies = defaultDependencies$10) {
 	if (input.comparison !== void 0 && input.comparison !== "previous-period" && input.comparison !== "year-over-year") throw new SeoError("INVALID_INPUT", "comparison must be previous-period or year-over-year.");
 	if (input.brandTerms && (input.brandTerms.length > 20 || input.brandTerms.some((term) => !term.trim() || term.trim().length > 200))) throw new SeoError("INVALID_INPUT", "brandTerms must contain at most 20 non-empty terms of 200 characters or fewer.");
 	const days = integerOption$2({
@@ -18221,7 +18237,7 @@ async function decayingReport(input, dependencies = defaultDependencies$9) {
 		aggregationType: "auto",
 		type: "web",
 		dataState: "final",
-		maxRows: MAX_GSC_ROWS$2
+		maxRows: MAX_GSC_ROWS$3
 	};
 	const [current, previous] = await Promise.all([dependencies.searchAnalytics(input.site, {
 		...request,
@@ -18244,8 +18260,8 @@ async function decayingReport(input, dependencies = defaultDependencies$9) {
 		brandTerms: input.brandTerms,
 		includeBrand: input.includeBrand
 	});
-	const currentTruncated = current.rowsFetched >= MAX_GSC_ROWS$2;
-	const previousTruncated = previous.rowsFetched >= MAX_GSC_ROWS$2;
+	const currentTruncated = current.rowsFetched >= MAX_GSC_ROWS$3;
+	const previousTruncated = previous.rowsFetched >= MAX_GSC_ROWS$3;
 	const possiblyTruncated = currentTruncated || previousTruncated;
 	const dataStatus = current.rowsFetched === 0 && previous.rowsFetched === 0 ? "empty" : current.rowsFetched === 0 || previous.rowsFetched === 0 || possiblyTruncated || analysis.selection.currentInvalidRows > 0 || analysis.selection.previousInvalidRows > 0 || analysis.selection.currentRowNotRetained > 0 ? "partial" : analysis.selection.eligibleRows === 0 ? "filtered" : "complete";
 	const reportBase = {
@@ -18272,13 +18288,13 @@ async function decayingReport(input, dependencies = defaultDependencies$9) {
 			current: {
 				rowsFetched: current.rowsFetched,
 				calls: current.calls,
-				maxRows: MAX_GSC_ROWS$2,
+				maxRows: MAX_GSC_ROWS$3,
 				possiblyTruncated: currentTruncated
 			},
 			previous: {
 				rowsFetched: previous.rowsFetched,
 				calls: previous.calls,
-				maxRows: MAX_GSC_ROWS$2,
+				maxRows: MAX_GSC_ROWS$3,
 				possiblyTruncated: previousTruncated
 			},
 			completeness: possiblyTruncated ? "possibly-truncated" : "retained-query-rows-only"
@@ -18654,12 +18670,12 @@ function quickWinTemplateSummaries(items) {
 }
 //#endregion
 //#region packages/core/dist/analyze/site-diagnostics/quick-wins.js
-const DEFAULT_DAYS$2 = 28;
-const MAX_DAYS$2 = 548;
+const DEFAULT_DAYS$3 = 28;
+const MAX_DAYS$3 = 548;
 const DEFAULT_VERIFY_LIMIT$1 = 5;
 const MAX_VERIFY_LIMIT = 100;
 const MAX_SOURCE_ROWS$3 = 1e5;
-const defaultDependencies$8 = {
+const defaultDependencies$9 = {
 	searchAnalytics: querySearchAnalytics,
 	fetch: fetchPage,
 	extract: extractPage,
@@ -18678,13 +18694,13 @@ function applyVerification$1(item, coverage) {
 		evidenceRef: `${item.recommendation.evidenceRef} ${coverage.summary}`
 	};
 }
-async function quickWinsReport(input, dependencies = defaultDependencies$8) {
-	const explicitRange = explicitDateRange(input, MAX_DAYS$2);
+async function quickWinsReport(input, dependencies = defaultDependencies$9) {
+	const explicitRange = explicitDateRange(input, MAX_DAYS$3);
 	const days = explicitRange?.days ?? integerOption$2({
 		value: input.days,
-		fallback: DEFAULT_DAYS$2,
+		fallback: DEFAULT_DAYS$3,
 		minimum: 1,
-		maximum: MAX_DAYS$2,
+		maximum: MAX_DAYS$3,
 		label: "Days"
 	});
 	const verifyLimit = integerOption$2({
@@ -19051,11 +19067,11 @@ function analyzeStrikingDistanceRows(input) {
 }
 //#endregion
 //#region packages/core/dist/analyze/striking-distance.js
-const DEFAULT_DAYS$1 = 28;
-const MAX_DAYS$1 = 548;
+const DEFAULT_DAYS$2 = 28;
+const MAX_DAYS$2 = 548;
 const DEFAULT_VERIFY_LIMIT = 5;
 const MAX_SOURCE_ROWS$2 = 1e5;
-const defaultDependencies$7 = {
+const defaultDependencies$8 = {
 	searchAnalytics: querySearchAnalytics,
 	verifyContent: verifyQueryContent,
 	now: () => /* @__PURE__ */ new Date()
@@ -19065,8 +19081,8 @@ function boundedInteger$3(value, fallback, minimum, maximum) {
 	return Math.min(maximum, Math.max(minimum, Math.floor(value)));
 }
 function reportDays(value) {
-	if (value === void 0) return DEFAULT_DAYS$1;
-	if (!Number.isInteger(value) || value < 1 || value > MAX_DAYS$1) throw new SeoError("INVALID_INPUT", `Days must be a whole number between 1 and ${MAX_DAYS$1}.`);
+	if (value === void 0) return DEFAULT_DAYS$2;
+	if (!Number.isInteger(value) || value < 1 || value > MAX_DAYS$2) throw new SeoError("INVALID_INPUT", `Days must be a whole number between 1 and ${MAX_DAYS$2}.`);
 	return value;
 }
 function dateRange(days, now) {
@@ -19105,7 +19121,7 @@ function verdict$2(analysis) {
 	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.`;
 }
-async function strikingDistance(input, dependencies = defaultDependencies$7) {
+async function strikingDistance(input, dependencies = defaultDependencies$8) {
 	const days = reportDays(input.days);
 	const generatedAt = dependencies.now().toISOString();
 	const range = dateRange(days, new Date(generatedAt));
@@ -19952,7 +19968,7 @@ function emptyQuickWins(input) {
 		warnings: []
 	};
 }
-const defaultDependencies$6 = {
+const defaultDependencies$7 = {
 	trafficAnomaly,
 	updateCorrelation,
 	segmentImpact,
@@ -19963,7 +19979,7 @@ const defaultDependencies$6 = {
 };
 async function diagnoseProperty(input, dependencies = {}) {
 	const providers = {
-		...defaultDependencies$6,
+		...defaultDependencies$7,
 		...dependencies
 	};
 	const limit = input.limit ?? 10;
@@ -20827,6 +20843,42 @@ async function providerRequestJson(input) {
 	return parsed.data;
 }
 //#endregion
+//#region packages/core/dist/providers/dataforseo/account-pricing.js
+function unitPrice(components) {
+	const prices = components ?? [];
+	const total = (type) => {
+		const matching = prices.filter((item) => item.cost_type === type);
+		return matching.length ? matching.reduce((sum, item) => sum + Math.round(item.cost * 1e6), 0) : prices.length ? 0 : null;
+	};
+	return {
+		perRequestMicros: total("per_request"),
+		perResultMicros: total("per_result")
+	};
+}
+function dataForSeoAccountPrices(account) {
+	return {
+		keywordOverviewPrice: unitPrice(account.price?.dataforseo_labs?.keyword_overview?.live?.priority_normal),
+		keywordDiscoveryPrices: {
+			ideas: unitPrice(account.price?.dataforseo_labs?.keyword_ideas?.live?.priority_normal),
+			related: unitPrice(account.price?.dataforseo_labs?.related_keywords?.live?.priority_normal),
+			suggestions: unitPrice(account.price?.dataforseo_labs?.keyword_suggestions?.live?.priority_normal)
+		},
+		domainResearchPrices: {
+			domainOverview: unitPrice(account.price?.dataforseo_labs?.domain_rank_overview?.live?.priority_normal),
+			rankedKeywords: unitPrice(account.price?.dataforseo_labs?.ranked_keywords?.live?.priority_normal),
+			rankingPages: unitPrice(account.price?.dataforseo_labs?.relevant_pages?.live?.priority_normal),
+			serpCompetitors: unitPrice(account.price?.dataforseo_labs?.serp_competitors?.live?.priority_normal)
+		},
+		linkPrices: {
+			summary: unitPrice(account.price?.backlinks?.summary?.live?.priority_normal),
+			backlinks: unitPrice(account.price?.backlinks?.backlinks?.live?.priority_normal),
+			referringDomains: unitPrice(account.price?.backlinks?.referring_domains?.live?.priority_normal)
+		},
+		serpLiveAdvancedPrice: unitPrice(account.price?.serp?.live?.advanced?.priority_normal),
+		serpTaskPostPrice: unitPrice(account.price?.serp?.task_post?.priority_normal)
+	};
+}
+//#endregion
 //#region packages/core/dist/providers/dataforseo/account-schema.js
 const userDataMoneySchema = z.object({
 	total: z.number().finite().nonnegative().optional(),
@@ -20844,6 +20896,11 @@ const priceComponentSchema = z.object({
 const normalPriorityPriceSchema = z.object({ priority_normal: z.array(priceComponentSchema).max(20).optional() }).passthrough();
 const livePriceSchema = z.object({ live: normalPriorityPriceSchema.optional() }).passthrough();
 const userDataPriceSchema = z.object({
+	backlinks: z.object({
+		summary: livePriceSchema.optional(),
+		backlinks: livePriceSchema.optional(),
+		referring_domains: livePriceSchema.optional()
+	}).passthrough().optional(),
 	dataforseo_labs: z.object({
 		keyword_overview: livePriceSchema.optional(),
 		keyword_ideas: livePriceSchema.optional(),
@@ -20901,7 +20958,7 @@ function discoveryNextCursor(response) {
 //#region packages/core/dist/providers/dataforseo/schema.js
 const MAX_PROVIDER_MONTHLY_SEARCH_ROWS = 120;
 const nullableNumber$1 = z.number().finite().nullable().optional();
-const nullableCount$1 = z.union([z.number().finite(), z.string().trim().min(1)]).nullable().optional();
+const nullableCount$2 = z.union([z.number().finite(), z.string().trim().min(1)]).nullable().optional();
 const monthlySearchSchema$1 = z.object({
 	year: z.number().int(),
 	month: z.number().int(),
@@ -20917,7 +20974,7 @@ const keywordOverviewItemSchema = z.object({
 		last_updated_time: z.string().trim().min(1).nullable().optional()
 	}).nullish(),
 	keyword_properties: z.object({ keyword_difficulty: nullableNumber$1 }).nullish(),
-	serp_info: z.object({ se_results_count: nullableCount$1 }).nullish(),
+	serp_info: z.object({ se_results_count: nullableCount$2 }).nullish(),
 	search_intent_info: z.object({ main_intent: z.enum([
 		"informational",
 		"navigational",
@@ -20990,37 +21047,37 @@ const dataForSeoDiscoveryResponseSchema = z.object({
 //#region packages/core/dist/providers/dataforseo/domain-schema.js
 const nullableNumber = z.number().finite().nullable().optional();
 const nullableNonnegativeNumber = z.number().finite().nonnegative().nullable().optional();
-const nullableCount = z.number().int().nonnegative().nullable().optional();
+const nullableCount$1 = z.number().int().nonnegative().nullable().optional();
 const rankingMetricsSchema = z.object({
-	pos_1: nullableCount,
-	pos_2_3: nullableCount,
-	pos_4_10: nullableCount,
-	pos_11_20: nullableCount,
-	pos_21_30: nullableCount,
-	pos_31_40: nullableCount,
-	pos_41_50: nullableCount,
-	pos_51_60: nullableCount,
-	pos_61_70: nullableCount,
-	pos_71_80: nullableCount,
-	pos_81_90: nullableCount,
-	pos_91_100: nullableCount,
+	pos_1: nullableCount$1,
+	pos_2_3: nullableCount$1,
+	pos_4_10: nullableCount$1,
+	pos_11_20: nullableCount$1,
+	pos_21_30: nullableCount$1,
+	pos_31_40: nullableCount$1,
+	pos_41_50: nullableCount$1,
+	pos_51_60: nullableCount$1,
+	pos_61_70: nullableCount$1,
+	pos_71_80: nullableCount$1,
+	pos_81_90: nullableCount$1,
+	pos_91_100: nullableCount$1,
 	etv: nullableNonnegativeNumber,
-	count: nullableCount,
+	count: nullableCount$1,
 	estimated_paid_traffic_cost: nullableNonnegativeNumber,
-	is_new: nullableCount,
-	is_up: nullableCount,
-	is_down: nullableCount,
-	is_lost: nullableCount
+	is_new: nullableCount$1,
+	is_up: nullableCount$1,
+	is_down: nullableCount$1,
+	is_lost: nullableCount$1
 }).passthrough();
 const metricsSchema = z.object({ organic: rankingMetricsSchema.nullable().optional() }).passthrough();
-const paidResponseSchema = z.object({
+const paidResponseSchema$1 = 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()
 }).passthrough();
-const taskFields = {
+const taskFields$1 = {
 	id: z.string().trim().min(1).max(100).optional(),
 	status_code: z.number().int(),
 	status_message: z.string().max(1e3),
@@ -21040,8 +21097,8 @@ const overviewResultSchema = z.object({
 	items_count: z.number().int().nonnegative().optional(),
 	items: z.array(overviewItemSchema).max(1e3).nullable().optional()
 }).passthrough();
-const dataForSeoDomainOverviewResponseSchema = paidResponseSchema.extend({ tasks: z.array(z.object({
-	...taskFields,
+const dataForSeoDomainOverviewResponseSchema = paidResponseSchema$1.extend({ tasks: z.array(z.object({
+	...taskFields$1,
 	result: z.array(overviewResultSchema).max(10).nullable().optional()
 }).passthrough()).max(10) });
 const rankedSerpItemSchema = z.object({
@@ -21061,8 +21118,8 @@ const rankedKeywordsResultSchema = z.object({
 	items_count: z.number().int().nonnegative().optional(),
 	items: z.array(rankedKeywordItemSchema).max(1e3).nullable().optional()
 }).passthrough();
-const dataForSeoRankedKeywordsResponseSchema = paidResponseSchema.extend({ tasks: z.array(z.object({
-	...taskFields,
+const dataForSeoRankedKeywordsResponseSchema = paidResponseSchema$1.extend({ tasks: z.array(z.object({
+	...taskFields$1,
 	result: z.array(rankedKeywordsResultSchema).max(10).nullable().optional()
 }).passthrough()).max(10) });
 const rankingPageItemSchema = z.object({
@@ -21075,8 +21132,8 @@ const rankingPagesResultSchema = z.object({
 	items_count: z.number().int().nonnegative().optional(),
 	items: z.array(rankingPageItemSchema).max(1e3).nullable().optional()
 }).passthrough();
-const dataForSeoRankingPagesResponseSchema = paidResponseSchema.extend({ tasks: z.array(z.object({
-	...taskFields,
+const dataForSeoRankingPagesResponseSchema = paidResponseSchema$1.extend({ tasks: z.array(z.object({
+	...taskFields$1,
 	result: z.array(rankingPagesResultSchema).max(10).nullable().optional()
 }).passthrough()).max(10) });
 const competitorItemSchema = z.object({
@@ -21084,9 +21141,9 @@ const competitorItemSchema = z.object({
 	avg_position: nullableNumber,
 	median_position: nullableNumber,
 	etv: nullableNonnegativeNumber,
-	keywords_count: nullableCount,
+	keywords_count: nullableCount$1,
 	visibility: nullableNonnegativeNumber,
-	relevant_serp_items: nullableCount,
+	relevant_serp_items: nullableCount$1,
 	keywords_positions: z.record(z.string().trim().min(1).max(80), z.array(z.number().int().positive()).max(100)).nullable().optional()
 }).passthrough();
 const competitorsResultSchema = z.object({
@@ -21095,8 +21152,8 @@ const competitorsResultSchema = z.object({
 	items_count: z.number().int().nonnegative().optional(),
 	items: z.array(competitorItemSchema).max(1e3).nullable().optional()
 }).passthrough();
-const dataForSeoSerpCompetitorsResponseSchema = paidResponseSchema.extend({ tasks: z.array(z.object({
-	...taskFields,
+const dataForSeoSerpCompetitorsResponseSchema = paidResponseSchema$1.extend({ tasks: z.array(z.object({
+	...taskFields$1,
 	result: z.array(competitorsResultSchema).max(10).nullable().optional()
 }).passthrough()).max(10) });
 const DOMAIN_OVERVIEW_PATH = "v3/dataforseo_labs/google/domain_rank_overview/live";
@@ -21286,6 +21343,209 @@ function serpCompetitorsPaidRequest(input, ttlMs) {
 	};
 }
 //#endregion
+//#region packages/core/dist/providers/dataforseo/link-schema.js
+const nullableCount = z.number().int().nonnegative().nullable().optional();
+const nullableScore = z.number().finite().nonnegative().nullable().optional();
+const nullableText = z.string().max(2e4).nullable().optional();
+const paidResponseSchema = 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()
+}).passthrough();
+const taskFields = {
+	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()
+};
+const dataForSeoLinkSummaryItemSchema = z.object({
+	target: z.string().trim().min(1).max(2048).optional(),
+	rank: nullableScore,
+	backlinks: nullableCount,
+	referring_pages: nullableCount,
+	referring_domains: nullableCount,
+	broken_backlinks: nullableCount,
+	broken_pages: nullableCount,
+	backlinks_spam_score: nullableScore,
+	info: z.object({ target_spam_score: nullableScore }).passthrough().nullable().optional()
+}).passthrough();
+const dataForSeoLinkSummaryResponseSchema = paidResponseSchema.extend({ tasks: z.array(z.object({
+	...taskFields,
+	result: z.array(dataForSeoLinkSummaryItemSchema).max(10).nullable().optional()
+}).passthrough()).max(10) });
+const dataForSeoBacklinkItemSchema = z.object({
+	domain_from: nullableText,
+	url_from: nullableText,
+	url_to: nullableText,
+	anchor: nullableText,
+	item_type: z.string().max(100).nullable().optional(),
+	dofollow: z.boolean().nullable().optional(),
+	rank: nullableScore,
+	domain_from_rank: nullableScore,
+	page_from_rank: nullableScore,
+	backlink_spam_score: nullableScore,
+	backlinks_spam_score: nullableScore,
+	first_seen: z.string().max(100).nullable().optional(),
+	last_visited: z.string().max(100).nullable().optional(),
+	lost_date: z.string().max(100).nullable().optional(),
+	is_lost: z.boolean().nullable().optional(),
+	is_indirect_link: z.boolean().nullable().optional(),
+	links_count: nullableCount,
+	group_count: nullableCount,
+	rel_attributes: z.array(z.string().trim().min(1).max(100)).max(100).nullable().optional(),
+	attributes: z.array(z.string().trim().min(1).max(100)).max(100).nullable().optional()
+}).passthrough();
+const backlinkResultSchema = z.object({
+	target: z.string().trim().min(1).max(2048).optional(),
+	total_count: nullableCount,
+	items_count: nullableCount,
+	search_after_token: z.string().max(2e4).nullable().optional(),
+	items: z.array(dataForSeoBacklinkItemSchema).max(1e3).nullable().optional()
+}).passthrough();
+const dataForSeoBacklinksResponseSchema = paidResponseSchema.extend({ tasks: z.array(z.object({
+	...taskFields,
+	result: z.array(backlinkResultSchema).max(10).nullable().optional()
+}).passthrough()).max(10) });
+const dataForSeoReferringDomainItemSchema = z.object({
+	domain: z.string().trim().min(1).max(2048).nullable().optional(),
+	backlinks: nullableCount,
+	referring_pages: nullableCount,
+	broken_backlinks: nullableCount,
+	broken_pages: nullableCount,
+	rank: nullableScore,
+	backlinks_spam_score: nullableScore,
+	first_seen: z.string().max(100).nullable().optional()
+}).passthrough();
+const referringDomainsResultSchema = z.object({
+	target: z.string().trim().min(1).max(2048).optional(),
+	total_count: nullableCount,
+	items_count: nullableCount,
+	items: z.array(dataForSeoReferringDomainItemSchema).max(1e3).nullable().optional()
+}).passthrough();
+const dataForSeoReferringDomainsResponseSchema = paidResponseSchema.extend({ tasks: z.array(z.object({
+	...taskFields,
+	result: z.array(referringDomainsResultSchema).max(10).nullable().optional()
+}).passthrough()).max(10) });
+const MAX_LINK_ROWS$1 = 1e3;
+const MAX_LINK_OFFSET = 2e4;
+const LINK_ENDPOINTS = {
+	summary: "v3/backlinks/summary/live",
+	backlinks: "v3/backlinks/backlinks/live",
+	referringDomains: "v3/backlinks/referring_domains/live"
+};
+function resultRows(response) {
+	return response.tasks.reduce((taskTotal, task) => taskTotal + (task.result ?? []).reduce((resultTotal, result) => resultTotal + (result.items?.length ?? 0), 0), 0);
+}
+function summaryRows(response) {
+	return response.tasks.reduce((total, task) => total + (task.result?.length ?? 0), 0);
+}
+function commonRequest(input) {
+	return {
+		target: input.target,
+		include_subdomains: input.scope === "domain" ? input.includeSubdomains : false,
+		include_indirect_links: true,
+		exclude_internal_backlinks: true,
+		backlinks_status_type: "live",
+		rank_scale: "one_hundred"
+	};
+}
+function validatePage(input) {
+	if (!Number.isSafeInteger(input.limit) || input.limit < 1 || input.limit > 1e3) throw new ProviderError({
+		provider: "dataforseo",
+		operation: input.operation,
+		code: "configuration",
+		message: `Link row limit must be from 1 to ${MAX_LINK_ROWS$1}.`
+	});
+	if (!Number.isSafeInteger(input.offset) || input.offset < 0 || input.offset > 2e4) throw new ProviderError({
+		provider: "dataforseo",
+		operation: input.operation,
+		code: "configuration",
+		message: `Link row offset must be from 0 to ${MAX_LINK_OFFSET}.`
+	});
+}
+function linkSummaryPaidRequest(input, ttlMs) {
+	return {
+		operation: "link-summary",
+		capability: "link-summary",
+		endpoint: LINK_ENDPOINTS.summary,
+		request: commonRequest(input),
+		schema: dataForSeoLinkSummaryResponseSchema,
+		requestedRows: 1,
+		price: (account) => account.linkPrices.summary,
+		context: input.context,
+		ttlMs,
+		refresh: input.refresh,
+		rowCount: summaryRows
+	};
+}
+function backlinksPaidRequest(input, ttlMs) {
+	validatePage({
+		limit: input.limit,
+		offset: input.offset,
+		operation: "backlinks"
+	});
+	if (input.orderBy.length < 1 || input.orderBy.length > 3) throw new ProviderError({
+		provider: "dataforseo",
+		operation: "backlinks",
+		code: "configuration",
+		message: "Backlink rows need from 1 to 3 sort rules."
+	});
+	return {
+		operation: "backlinks",
+		capability: "backlinks",
+		endpoint: LINK_ENDPOINTS.backlinks,
+		request: {
+			...commonRequest(input),
+			mode: input.mode,
+			backlinks_status_type: input.status,
+			limit: input.limit,
+			offset: input.offset,
+			order_by: input.orderBy
+		},
+		schema: dataForSeoBacklinksResponseSchema,
+		requestedRows: input.limit,
+		price: (account) => account.linkPrices.backlinks,
+		context: input.context,
+		ttlMs,
+		refresh: input.refresh,
+		rowCount: resultRows
+	};
+}
+function referringDomainsPaidRequest(input, ttlMs) {
+	validatePage({
+		limit: input.limit,
+		offset: input.offset,
+		operation: "referring-domains"
+	});
+	if (input.orderBy.length < 1 || input.orderBy.length > 3) throw new ProviderError({
+		provider: "dataforseo",
+		operation: "referring-domains",
+		code: "configuration",
+		message: "Referring-domain rows need from 1 to 3 sort rules."
+	});
+	return {
+		operation: "referring-domains",
+		capability: "referring-domains",
+		endpoint: LINK_ENDPOINTS.referringDomains,
+		request: {
+			...commonRequest(input),
+			limit: input.limit,
+			offset: input.offset,
+			order_by: input.orderBy
+		},
+		schema: dataForSeoReferringDomainsResponseSchema,
+		requestedRows: input.limit,
+		price: (account) => account.linkPrices.referringDomains,
+		context: input.context,
+		ttlMs,
+		refresh: input.refresh,
+		rowCount: resultRows
+	};
+}
+//#endregion
 //#region packages/core/dist/providers/dataforseo/paid-request.js
 function usdToMicros(value) {
 	if (value === void 0) return null;
@@ -21809,41 +22069,6 @@ const MAX_KEYWORD_CHARACTERS = 80;
 const MAX_KEYWORD_WORDS = 10;
 const MAX_DISCOVERY_SEEDS$1 = 5;
 const MAX_DISCOVERY_ROWS$1 = 100;
-function unitPrice(components) {
-	const prices = components ?? [];
-	const total = (type) => {
-		const matching = prices.filter((item) => item.cost_type === type);
-		return matching.length ? matching.reduce((sum, item) => sum + Math.round(item.cost * 1e6), 0) : prices.length ? 0 : null;
-	};
-	return {
-		perRequestMicros: total("per_request"),
-		perResultMicros: total("per_result")
-	};
-}
-function keywordOverviewPrice(account) {
-	return unitPrice(account.price?.dataforseo_labs?.keyword_overview?.live?.priority_normal);
-}
-function keywordDiscoveryPrices(account) {
-	return {
-		ideas: unitPrice(account.price?.dataforseo_labs?.keyword_ideas?.live?.priority_normal),
-		related: unitPrice(account.price?.dataforseo_labs?.related_keywords?.live?.priority_normal),
-		suggestions: unitPrice(account.price?.dataforseo_labs?.keyword_suggestions?.live?.priority_normal)
-	};
-}
-function domainResearchPrices(account) {
-	return {
-		domainOverview: unitPrice(account.price?.dataforseo_labs?.domain_rank_overview?.live?.priority_normal),
-		rankedKeywords: unitPrice(account.price?.dataforseo_labs?.ranked_keywords?.live?.priority_normal),
-		rankingPages: unitPrice(account.price?.dataforseo_labs?.relevant_pages?.live?.priority_normal),
-		serpCompetitors: unitPrice(account.price?.dataforseo_labs?.serp_competitors?.live?.priority_normal)
-	};
-}
-function serpLiveAdvancedPrice(account) {
-	return unitPrice(account.price?.serp?.live?.advanced?.priority_normal);
-}
-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);
 }
@@ -21863,6 +22088,7 @@ var DataForSeoClient = class {
 	serpTtlMs;
 	accountPricingTtlMs;
 	domainResearchTtlMs;
+	linkTtlMs;
 	spendLimits;
 	accountPricing;
 	accountPricingRequest;
@@ -21879,6 +22105,7 @@ var DataForSeoClient = class {
 		this.serpTtlMs = options.serpTtlMs ?? DEFAULT_SERP_TTL_MS;
 		this.accountPricingTtlMs = options.accountPricingTtlMs ?? DEFAULT_ACCOUNT_PRICING_TTL_MS;
 		this.domainResearchTtlMs = options.domainResearchTtlMs ?? 6048e5;
+		this.linkTtlMs = options.linkTtlMs ?? 864e5;
 		this.spendLimits = options.spendLimits;
 	}
 	async getCredentials(operation) {
@@ -21961,11 +22188,7 @@ var DataForSeoClient = class {
 			accountDailySpendMicros: dataForSeoUsdToMicros(account.money?.statistics?.day?.total),
 			accountDailySpendPeriod: account.money?.statistics?.day?.value ?? null,
 			accountDailyLimitMicros: dataForSeoUsdToMicros(account.money?.limits?.day?.total),
-			keywordOverviewPrice: keywordOverviewPrice(account),
-			keywordDiscoveryPrices: keywordDiscoveryPrices(account),
-			domainResearchPrices: domainResearchPrices(account),
-			serpLiveAdvancedPrice: serpLiveAdvancedPrice(account),
-			serpTaskPostPrice: serpTaskPostPrice(account),
+			...dataForSeoAccountPrices(account),
 			backlinksSubscriptionExpiresAt: account.backlinks_subscription_expiry_date ?? null,
 			aiMentionsSubscriptionExpiresAt: account.llm_mentions_subscription_expiry_date ?? null,
 			apiVersion: response.version ?? null,
@@ -22028,6 +22251,15 @@ var DataForSeoClient = class {
 	async serpCompetitors(input) {
 		return this.paidPost(serpCompetitorsPaidRequest(input, this.domainResearchTtlMs));
 	}
+	async linkSummary(input) {
+		return this.paidPost(linkSummaryPaidRequest(input, this.linkTtlMs));
+	}
+	async backlinks(input) {
+		return this.paidPost(backlinksPaidRequest(input, this.linkTtlMs));
+	}
+	async referringDomains(input) {
+		return this.paidPost(referringDomainsPaidRequest(input, this.linkTtlMs));
+	}
 	async keywordOverview(input) {
 		const keywords = input.keywords.map((keyword) => keyword.trim());
 		if (keywords.length < 1 || keywords.length > MAX_KEYWORDS_PER_OVERVIEW_REQUEST || keywords.some((keyword) => keyword.length < 1 || keyword.length > MAX_KEYWORD_CHARACTERS || keyword.split(/\s+/u).length > MAX_KEYWORD_WORDS)) throw new ProviderError({
@@ -22371,20 +22603,20 @@ function compareCodepoints$3(left, right) {
 function normalizedKeyword$2(keyword) {
 	return keyword.trim().replace(/\s+/gu, " ").toLowerCase();
 }
-function missing$1(field) {
+function missing$2(field) {
 	return unavailableValue("missing", `DataForSEO omitted ${field}.`);
 }
 function numericValue(values, field, valid) {
 	const present = values.filter((value) => value !== null && value !== void 0);
-	if (present.length === 0) return missing$1(field);
+	if (present.length === 0) return missing$2(field);
 	const numbers = present.filter((value) => typeof value === "number" && valid(value));
 	if (numbers.length !== present.length) return unavailableValue("invalid", `DataForSEO returned an invalid ${field}.`);
 	const unique = [...new Set(numbers)];
 	return unique.length === 1 ? observedValue(unique[0]) : unavailableValue("invalid", `DataForSEO returned conflicting ${field} values.`);
 }
-function stringValue(values, field, normalize) {
+function stringValue$1(values, field, normalize) {
 	const present = values.filter((value) => value !== null && value !== void 0);
-	if (present.length === 0) return missing$1(field);
+	if (present.length === 0) return missing$2(field);
 	const strings = present.flatMap((value) => {
 		if (typeof value !== "string") return [];
 		const normalized = normalize(value);
@@ -22396,7 +22628,7 @@ function stringValue(values, field, normalize) {
 }
 function monthlySearchesValue(rows) {
 	const histories = rows.map((row) => row.keyword_info?.monthly_searches).filter((value) => value !== null && value !== void 0);
-	if (histories.length === 0) return missing$1("monthlySearches");
+	if (histories.length === 0) return missing$2("monthlySearches");
 	const byMonth = /* @__PURE__ */ new Map();
 	let invalid = false;
 	for (const history of histories) for (const item of history) {
@@ -22429,27 +22661,27 @@ function resultCountValues(rows) {
 function metricForKeyword(keyword, rows) {
 	if (rows.length === 0) return {
 		keyword,
-		monthlySearchVolume: missing$1("monthlySearchVolume"),
-		monthlySearches: missing$1("monthlySearches"),
-		searchVolumeUpdatedAt: missing$1("searchVolumeUpdatedAt"),
-		cpcUsd: missing$1("cpcUsd"),
-		paidCompetition: missing$1("paidCompetition"),
-		keywordDifficulty: missing$1("keywordDifficulty"),
-		intent: missing$1("intent"),
-		resultCount: missing$1("resultCount")
+		monthlySearchVolume: missing$2("monthlySearchVolume"),
+		monthlySearches: missing$2("monthlySearches"),
+		searchVolumeUpdatedAt: missing$2("searchVolumeUpdatedAt"),
+		cpcUsd: missing$2("cpcUsd"),
+		paidCompetition: missing$2("paidCompetition"),
+		keywordDifficulty: missing$2("keywordDifficulty"),
+		intent: missing$2("intent"),
+		resultCount: missing$2("resultCount")
 	};
 	return {
 		keyword,
 		monthlySearchVolume: numericValue(rows.map((row) => row.keyword_info?.search_volume), "monthlySearchVolume", (value) => Number.isSafeInteger(value) && value >= 0),
 		monthlySearches: monthlySearchesValue(rows),
-		searchVolumeUpdatedAt: stringValue(rows.map((row) => row.keyword_info?.last_updated_time), "searchVolumeUpdatedAt", (value) => {
+		searchVolumeUpdatedAt: stringValue$1(rows.map((row) => row.keyword_info?.last_updated_time), "searchVolumeUpdatedAt", (value) => {
 			const timestamp = Date.parse(value);
 			return Number.isFinite(timestamp) ? new Date(timestamp).toISOString() : null;
 		}),
 		cpcUsd: numericValue(rows.map((row) => row.keyword_info?.cpc), "cpcUsd", (value) => Number.isFinite(value) && value >= 0),
 		paidCompetition: numericValue(rows.map((row) => row.keyword_info?.competition), "paidCompetition", (value) => Number.isFinite(value) && value >= 0 && value <= 1),
 		keywordDifficulty: numericValue(rows.map((row) => row.keyword_properties?.keyword_difficulty), "keywordDifficulty", (value) => Number.isFinite(value) && value >= 0 && value <= 100),
-		intent: stringValue(rows.map((row) => row.search_intent_info?.main_intent), "intent", (value) => value.trim().toLowerCase() || null),
+		intent: stringValue$1(rows.map((row) => row.search_intent_info?.main_intent), "intent", (value) => value.trim().toLowerCase() || null),
 		resultCount: numericValue(resultCountValues(rows), "resultCount", (value) => Number.isSafeInteger(value) && value >= 0)
 	};
 }
@@ -22502,21 +22734,21 @@ const COMPETITOR_RESULT_TYPES = /* @__PURE__ */ new Set([
 	"featured_snippet",
 	"local_pack"
 ]);
-function missing(field) {
+function missing$1(field) {
 	return unavailableValue("missing", `DataForSEO omitted ${field}.`);
 }
-function numberValue(value, field) {
-	return value === null || value === void 0 ? missing(field) : observedValue(value);
+function numberValue$1(value, field) {
+	return value === null || value === void 0 ? missing$1(field) : observedValue(value);
 }
 function countValue(value, field) {
-	return numberValue(value, field);
+	return numberValue$1(value, field);
 }
 function sumBuckets(metrics, fields, label) {
 	const values = fields.map((field) => metrics[field]);
-	return values.some((value) => value === null || value === void 0) ? missing(label) : observedValue(values.reduce((sum, value) => sum + (typeof value === "number" ? value : 0), 0));
+	return values.some((value) => value === null || value === void 0) ? missing$1(label) : observedValue(values.reduce((sum, value) => sum + (typeof value === "number" ? value : 0), 0));
 }
 function rankingDistribution(metrics) {
-	if (!metrics) return missing("organic ranking distribution");
+	if (!metrics) return missing$1("organic ranking distribution");
 	const buckets = {
 		first: sumBuckets(metrics, ["pos_1"], "position 1 rankings"),
 		top3: sumBuckets(metrics, ["pos_1", "pos_2_3"], "top 3 rankings"),
@@ -22567,9 +22799,9 @@ function rankingDistribution(metrics) {
 }
 function organicFootprint(metrics) {
 	return {
-		estimatedMonthlyTraffic: numberValue(metrics?.etv, "estimated organic monthly traffic"),
+		estimatedMonthlyTraffic: numberValue$1(metrics?.etv, "estimated organic monthly traffic"),
 		rankedKeywords: countValue(metrics?.count, "ranked organic keywords"),
-		estimatedMonthlyTrafficCostUsd: numberValue(metrics?.estimated_paid_traffic_cost, "estimated organic traffic cost"),
+		estimatedMonthlyTrafficCostUsd: numberValue$1(metrics?.estimated_paid_traffic_cost, "estimated organic traffic cost"),
 		rankings: rankingDistribution(metrics),
 		newRankings: countValue(metrics?.is_new, "new rankings"),
 		improvedRankings: countValue(metrics?.is_up, "improved rankings"),
@@ -22624,7 +22856,7 @@ function researchMarket(input, operation) {
 	});
 	return parsed;
 }
-function rowLimit(limit, offset = 0) {
+function rowLimit$1(limit, offset = 0) {
 	if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1e3) throw new ProviderError({
 		provider: "dataforseo",
 		operation: "domain-research",
@@ -22648,7 +22880,7 @@ function resultTypes(input, allowed) {
 	});
 	return normalized;
 }
-function safeUrl$1(value) {
+function safeUrl$2(value) {
 	if (!value) return null;
 	try {
 		const url = new URL(value);
@@ -22668,7 +22900,7 @@ function dedupeBy(rows, key) {
 	}
 	return [...grouped.entries()].sort(([left], [right]) => compareCodepoints$3(left, right)).map(([, matches]) => [...matches].sort((left, right) => compareCodepoints$3(JSON.stringify(left), JSON.stringify(right)))[0]);
 }
-function observedNumber(value) {
+function observedNumber$1(value) {
 	return value.state === "observed" ? value.value : -1;
 }
 function duplicateWarning(available, retained, label) {
@@ -22679,7 +22911,7 @@ function duplicateWarning(available, retained, label) {
 		message: `${duplicates} duplicate ${label} row${duplicates === 1 ? "" : "s"} were collapsed deterministically.`
 	}] : [];
 }
-function totalRows(values) {
+function totalRows$1(values) {
 	const present = values.filter((value) => value !== null && value !== void 0);
 	return present.length ? Math.max(...present) : null;
 }
@@ -22695,7 +22927,7 @@ function coverage(input) {
 		nextCursor: hasMore ? String(input.offset + input.returnedRows) : null
 	};
 }
-function requestContext(reportId, supplied) {
+function requestContext$1(reportId, supplied) {
 	return supplied ?? {
 		reportId,
 		reportRunId: randomUUID()
@@ -22744,7 +22976,7 @@ async function dataForSeoDomainOverview(client, input) {
 		languageCode: market.languageCode.split("-")[0],
 		...location,
 		refresh: input.refresh,
-		context: requestContext("domain-overview", input.context)
+		context: requestContext$1("domain-overview", input.context)
 	});
 	const results = snapshot.response.tasks.flatMap((task) => task.result ?? []);
 	const matchingResult = results.find((row) => !row.target || domain(row.target) === target);
@@ -22836,7 +23068,7 @@ async function dataForSeoRankedKeywords(client, input) {
 	const market = researchMarket(input.market, "ranked-keywords");
 	const target = rankedTarget(input.target);
 	const offset = input.offset ?? 0;
-	rowLimit(input.limit, offset);
+	rowLimit$1(input.limit, offset);
 	const types = resultTypes(input.resultTypes, RANKED_RESULT_TYPES);
 	const excluded = excludedTerms(input);
 	const requestedFilters = filters$1(input, excluded);
@@ -22856,7 +23088,7 @@ async function dataForSeoRankedKeywords(client, input) {
 		limit: input.limit,
 		offset,
 		refresh: input.refresh,
-		context: requestContext("ranked-keywords", input.context)
+		context: requestContext$1("ranked-keywords", input.context)
 	});
 	const responseResults = snapshot.response.tasks.flatMap((task) => task.result ?? []);
 	const rawRows = responseResults.flatMap((result) => result.items ?? []);
@@ -22865,7 +23097,7 @@ async function dataForSeoRankedKeywords(client, input) {
 		const keywordData = row.keyword_data;
 		const serp = row.ranked_serp_element?.serp_item;
 		const keyword = keywordData?.keyword ? normalizedKeyword$2(keywordData.keyword) : "";
-		const url = safeUrl$1(serp?.url);
+		const url = safeUrl$2(serp?.url);
 		if (!keywordData || !keyword || !url || !serp?.rank_group || !serp.rank_absolute || !serp.type) {
 			invalidRows += 1;
 			return [];
@@ -22876,11 +23108,11 @@ async function dataForSeoRankedKeywords(client, input) {
 			rankGroup: serp.rank_group,
 			rankAbsolute: serp.rank_absolute,
 			resultType: serp.type,
-			estimatedMonthlyTraffic: numberValue(serp.etv, "estimated keyword traffic")
+			estimatedMonthlyTraffic: numberValue$1(serp.etv, "estimated keyword traffic")
 		}];
 	});
-	const rows = dedupeBy(mappedRows, (row) => `${row.keyword}\0${row.url}\0${row.resultType}`).sort((left, right) => observedNumber(right.monthlySearchVolume) - observedNumber(left.monthlySearchVolume) || left.rankGroup - right.rankGroup || compareCodepoints$3(left.keyword, right.keyword) || compareCodepoints$3(left.url, right.url));
-	const providerTotalRows = totalRows(responseResults.map((result) => result.total_count));
+	const rows = dedupeBy(mappedRows, (row) => `${row.keyword}\0${row.url}\0${row.resultType}`).sort((left, right) => observedNumber$1(right.monthlySearchVolume) - observedNumber$1(left.monthlySearchVolume) || left.rankGroup - right.rankGroup || compareCodepoints$3(left.keyword, right.keyword) || compareCodepoints$3(left.url, right.url));
+	const providerTotalRows = totalRows$1(responseResults.map((result) => result.total_count));
 	return domainEvidence({
 		capability: "ranked-keywords",
 		data: {
@@ -22953,7 +23185,7 @@ async function dataForSeoRankingPages(client, input) {
 	const market = researchMarket(input.market, "ranking-pages");
 	const target = domain(input.domain);
 	const offset = input.offset ?? 0;
-	rowLimit(input.limit, offset);
+	rowLimit$1(input.limit, offset);
 	const requestedFilters = filters(input);
 	const orderBy = ["metrics.organic.etv,desc", "page_address,asc"];
 	const snapshot = await client.rankingPages({
@@ -22965,13 +23197,13 @@ async function dataForSeoRankingPages(client, input) {
 		limit: input.limit,
 		offset,
 		refresh: input.refresh,
-		context: requestContext("ranking-pages", input.context)
+		context: requestContext$1("ranking-pages", input.context)
 	});
 	const responseResults = snapshot.response.tasks.flatMap((task) => task.result ?? []);
 	const rawRows = responseResults.flatMap((result) => result.items ?? []);
 	let invalidRows = 0;
 	const mappedRows = rawRows.flatMap((row) => {
-		const url = safeUrl$1(row.page_address);
+		const url = safeUrl$2(row.page_address);
 		if (!url) {
 			invalidRows += 1;
 			return [];
@@ -22981,8 +23213,8 @@ async function dataForSeoRankingPages(client, input) {
 			organic: organicFootprint(row.metrics?.organic)
 		}];
 	});
-	const rows = dedupeBy(mappedRows, (row) => row.url).sort((left, right) => observedNumber(right.organic.estimatedMonthlyTraffic) - observedNumber(left.organic.estimatedMonthlyTraffic) || compareCodepoints$3(left.url, right.url));
-	const providerTotalRows = totalRows(responseResults.map((result) => result.total_count));
+	const rows = dedupeBy(mappedRows, (row) => row.url).sort((left, right) => observedNumber$1(right.organic.estimatedMonthlyTraffic) - observedNumber$1(left.organic.estimatedMonthlyTraffic) || compareCodepoints$3(left.url, right.url));
+	const providerTotalRows = totalRows$1(responseResults.map((result) => result.total_count));
 	return domainEvidence({
 		capability: "relevant-pages",
 		data: {
@@ -23027,7 +23259,7 @@ function keywords(input) {
 async function dataForSeoSerpCompetitors(client, input) {
 	const market = researchMarket(input.market, "serp-competitors");
 	const offset = input.offset ?? 0;
-	rowLimit(input.limit, offset);
+	rowLimit$1(input.limit, offset);
 	const requestedKeywords = keywords(input.keywords);
 	const types = resultTypes(input.resultTypes, COMPETITOR_RESULT_TYPES);
 	const orderBy = [
@@ -23045,7 +23277,7 @@ async function dataForSeoSerpCompetitors(client, input) {
 		limit: input.limit,
 		offset,
 		refresh: input.refresh,
-		context: requestContext("serp-competitors", input.context)
+		context: requestContext$1("serp-competitors", input.context)
 	});
 	const responseResults = snapshot.response.tasks.flatMap((task) => task.result ?? []);
 	const rawRows = responseResults.flatMap((result) => result.items ?? []);
@@ -23068,16 +23300,16 @@ async function dataForSeoSerpCompetitors(client, input) {
 		return [{
 			domain: normalizedDomain,
 			matchedKeywords: row.keywords_count,
-			averagePosition: numberValue(row.avg_position, "average position"),
-			medianPosition: numberValue(row.median_position, "median position"),
-			visibility: numberValue(row.visibility, "visibility"),
-			estimatedMonthlyTraffic: numberValue(row.etv, "estimated monthly traffic"),
+			averagePosition: numberValue$1(row.avg_position, "average position"),
+			medianPosition: numberValue$1(row.median_position, "median position"),
+			visibility: numberValue$1(row.visibility, "visibility"),
+			estimatedMonthlyTraffic: numberValue$1(row.etv, "estimated monthly traffic"),
 			relevantResults: countValue(row.relevant_serp_items, "relevant result count"),
 			keywordPositions
 		}];
 	});
-	const rows = dedupeBy(mappedRows, (row) => row.domain).sort((left, right) => observedNumber(right.visibility) - observedNumber(left.visibility) || right.matchedKeywords - left.matchedKeywords || compareCodepoints$3(left.domain, right.domain));
-	const providerTotalRows = totalRows(responseResults.map((result) => result.total_count));
+	const rows = dedupeBy(mappedRows, (row) => row.domain).sort((left, right) => observedNumber$1(right.visibility) - observedNumber$1(left.visibility) || right.matchedKeywords - left.matchedKeywords || compareCodepoints$3(left.domain, right.domain));
+	const providerTotalRows = totalRows$1(responseResults.map((result) => result.total_count));
 	return domainEvidence({
 		capability: "serp-competitors",
 		data: {
@@ -23992,7 +24224,7 @@ function analyzeCompetitorGap(acquisition) {
 }
 //#endregion
 //#region packages/core/dist/analyze/domain-research/gap-report.js
-const MAX_FINDINGS = 10;
+const MAX_FINDINGS$2 = 10;
 const MAX_SOURCE_BRIEFS = 5;
 function count(candidates, classification) {
 	return candidates.filter((item) => item.classification === classification).length;
@@ -24007,7 +24239,7 @@ function dataStatus(input) {
 function findings$2(input) {
 	const result = [];
 	for (const [index, candidate] of input.candidates.entries()) {
-		if (result.length >= MAX_FINDINGS) break;
+		if (result.length >= MAX_FINDINGS$2) break;
 		if (candidate.classification === "relevant-gap-candidate") result.push({
 			code: "relevant-competitor-gap",
 			evidenceRefs: [`candidates[${index}]`, ...candidate.evidenceRefs],
@@ -24022,7 +24254,7 @@ function findings$2(input) {
 		});
 	}
 	for (const [index, pattern] of input.patterns.entries()) {
-		if (result.length >= MAX_FINDINGS) break;
+		if (result.length >= MAX_FINDINGS$2) break;
 		result.push({
 			code: "competitor-template-pattern",
 			evidenceRefs: [`repeatedCompetitorPatterns[${index}]`, ...pattern.evidenceRefs],
@@ -25069,7 +25301,7 @@ function measurementWindow(input) {
 }
 //#endregion
 //#region packages/core/dist/analyze/experiments/measure-change.js
-const defaultDependencies$5 = {
+const defaultDependencies$6 = {
 	searchAnalytics: querySearchAnalytics,
 	googleAnalyticsReport: runGa4Report,
 	contentGroup: getContentGroup,
@@ -25087,7 +25319,7 @@ function counterfactualDelta(input) {
 	const expectedAfter = input.treatmentBefore * (input.controlAfter / input.controlBefore);
 	return fixed(input.treatmentAfter - expectedAfter);
 }
-async function measureChange(input, dependencies = defaultDependencies$5) {
+async function measureChange(input, dependencies = defaultDependencies$6) {
 	const now = dependencies.now();
 	const change = (input.id ? getChange(input.id) : void 0) ?? {
 		id: "adhoc",
@@ -25810,14 +26042,14 @@ async function verifyInternalLinkCandidate(input) {
 }
 //#endregion
 //#region packages/core/dist/analyze/internal-links.js
-const MAX_GSC_ROWS$1 = 1e5;
-const defaultDependencies$4 = {
+const MAX_GSC_ROWS$2 = 1e5;
+const defaultDependencies$5 = {
 	searchAnalytics: querySearchAnalytics,
 	fetch: fetchPage,
 	extract: extractPage,
 	now: () => /* @__PURE__ */ new Date()
 };
-async function internalLinksReport(input, dependencies = defaultDependencies$4) {
+async function internalLinksReport(input, dependencies = defaultDependencies$5) {
 	const targetPage = new URL(assertUrlMatchesGscProperty(input.site, input.targetUrl));
 	targetPage.hash = "";
 	const targetUrl = targetPage.toString();
@@ -25866,7 +26098,7 @@ async function internalLinksReport(input, dependencies = defaultDependencies$4)
 			dimensions: ["query", "page"],
 			type: "web",
 			dataState: "final",
-			maxRows: MAX_GSC_ROWS$1,
+			maxRows: MAX_GSC_ROWS$2,
 			dimensionFilterGroups: [{
 				groupType: "and",
 				filters: [{
@@ -25898,7 +26130,7 @@ async function internalLinksReport(input, dependencies = defaultDependencies$4)
 		dimensions: ["query", "page"],
 		type: "web",
 		dataState: "final",
-		maxRows: MAX_GSC_ROWS$1
+		maxRows: MAX_GSC_ROWS$2
 	}, { refresh: input.refresh }) : {
 		rows: [],
 		calls: 0,
@@ -25943,8 +26175,8 @@ async function internalLinksReport(input, dependencies = defaultDependencies$4)
 		else checkedSources += 1;
 	}
 	const uncheckedCandidates = Math.max(0, analysis.candidates.length - attemptedSources);
-	const targetTruncated = targetRequests.some(({ result }) => result.rowsFetched >= MAX_GSC_ROWS$1);
-	const sourceTruncated = sourceResult.rowsFetched >= MAX_GSC_ROWS$1;
+	const targetTruncated = targetRequests.some(({ result }) => result.rowsFetched >= MAX_GSC_ROWS$2);
+	const sourceTruncated = sourceResult.rowsFetched >= MAX_GSC_ROWS$2;
 	const invalidRows = analysis.selection.targetInvalidRows + analysis.selection.sourceInvalidRows;
 	const structuredWarnings = uniqueInternalLinksWarnings(warnings);
 	const dataStatus = target.verification === "technical-issue" ? "target-technical-issue" : target.verification === "failed" ? "partial" : targetRows.length === 0 ? "empty" : targetTruncated || sourceTruncated || invalidRows > 0 ? "partial" : queryCandidates && sourceResult.rows.length === 0 ? "source-empty" : analysis.selection.targetEligibleQueries === 0 || analysis.candidates.length === 0 ? "filtered" : failedChecks > 0 || uncheckedCandidates > 0 ? "partial" : "complete";
@@ -25985,18 +26217,18 @@ async function internalLinksReport(input, dependencies = defaultDependencies$4)
 					pageFilter: alias,
 					rowsFetched: result.rowsFetched,
 					calls: result.calls,
-					possiblyTruncated: result.rowsFetched >= MAX_GSC_ROWS$1
+					possiblyTruncated: result.rowsFetched >= MAX_GSC_ROWS$2
 				})),
 				rowsFetched: targetRequests.reduce((sum, { result }) => sum + result.rowsFetched, 0),
 				calls: targetRequests.reduce((sum, { result }) => sum + result.calls, 0),
-				maxRowsPerRequest: MAX_GSC_ROWS$1,
+				maxRowsPerRequest: MAX_GSC_ROWS$2,
 				possiblyTruncated: targetTruncated
 			},
 			candidates: {
 				queried: queryCandidates,
 				rowsFetched: sourceResult.rowsFetched,
 				calls: sourceResult.calls,
-				maxRows: MAX_GSC_ROWS$1,
+				maxRows: MAX_GSC_ROWS$2,
 				possiblyTruncated: sourceTruncated
 			},
 			completeness: !queryCandidates ? "not-queried" : targetTruncated || sourceTruncated ? "possibly-truncated" : "retained-rows-only"
@@ -26015,7 +26247,7 @@ async function internalLinksReport(input, dependencies = defaultDependencies$4)
 			minImpressions,
 			resultLimit: limit,
 			checkLimit,
-			maxGscRowsPerRequest: MAX_GSC_ROWS$1
+			maxGscRowsPerRequest: MAX_GSC_ROWS$2
 		},
 		target: {
 			requestedUrl: target.requestedUrl,
@@ -26952,8 +27184,8 @@ function analyzeSecondPageRows(input) {
 }
 //#endregion
 //#region packages/core/dist/analyze/keyword-opportunities.js
-const DEFAULT_DAYS = 28;
-const MAX_DAYS = 548;
+const DEFAULT_DAYS$1 = 28;
+const MAX_DAYS$1 = 548;
 const DEFAULT_REPORT_LIMIT = 10;
 const MAX_REPORT_LIMIT = 25;
 const DEFAULT_KEYWORD_LIMIT = 30;
@@ -27000,9 +27232,9 @@ function validateInput$2(input) {
 		site,
 		days: integerOption$1({
 			value: input.days,
-			fallback: DEFAULT_DAYS,
+			fallback: DEFAULT_DAYS$1,
 			minimum: 1,
-			maximum: MAX_DAYS,
+			maximum: MAX_DAYS$1,
 			label: "Days"
 		}),
 		limit: integerOption$1({
@@ -28537,7 +28769,7 @@ function analyzeIndexCoverageSignals(input) {
 const MAX_SITEMAP_DOCUMENTS = 20;
 const MAX_SEARCH_ROWS = 25e4;
 const MAX_SITEMAP_URLS = 25e4;
-const defaultDependencies$3 = {
+const defaultDependencies$4 = {
 	loadCrawl: loadCrawlReport,
 	latestCrawl: latestCrawlReport,
 	searchAnalytics: querySearchAnalytics,
@@ -28569,7 +28801,7 @@ function sitemapCompleteness(input) {
 	if (input.inventoryTruncated) return "truncated";
 	return input.results.every((result) => result.dataStatus === "complete") ? "complete" : "partial";
 }
-async function indexCoverageSignals(input, dependencies = defaultDependencies$3) {
+async function indexCoverageSignals(input, dependencies = defaultDependencies$4) {
 	const days = integerOption$2({
 		value: input.days,
 		fallback: 90,
@@ -29052,7 +29284,7 @@ function pruneIndexWatchSnapshots(rootSite, url, database = getDb()) {
         WHERE attempts.attempt_rank > ? AND latest_success.id IS NULL
       )`).run(rootSite, url, rootSite, url, 20).changes;
 }
-const defaultDependencies$2 = {
+const defaultDependencies$3 = {
 	inspectUrl,
 	now: () => /* @__PURE__ */ new Date(),
 	store: {
@@ -29097,7 +29329,7 @@ function isFatalBatchError(error) {
 		"AUTH_REQUIRED"
 	].includes(error.code);
 }
-async function indexWatch(input, dependencies = defaultDependencies$2) {
+async function indexWatch(input, dependencies = defaultDependencies$3) {
 	const languageCode = validateLanguageCode(input.languageCode);
 	const dailyLimit = integerOption$2({
 		value: input.dailyLimit,
@@ -31192,9 +31424,9 @@ function pseoSampleUrls(report) {
 }
 //#endregion
 //#region packages/core/dist/analyze/pseo/audit.js
-const MAX_GSC_ROWS = 5e4;
+const MAX_GSC_ROWS$1 = 5e4;
 const DEFAULT_SITEMAP_URLS = 5e4;
-const defaultDependencies$1 = {
+const defaultDependencies$2 = {
 	searchAnalytics: querySearchAnalytics,
 	fetchPage,
 	inspectUrl,
@@ -31396,7 +31628,7 @@ async function inspectSample(input) {
 		};
 	}
 }
-async function acquirePseoAuditEvidence(input, dependencies = defaultDependencies$1) {
+async function acquirePseoAuditEvidence(input, dependencies = defaultDependencies$2) {
 	const options = pseoAuditOptions(input);
 	const now = dependencies.now();
 	const generatedAt = now.toISOString();
@@ -31415,7 +31647,7 @@ async function acquirePseoAuditEvidence(input, dependencies = defaultDependencie
 		type: "web",
 		dataState: "final",
 		aggregationType: "auto",
-		maxRows: MAX_GSC_ROWS
+		maxRows: MAX_GSC_ROWS$1
 	};
 	input.progress?.(`Fetching ${options.days} days of GSC page and query/page rows`);
 	const [pageResponse, queryPageResponse] = await Promise.all([dependencies.searchAnalytics(input.site, {
@@ -31466,7 +31698,7 @@ function buildPseoAuditFromAcquisition(input, acquisition, evidence) {
 		minimumTemplateImpressions: options.minimumTemplateImpressions,
 		crawlSamplesPerTemplate: options.crawlSamples,
 		inspectionSamplesPerTemplate: options.inspectSamples,
-		maxRowsPerRequest: MAX_GSC_ROWS,
+		maxRowsPerRequest: MAX_GSC_ROWS$1,
 		pageRowsFetched: acquisition.pageRowsFetched,
 		queryPageRowsFetched: acquisition.queryPageRowsFetched,
 		sitemapsRequested: input.sitemaps?.length ?? 0,
@@ -31477,7 +31709,7 @@ function buildPseoAuditFromAcquisition(input, acquisition, evidence) {
 		caveats: [`Data freshness: ${input.refresh ? "fresh fetch requested; caches bypassed where supported" : "local cache allowed; use --refresh to bypass cached provider and HTTP data"}.`, input.sitemaps?.length ? `Sitemaps: ${countLabel(input.sitemaps.length, "sitemap URL")} requested.` : "Sitemaps: none provided; template discovery used retained GSC page rows."]
 	});
 }
-async function pseoAuditReport(input, dependencies = defaultDependencies$1) {
+async function pseoAuditReport(input, dependencies = defaultDependencies$2) {
 	const acquisition = await acquirePseoAuditEvidence(input, dependencies);
 	const sampleUrls = pseoSampleUrls(buildPseoAuditFromAcquisition(input, acquisition));
 	const topQueries = topQueryByUrl(acquisition.queryPageRows, input);
@@ -32319,7 +32551,7 @@ function pseoOpportunityVerdict(input) {
 //#region packages/core/dist/providers/dataforseo/serp-snapshot.js
 const MAX_SERP_DEPTH = 100;
 const SERP_ENDPOINT = "v3/serp/google/organic/live/advanced";
-function safeUrl(value) {
+function safeUrl$1(value) {
 	if (!value) return null;
 	try {
 		const parsed = new URL(value);
@@ -32332,11 +32564,11 @@ function safeUrl(value) {
 	}
 }
 function validOrganic(item) {
-	return item.type === "organic" && Number.isSafeInteger(item.rank_group) && (item.rank_group ?? 0) > 0 && Number.isSafeInteger(item.rank_absolute) && (item.rank_absolute ?? 0) > 0 && Number.isSafeInteger(item.page) && (item.page ?? 0) > 0 && Boolean(item.domain?.trim()) && safeUrl(item.url) !== null;
+	return item.type === "organic" && Number.isSafeInteger(item.rank_group) && (item.rank_group ?? 0) > 0 && Number.isSafeInteger(item.rank_absolute) && (item.rank_absolute ?? 0) > 0 && Number.isSafeInteger(item.page) && (item.page ?? 0) > 0 && Boolean(item.domain?.trim()) && safeUrl$1(item.url) !== null;
 }
 function organicResult(item) {
 	if (!validOrganic(item)) return null;
-	const url = safeUrl(item.url);
+	const url = safeUrl$1(item.url);
 	if (!url) return null;
 	return {
 		rankGroup: item.rank_group,
@@ -32385,7 +32617,7 @@ function mapDataForSeoSerpSnapshot(input, snapshot, endpoint = SERP_ENDPOINT) {
 		field: "checkedAt",
 		message: "DataForSEO returned an invalid SERP observation time; the local response time was retained."
 	});
-	const checkUrl = safeUrl(result.check_url);
+	const checkUrl = safeUrl$1(result.check_url);
 	if (result.check_url && !checkUrl) warnings.push({
 		code: "invalid-serp-check-url",
 		field: "checkUrl",
@@ -34528,7 +34760,7 @@ function groupedMappings(evidence) {
 //#endregion
 //#region packages/core/dist/analyze/second-page.js
 const MAX_SOURCE_ROWS = 1e5;
-const defaultDependencies = {
+const defaultDependencies$1 = {
 	searchAnalytics: querySearchAnalytics,
 	fetch: fetchPage,
 	extract: extractPage,
@@ -34605,7 +34837,7 @@ function reportRecommendations(items) {
 		"Treat the priority score as a triage heuristic, not an estimated traffic lift."
 	]);
 }
-async function secondPage(input, dependencies = defaultDependencies) {
+async function secondPage(input, dependencies = defaultDependencies$1) {
 	const days = integerOption({
 		value: input.range,
 		fallback: 28,
@@ -36796,10 +37028,10 @@ const DEFAULT_TARGET_LIMIT = 20;
 const MAX_TARGET_LIMIT = 50;
 const DEFAULT_DETAIL_PAGES = 1;
 const MAX_DETAIL_PAGES = 3;
-const DEFAULT_ROW_LIMIT$2 = 500;
-const MAX_ROW_LIMIT$2 = 1e3;
+const DEFAULT_ROW_LIMIT$3 = 500;
+const MAX_ROW_LIMIT$3 = 1e3;
 const MAX_CONCURRENCY = 3;
-function integer(value, fallback, max, name) {
+function integer$1(value, fallback, max, name) {
 	const resolved = value ?? fallback;
 	if (!Number.isInteger(resolved) || resolved < 1 || resolved > max) throw new SeoError("INVALID_INPUT", `${name} must be between 1 and ${max}.`);
 	return resolved;
@@ -36860,9 +37092,9 @@ async function targetDetails(input) {
 }
 async function collectBingLinkEvidence(input) {
 	if (!input.site.trim()) throw new SeoError("INVALID_INPUT", "Pass a Bing Webmaster site URL.");
-	const targetLimit = integer(input.targetLimit, DEFAULT_TARGET_LIMIT, MAX_TARGET_LIMIT, "Bing link target limit");
-	const detailPages = integer(input.detailPagesPerTarget, DEFAULT_DETAIL_PAGES, MAX_DETAIL_PAGES, "Bing detail page limit");
-	const rowLimit = integer(input.rowLimit, DEFAULT_ROW_LIMIT$2, MAX_ROW_LIMIT$2, "Bing link row limit");
+	const targetLimit = integer$1(input.targetLimit, DEFAULT_TARGET_LIMIT, MAX_TARGET_LIMIT, "Bing link target limit");
+	const detailPages = integer$1(input.detailPagesPerTarget, DEFAULT_DETAIL_PAGES, MAX_DETAIL_PAGES, "Bing detail page limit");
+	const rowLimit = integer$1(input.rowLimit, DEFAULT_ROW_LIMIT$3, MAX_ROW_LIMIT$3, "Bing link row limit");
 	const client = input.client ?? (await createBingWebmasterClient()).client;
 	const countRows = [];
 	let countPagesRequested = 0;
@@ -36983,6 +37215,884 @@ async function collectBingLinkEvidence(input) {
 	};
 }
 //#endregion
+//#region packages/core/dist/links/context-sources.js
+function urlKey(value) {
+	try {
+		const url = new URL(value);
+		if (!["http:", "https:"].includes(url.protocol)) return null;
+		url.hash = "";
+		return url.toString();
+	} catch {
+		return null;
+	}
+}
+function compareTargets(left, right) {
+	return right.observedLinks - left.observedLinks || (left.targetUrl < right.targetUrl ? -1 : left.targetUrl > right.targetUrl ? 1 : 0);
+}
+function linkTargetCounts(evidence) {
+	if (evidence.targetCounts.length) return [...evidence.targetCounts].sort(compareTargets);
+	const counts = /* @__PURE__ */ new Map();
+	for (const row of evidence.rows) counts.set(row.targetUrl, (counts.get(row.targetUrl) ?? 0) + 1);
+	return [...counts].map(([targetUrl, observedLinks]) => ({
+		targetUrl,
+		observedLinks
+	})).sort(compareTargets);
+}
+function crawlForLinkTargets(input) {
+	const values = /* @__PURE__ */ new Map();
+	if (!input.report) {
+		for (const target of input.targets) values.set(target.targetUrl, {
+			state: "unavailable",
+			reason: "No matching saved crawl was available."
+		});
+		return {
+			values,
+			matched: 0
+		};
+	}
+	const pages = /* @__PURE__ */ new Map();
+	for (const page of input.report.pages) for (const value of [page.url, page.finalUrl]) {
+		const key = urlKey(value);
+		if (key && !pages.has(key)) pages.set(key, page);
+	}
+	const issues = /* @__PURE__ */ new Map();
+	for (const issue of input.report.issues) {
+		const key = urlKey(issue.url);
+		if (!key) continue;
+		const ids = issues.get(key) ?? /* @__PURE__ */ new Set();
+		ids.add(issue.ruleId);
+		issues.set(key, ids);
+	}
+	let matched = 0;
+	for (const target of input.targets) {
+		const key = urlKey(target.targetUrl);
+		const page = key ? pages.get(key) : void 0;
+		if (!page) {
+			values.set(target.targetUrl, {
+				state: "not-observed",
+				reason: "The target URL was not present in the retained crawl pages."
+			});
+			continue;
+		}
+		matched += 1;
+		values.set(target.targetUrl, {
+			state: "observed",
+			reportId: input.report.id,
+			observedAt: input.report.generatedAt,
+			status: page.status,
+			finalUrl: page.finalUrl,
+			indexable: page.indexable,
+			canonical: page.canonical ?? null,
+			issueIds: [...issues.get(key) ?? []].sort()
+		});
+	}
+	return {
+		values,
+		matched
+	};
+}
+function aggregateLinkSearchRows(rows) {
+	const values = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const page = row.keys[0];
+		const key = page ? urlKey(page) : null;
+		if (!key) continue;
+		const current = values.get(key) ?? {
+			clicks: 0,
+			impressions: 0,
+			positionWeight: 0
+		};
+		current.clicks += row.clicks;
+		current.impressions += row.impressions;
+		current.positionWeight += row.position * row.impressions;
+		values.set(key, current);
+	}
+	return values;
+}
+//#endregion
+//#region packages/core/dist/links/context-findings.js
+const MAX_FINDINGS$1 = 50;
+function findingPriority(input) {
+	const searchValue = input.search.state === "observed" && (input.search.clicks > 0 || input.search.impressions >= 100);
+	if (input.code === "linked-broken-target" || searchValue) return "high";
+	if (input.observedLinks >= 5) return "medium";
+	return "low";
+}
+function finding(input) {
+	const crawl = input.row.crawl;
+	if (crawl.state !== "observed") throw new Error("A link finding requires observed crawl evidence.");
+	const searchEvidence = input.row.searchConsole.state === "observed" ? ` Search Console retained ${input.row.searchConsole.clicks.toFixed(0)} clicks and ${input.row.searchConsole.impressions.toFixed(0)} impressions for this page in the selected window.` : "";
+	const common = {
+		priority: findingPriority({
+			code: input.code,
+			observedLinks: input.row.observedLinks,
+			crawl,
+			search: input.row.searchConsole
+		}),
+		heuristic: true,
+		targetUrl: input.row.targetUrl,
+		observedLinks: input.row.observedLinks,
+		evidenceRefs: [input.row.targetUrl, crawl.reportId]
+	};
+	if (input.code === "linked-broken-target") return {
+		...common,
+		code: input.code,
+		principle: "Linked target pages should resolve intentionally.",
+		evidence: `The saved crawl observed status ${crawl.status} for a target with ${input.row.observedLinks} retained representative links.${searchEvidence}`,
+		action: "Confirm whether the page should exist. Restore it or add one direct redirect to a genuinely equivalent live page when the missing URL is unintended.",
+		verify: "Run redirect-trace for the target, then recrawl it and confirm a stable intended response."
+	};
+	if (input.code === "linked-redirect-target") return {
+		...common,
+		code: input.code,
+		principle: "External links should reach a stable final destination.",
+		evidence: `The saved crawl observed ${input.row.targetUrl} resolving to ${crawl.finalUrl}.${searchEvidence}`,
+		action: "Check that the redirect is intentional, direct and semantically equivalent. Update links you control to the final URL and ask important external sources to update only when the change is worth the effort.",
+		verify: "Run redirect-trace and confirm one stable hop to the intended indexable page."
+	};
+	if (input.code === "linked-canonical-conflict") return {
+		...common,
+		code: input.code,
+		principle: "Canonical hints should agree with the intended linked page.",
+		evidence: `The saved crawl observed canonical ${crawl.canonical} on a linked target that resolved to ${crawl.finalUrl}.${searchEvidence}`,
+		action: "Confirm the preferred URL. Align the canonical and redirect only if the current disagreement is unintended.",
+		verify: "Audit the final page and inspect the declared and Google-selected canonical before changing it."
+	};
+	return {
+		...common,
+		code: input.code,
+		principle: "A linked page should be indexable when search visibility is intended.",
+		evidence: `The saved crawl marked a linked target as non-indexable.${searchEvidence}`,
+		action: "Confirm whether non-indexing is intentional. Remove the blocking signal or redirect to an equivalent indexable page only when this URL should appear in search.",
+		verify: "Audit the page, then use URL Inspection when the intended state is indexable."
+	};
+}
+function linkTargetFindings(rows) {
+	return rows.flatMap((row) => {
+		const crawl = row.crawl;
+		if (crawl.state !== "observed") return [];
+		if (crawl.status >= 400) return [finding({
+			row,
+			code: "linked-broken-target"
+		})];
+		if (urlKey(crawl.finalUrl) !== urlKey(row.targetUrl)) return [finding({
+			row,
+			code: "linked-redirect-target"
+		})];
+		if (crawl.canonical && urlKey(crawl.canonical) !== urlKey(crawl.finalUrl)) return [finding({
+			row,
+			code: "linked-canonical-conflict"
+		})];
+		if (!crawl.indexable) return [finding({
+			row,
+			code: "linked-non-indexable-target"
+		})];
+		return [];
+	}).sort((left, right) => ({
+		high: 0,
+		medium: 1,
+		low: 2
+	})[left.priority] - {
+		high: 0,
+		medium: 1,
+		low: 2
+	}[right.priority] || right.observedLinks - left.observedLinks || (left.targetUrl < right.targetUrl ? -1 : left.targetUrl > right.targetUrl ? 1 : 0)).slice(0, MAX_FINDINGS$1);
+}
+//#endregion
+//#region packages/core/dist/links/context.js
+const DEFAULT_DAYS = 90;
+const MAX_DAYS = 548;
+const DEFAULT_CONTEXT_LIMIT = 100;
+const MAX_CONTEXT_LIMIT = 100;
+const MAX_GSC_ROWS = 25e3;
+const defaultDependencies = {
+	latestCrawl: latestCrawlReport,
+	searchAnalytics: querySearchAnalytics,
+	now: () => /* @__PURE__ */ new Date()
+};
+function integer(input) {
+	const value = input.value ?? input.fallback;
+	if (!Number.isSafeInteger(value) || value < 1 || value > input.maximum) throw new SeoError("INVALID_INPUT", `${input.label} must be between 1 and ${input.maximum}.`);
+	return value;
+}
+function searchEvidence(input) {
+	if (!input.site) return {
+		state: "unavailable",
+		reason: "No Search Console property was selected for this report."
+	};
+	if (input.error) return {
+		state: "unavailable",
+		reason: input.error
+	};
+	if (!input.aggregate) return {
+		state: "not-retained",
+		reason: input.retainedLimitReached ? `The bounded Search Console response reached ${MAX_GSC_ROWS} rows and did not retain this page.` : "Search Console did not retain a page row for this URL in the selected window."
+	};
+	return {
+		state: "observed",
+		clicks: input.aggregate.clicks,
+		impressions: input.aggregate.impressions,
+		ctr: input.aggregate.impressions > 0 ? input.aggregate.clicks / input.aggregate.impressions : 0,
+		position: input.aggregate.impressions > 0 ? input.aggregate.positionWeight / input.aggregate.impressions : 0
+	};
+}
+async function linkTargetContext(input, dependencies = defaultDependencies) {
+	const days = integer({
+		value: input.days,
+		fallback: DEFAULT_DAYS,
+		maximum: MAX_DAYS,
+		label: "Link context days"
+	});
+	const limit = integer({
+		value: input.limit,
+		fallback: DEFAULT_CONTEXT_LIMIT,
+		maximum: MAX_CONTEXT_LIMIT,
+		label: "Link context limit"
+	});
+	const available = linkTargetCounts(input.evidence);
+	const selected = available.slice(0, limit);
+	const crawlLookup = input.crawlSite ?? input.searchConsoleSite;
+	const crawl = crawlLookup ? dependencies.latestCrawl(crawlLookup) : void 0;
+	const crawlValues = crawlForLinkTargets({
+		report: crawl,
+		targets: selected
+	});
+	const warnings = [];
+	const range = finalGscDateRange(days, dependencies.now());
+	let searchRows = /* @__PURE__ */ new Map();
+	let searchCalls = 0;
+	let searchRowsFetched = 0;
+	let searchError = null;
+	if (input.searchConsoleSite) try {
+		const result = await dependencies.searchAnalytics(input.searchConsoleSite, {
+			...range,
+			dimensions: ["page"],
+			type: "web",
+			dataState: "final",
+			rowLimit: MAX_GSC_ROWS,
+			maxRows: MAX_GSC_ROWS
+		}, { refresh: input.refresh });
+		searchRows = aggregateLinkSearchRows(result.rows);
+		searchCalls = result.calls;
+		searchRowsFetched = result.rowsFetched;
+	} catch (error) {
+		searchError = error instanceof Error ? error.message : "Search Console evidence could not be loaded.";
+		warnings.push(`Search Console context was unavailable. ${searchError}`);
+	}
+	let searchMatches = 0;
+	const retainedLimitReached = searchRowsFetched >= MAX_GSC_ROWS;
+	const rows = selected.map((target) => {
+		const aggregate = searchRows.get(urlKey(target.targetUrl) ?? "");
+		if (aggregate) searchMatches += 1;
+		return {
+			...target,
+			crawl: crawlValues.values.get(target.targetUrl) ?? {
+				state: "not-observed",
+				reason: "The target URL was not present in the retained crawl pages."
+			},
+			searchConsole: searchEvidence({
+				site: input.searchConsoleSite,
+				error: searchError,
+				retainedLimitReached,
+				aggregate
+			})
+		};
+	});
+	if (!crawl) warnings.push("No matching saved crawl was available, so target response and indexability checks were skipped.");
+	if (retainedLimitReached) warnings.push(`Search Console reached the ${MAX_GSC_ROWS}-row acquisition limit. Missing target rows remain not retained rather than zero.`);
+	const unavailableSources = Number(!crawl) + Number(!input.searchConsoleSite);
+	return {
+		schemaVersion: 1,
+		dataStatus: unavailableSources === 2 ? "unavailable" : unavailableSources > 0 || searchError || retainedLimitReached ? "partial" : "complete",
+		selection: {
+			availableTargets: available.length,
+			returnedTargets: rows.length,
+			omittedTargets: Math.max(0, available.length - rows.length),
+			limit
+		},
+		provenance: {
+			crawl: {
+				status: crawl ? "joined" : "unavailable",
+				reportId: crawl?.id ?? null,
+				observedAt: crawl?.generatedAt ?? null,
+				availablePages: crawl?.pages.length ?? 0,
+				matchedTargets: crawlValues.matched
+			},
+			searchConsole: {
+				status: !input.searchConsoleSite || searchError ? "unavailable" : retainedLimitReached ? "partial" : "joined",
+				site: input.searchConsoleSite ?? null,
+				range: input.searchConsoleSite ? {
+					...range,
+					days
+				} : null,
+				calls: searchCalls,
+				rowsFetched: searchRowsFetched,
+				retainedRowLimit: MAX_GSC_ROWS,
+				retainedRowLimitReached: retainedLimitReached,
+				matchedTargets: searchMatches
+			}
+		},
+		rows,
+		findings: linkTargetFindings(rows),
+		warnings
+	};
+}
+//#endregion
+//#region packages/core/dist/providers/dataforseo/link-research-shared.js
+function linkTarget(value, requestedScope = "domain") {
+	const raw = value.trim();
+	if (!raw || raw.length > 2048) throw invalidTarget();
+	if (requestedScope === "page") try {
+		const url = new URL(raw);
+		if (!["http:", "https:"].includes(url.protocol) || url.username || url.password) throw new Error();
+		url.hash = "";
+		return {
+			target: url.toString(),
+			scope: "page"
+		};
+	} catch {
+		throw invalidTarget();
+	}
+	try {
+		const hostname = new URL(raw.includes("://") ? raw : `https://${raw}`).hostname.toLowerCase().replace(/^www\./u, "").replace(/\.$/u, "");
+		if (!hostname || hostname.length > 253 || hostname.includes("..") || !hostname.includes(".") || !/^[a-z0-9.-]+$/u.test(hostname)) throw new Error();
+		return {
+			target: hostname,
+			scope: "domain"
+		};
+	} catch {
+		throw invalidTarget();
+	}
+}
+function invalidTarget() {
+	return new ProviderError({
+		provider: "dataforseo",
+		operation: "link-evidence",
+		code: "configuration",
+		message: "Use a valid domain, or choose page scope and pass an absolute URL."
+	});
+}
+function linkRowLimit(limit, offset = 0) {
+	if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1e3) throw new ProviderError({
+		provider: "dataforseo",
+		operation: "link-evidence",
+		code: "configuration",
+		message: `Link row limit must be from 1 to ${MAX_LINK_ROWS$1}.`
+	});
+	if (!Number.isSafeInteger(offset) || offset < 0 || offset > 2e4) throw new ProviderError({
+		provider: "dataforseo",
+		operation: "link-evidence",
+		code: "configuration",
+		message: `Link row offset must be from 0 to ${MAX_LINK_OFFSET}.`
+	});
+}
+function requestContext(reportId, supplied) {
+	return supplied ?? {
+		reportId,
+		reportRunId: randomUUID()
+	};
+}
+function missing(field) {
+	return unavailableValue("missing", `DataForSEO omitted ${field}.`);
+}
+function numberValue(value, field) {
+	return value === null || value === void 0 ? missing(field) : observedValue(value);
+}
+function stringValue(value, field) {
+	return value ? observedValue(value) : missing(field);
+}
+function metric(id, label, value) {
+	return value === null || value === void 0 ? [] : [{
+		provider: "dataforseo",
+		id,
+		label,
+		value,
+		scale: {
+			minimum: 0,
+			maximum: 100
+		}
+	}];
+}
+function safeUrl(value) {
+	if (!value) return null;
+	try {
+		const url = new URL(value);
+		if (!["http:", "https:"].includes(url.protocol)) return null;
+		url.username = "";
+		url.password = "";
+		url.hash = "";
+		return url.toString();
+	} catch {
+		return null;
+	}
+}
+function normalizedDate(value) {
+	if (!value) return null;
+	const parsed = Date.parse(value);
+	return Number.isFinite(parsed) ? new Date(parsed).toISOString() : null;
+}
+function uniqueSorted(values = []) {
+	return [...new Set(values.map((value) => value.trim()).filter(Boolean))].sort(compareCodepoints$3);
+}
+function totalRows(values) {
+	const present = values.filter((value) => value !== null && value !== void 0);
+	return present.length ? Math.max(...present) : null;
+}
+function linkCoverage(input) {
+	const hasMore = input.providerTotalComparable !== false && input.providerTotalRows !== null ? input.offset + input.returnedRows < input.providerTotalRows : input.returnedRows >= input.requestedRows;
+	return {
+		requestedRows: input.requestedRows,
+		returnedRows: input.returnedRows,
+		retainedRows: input.retainedRows,
+		invalidRows: input.invalidRows,
+		providerTotalRows: input.providerTotalRows,
+		completeness: input.invalidRows > 0 ? "partial" : hasMore ? "capped" : input.filtered ? "filtered" : "complete",
+		nextCursor: hasMore ? String(input.offset + input.returnedRows) : null
+	};
+}
+function linkEvidence(input) {
+	return {
+		schemaVersion: 1,
+		provider: "dataforseo",
+		capability: input.capability,
+		data: input.data,
+		observedAt: input.snapshot.observedAt,
+		market: null,
+		coverage: input.coverage,
+		cache: input.snapshot.cache,
+		cost: input.snapshot.cost,
+		request: {
+			operation: input.capability,
+			endpoint: input.endpoint,
+			limit: input.limit,
+			filters: input.filters,
+			sort: input.sort
+		},
+		warnings: input.warnings
+	};
+}
+function mappingWarnings(input) {
+	return [
+		...input.snapshotWarnings,
+		...input.invalidRows ? [{
+			code: `invalid-${input.label}-rows`,
+			field: "data.rows",
+			message: `${input.invalidRows} ${input.label} row${input.invalidRows === 1 ? "" : "s"} lacked required fields and were omitted.`
+		}] : [],
+		...input.duplicateRows ? [{
+			code: `duplicate-${input.label}-rows`,
+			field: "data.rows",
+			message: `${input.duplicateRows} duplicate ${input.label} row${input.duplicateRows === 1 ? "" : "s"} were collapsed deterministically.`
+		}] : []
+	];
+}
+//#endregion
+//#region packages/core/dist/providers/dataforseo/backlinks.js
+function metricValue(row, id) {
+	return row.metrics.find((item) => item.id === id)?.value ?? -1;
+}
+function compareRows(left, right) {
+	return metricValue(right, "backlink-rank") - metricValue(left, "backlink-rank") || metricValue(right, "source-domain-rank") - metricValue(left, "source-domain-rank") || compareCodepoints$3(left.sourceDomain, right.sourceDomain) || compareCodepoints$3(left.sourceUrl, right.sourceUrl) || compareCodepoints$3(left.targetUrl, right.targetUrl) || compareCodepoints$3(left.anchorText ?? "", right.anchorText ?? "");
+}
+function dedupe(rows) {
+	const sorted = [...rows].sort(compareRows);
+	const seen = /* @__PURE__ */ new Set();
+	return sorted.filter((row) => {
+		const key = `${row.sourceUrl}\0${row.targetUrl}\0${row.anchorText ?? ""}`;
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+async function dataForSeoBacklinks(client, input) {
+	const normalized = linkTarget(input.target, input.scope);
+	const includeSubdomains = normalized.scope === "domain" ? input.includeSubdomains ?? true : false;
+	const offset = input.offset ?? 0;
+	linkRowLimit(input.limit, offset);
+	const mode = input.mode ?? "representative";
+	const status = input.status ?? "live";
+	const providerMode = mode === "representative" ? "one_per_domain" : "as_is";
+	const orderBy = [
+		"rank,desc",
+		"domain_from_rank,desc",
+		"url_from,asc"
+	];
+	const snapshot = await client.backlinks({
+		...normalized,
+		includeSubdomains,
+		mode: providerMode,
+		status,
+		limit: input.limit,
+		offset,
+		orderBy,
+		refresh: input.refresh,
+		context: requestContext("link-evidence", input.context)
+	});
+	const results = snapshot.response.tasks.flatMap((task) => task.result ?? []);
+	const rawRows = results.flatMap((result) => result.items ?? []);
+	let invalidRows = 0;
+	const mapped = rawRows.flatMap((row) => {
+		const sourceUrl = safeUrl(row.url_from);
+		const targetUrl = safeUrl(row.url_to);
+		if (!sourceUrl || !targetUrl) {
+			invalidRows += 1;
+			return [];
+		}
+		return [{
+			sourceUrl,
+			sourceDomain: new URL(sourceUrl).hostname.toLowerCase(),
+			targetUrl,
+			anchorText: row.anchor ?? null,
+			linkType: row.item_type ?? null,
+			dofollow: row.dofollow ?? null,
+			attributes: uniqueSorted(row.rel_attributes ?? row.attributes ?? []),
+			firstSeenAt: normalizedDate(row.first_seen),
+			lastSeenAt: normalizedDate(row.lost_date ?? row.last_visited),
+			state: row.is_lost || row.lost_date ? "lost" : "live",
+			indirect: row.is_indirect_link ?? null,
+			linksFromPage: row.links_count ?? null,
+			linksFromDomain: row.group_count ?? null,
+			metrics: [
+				...metric("backlink-rank", "DataForSEO backlink rank", row.rank),
+				...metric("source-domain-rank", "DataForSEO source domain rank", row.domain_from_rank),
+				...metric("source-page-rank", "DataForSEO source page rank", row.page_from_rank),
+				...metric("backlink-spam-score", "DataForSEO backlink spam score", row.backlink_spam_score ?? row.backlinks_spam_score)
+			]
+		}];
+	});
+	const rows = dedupe(mapped);
+	const duplicateRows = mapped.length - rows.length;
+	const providerTotalRows = totalRows(results.map((result) => result.total_count));
+	return linkEvidence({
+		capability: "backlinks",
+		data: {
+			target: normalized.target,
+			mode,
+			rows,
+			totalRows: providerTotalRows
+		},
+		snapshot,
+		coverage: linkCoverage({
+			requestedRows: input.limit,
+			returnedRows: rawRows.length,
+			retainedRows: rows.length,
+			invalidRows,
+			providerTotalRows,
+			offset,
+			filtered: mode === "representative" || status !== "all",
+			providerTotalComparable: mode !== "representative"
+		}),
+		endpoint: LINK_ENDPOINTS.backlinks,
+		limit: input.limit,
+		filters: {
+			scope: normalized.scope,
+			includeSubdomains,
+			mode,
+			status,
+			includeIndirectLinks: true,
+			excludeInternalBacklinks: true,
+			offset
+		},
+		sort: orderBy,
+		warnings: mappingWarnings({
+			snapshotWarnings: snapshot.warnings,
+			invalidRows,
+			duplicateRows,
+			label: "backlink"
+		})
+	});
+}
+//#endregion
+//#region packages/core/dist/providers/dataforseo/link-summary.js
+async function dataForSeoLinkSummary(client, input) {
+	const normalized = linkTarget(input.target, input.scope);
+	const includeSubdomains = normalized.scope === "domain" ? input.includeSubdomains ?? true : false;
+	const snapshot = await client.linkSummary({
+		...normalized,
+		includeSubdomains,
+		refresh: input.refresh,
+		context: requestContext("link-evidence", input.context)
+	});
+	const rows = snapshot.response.tasks.flatMap((task) => task.result ?? []);
+	const row = [...rows].sort((left, right) => compareCodepoints$3(left.target ?? "", right.target ?? ""))[0];
+	const data = {
+		target: normalized.target,
+		scope: normalized.scope,
+		backlinks: numberValue(row?.backlinks, "total backlinks"),
+		referringDomains: numberValue(row?.referring_domains, "referring domains"),
+		referringPages: numberValue(row?.referring_pages, "referring pages"),
+		brokenBacklinks: numberValue(row?.broken_backlinks, "broken backlinks"),
+		brokenPages: numberValue(row?.broken_pages, "broken referring pages"),
+		metrics: [
+			...metric("rank", "DataForSEO rank", row?.rank),
+			...metric("backlinks-spam-score", "DataForSEO backlink spam score", row?.backlinks_spam_score),
+			...metric("target-spam-score", "DataForSEO target spam score", row?.info?.target_spam_score)
+		]
+	};
+	const retainedRows = row ? 1 : 0;
+	return linkEvidence({
+		capability: "link-summary",
+		data,
+		snapshot,
+		coverage: {
+			requestedRows: 1,
+			returnedRows: rows.length,
+			retainedRows,
+			invalidRows: 0,
+			providerTotalRows: rows.length,
+			completeness: row ? "complete" : "unavailable",
+			nextCursor: null
+		},
+		endpoint: LINK_ENDPOINTS.summary,
+		limit: 1,
+		filters: {
+			scope: normalized.scope,
+			includeSubdomains,
+			status: "live",
+			includeIndirectLinks: true,
+			excludeInternalBacklinks: true
+		},
+		sort: [],
+		warnings: [
+			...snapshot.warnings,
+			...rows.length > 1 ? [{
+				code: "multiple-link-summary-rows",
+				field: "data",
+				message: "DataForSEO returned more than one summary row. One row was retained deterministically."
+			}] : [],
+			...!row ? [{
+				code: "missing-link-summary-row",
+				field: "data",
+				message: "DataForSEO returned no summary row. Counts remain unavailable rather than zero."
+			}] : []
+		]
+	});
+}
+//#endregion
+//#region packages/core/dist/providers/dataforseo/referring-domains.js
+function observedNumber(row) {
+	return row.backlinks.state === "observed" ? row.backlinks.value : -1;
+}
+async function dataForSeoReferringDomains(client, input) {
+	const normalized = linkTarget(input.target, input.scope);
+	const includeSubdomains = normalized.scope === "domain" ? input.includeSubdomains ?? true : false;
+	const offset = input.offset ?? 0;
+	linkRowLimit(input.limit, offset);
+	const orderBy = [
+		"backlinks,desc",
+		"rank,desc",
+		"domain,asc"
+	];
+	const snapshot = await client.referringDomains({
+		...normalized,
+		includeSubdomains,
+		limit: input.limit,
+		offset,
+		orderBy,
+		refresh: input.refresh,
+		context: requestContext("link-evidence", input.context)
+	});
+	const results = snapshot.response.tasks.flatMap((task) => task.result ?? []);
+	const rawRows = results.flatMap((result) => result.items ?? []);
+	let invalidRows = 0;
+	const mapped = rawRows.flatMap((row) => {
+		const domain = row.domain?.trim().toLowerCase();
+		if (!domain) {
+			invalidRows += 1;
+			return [];
+		}
+		const firstSeenAt = normalizedDate(row.first_seen);
+		return [{
+			domain,
+			backlinks: numberValue(row.backlinks, "domain backlinks"),
+			referringPages: numberValue(row.referring_pages, "domain referring pages"),
+			brokenBacklinks: numberValue(row.broken_backlinks, "domain broken backlinks"),
+			brokenPages: numberValue(row.broken_pages, "domain broken pages"),
+			firstSeenAt: stringValue(firstSeenAt, "domain first seen date"),
+			metrics: [...metric("source-domain-rank", "DataForSEO source domain rank", row.rank), ...metric("domain-backlinks-spam-score", "DataForSEO domain backlink spam score", row.backlinks_spam_score)]
+		}];
+	});
+	const byDomain = /* @__PURE__ */ new Map();
+	for (const row of mapped.sort((left, right) => observedNumber(right) - observedNumber(left) || compareCodepoints$3(left.domain, right.domain))) if (!byDomain.has(row.domain)) byDomain.set(row.domain, row);
+	const rows = [...byDomain.values()];
+	const duplicateRows = mapped.length - rows.length;
+	const providerTotalRows = totalRows(results.map((result) => result.total_count));
+	return linkEvidence({
+		capability: "referring-domains",
+		data: {
+			target: normalized.target,
+			rows,
+			totalRows: providerTotalRows
+		},
+		snapshot,
+		coverage: linkCoverage({
+			requestedRows: input.limit,
+			returnedRows: rawRows.length,
+			retainedRows: rows.length,
+			invalidRows,
+			providerTotalRows,
+			offset,
+			filtered: true
+		}),
+		endpoint: LINK_ENDPOINTS.referringDomains,
+		limit: input.limit,
+		filters: {
+			scope: normalized.scope,
+			includeSubdomains,
+			status: "live",
+			includeIndirectLinks: true,
+			excludeInternalBacklinks: true,
+			offset
+		},
+		sort: orderBy,
+		warnings: mappingWarnings({
+			snapshotWarnings: snapshot.warnings,
+			invalidRows,
+			duplicateRows,
+			label: "referring-domain"
+		})
+	});
+}
+//#endregion
+//#region packages/core/dist/providers/dataforseo/link-research.js
+var DataForSeoLinkProvider = class {
+	provider = "dataforseo";
+	capabilitySupport = [
+		"link-summary",
+		"referring-domains",
+		"backlinks"
+	].map((capability) => ({
+		capability,
+		status: "available",
+		markets: "all"
+	}));
+	client;
+	constructor(options = {}) {
+		this.client = options.client ?? new DataForSeoClient(options);
+	}
+	linkSummary(input) {
+		return dataForSeoLinkSummary(this.client, input);
+	}
+	backlinks(input) {
+		return dataForSeoBacklinks(this.client, input);
+	}
+	referringDomains(input) {
+		return dataForSeoReferringDomains(this.client, input);
+	}
+};
+//#endregion
+//#region packages/core/dist/links/dataforseo.js
+const DEFAULT_ROW_LIMIT$2 = 100;
+const MAX_ROW_LIMIT$2 = 500;
+function rowLimit(value) {
+	const limit = value ?? DEFAULT_ROW_LIMIT$2;
+	if (!Number.isSafeInteger(limit) || limit < 1 || limit > MAX_ROW_LIMIT$2) throw new SeoError("INVALID_INPUT", `DataForSEO link row limit must be between 1 and ${MAX_ROW_LIMIT$2}.`);
+	return limit;
+}
+async function collectDataForSeoLinkEvidence(input) {
+	const limit = rowLimit(input.rowLimit);
+	const provider = input.provider ?? new DataForSeoLinkProvider();
+	const context = input.context ?? {
+		reportId: "link-evidence",
+		reportRunId: randomUUID()
+	};
+	const summary = await provider.linkSummary({
+		target: input.target,
+		scope: input.scope,
+		includeSubdomains: input.includeSubdomains,
+		refresh: input.refresh,
+		context
+	});
+	const backlinks = await provider.backlinks({
+		target: summary.data.target,
+		scope: summary.data.scope,
+		includeSubdomains: input.includeSubdomains,
+		mode: "representative",
+		status: "live",
+		limit,
+		refresh: input.refresh,
+		context
+	});
+	const rows = backlinks.data.rows.map((row) => ({
+		sourceUrl: row.sourceUrl,
+		sourceDomain: row.sourceDomain,
+		targetUrl: row.targetUrl,
+		anchorText: row.anchorText ?? void 0,
+		firstSeenAt: row.firstSeenAt ?? void 0,
+		lastSeenAt: row.lastSeenAt ?? void 0,
+		nofollow: row.dofollow === null ? void 0 : !row.dofollow,
+		linkType: row.linkType ?? void 0,
+		attributes: row.attributes,
+		state: row.state,
+		indirect: row.indirect ?? void 0,
+		linksFromPage: row.linksFromPage ?? void 0,
+		linksFromDomain: row.linksFromDomain ?? void 0,
+		providerMetrics: row.metrics
+	}));
+	const counts = /* @__PURE__ */ new Map();
+	for (const row of rows) counts.set(row.targetUrl, (counts.get(row.targetUrl) ?? 0) + 1);
+	const targetCounts = [...counts].map(([targetUrl, observedLinks]) => ({
+		targetUrl,
+		observedLinks
+	})).sort((left, right) => right.observedLinks - left.observedLinks || (left.targetUrl < right.targetUrl ? -1 : left.targetUrl > right.targetUrl ? 1 : 0));
+	const completeness = backlinks.coverage.completeness;
+	const representative = backlinks.data.mode === "representative";
+	const partial = completeness !== "complete" || representative;
+	return {
+		rows,
+		targetCounts,
+		provenance: {
+			provider: "dataforseo",
+			observedAt: backlinks.observedAt > summary.observedAt ? backlinks.observedAt : summary.observedAt,
+			cached: summary.cache.status === "hit" && backlinks.cache.status === "hit",
+			suppliedRows: backlinks.coverage.returnedRows ?? rows.length,
+			validRows: rows.length,
+			invalidRows: backlinks.coverage.invalidRows,
+			duplicateRows: Math.max(0, (backlinks.coverage.returnedRows ?? rows.length) - backlinks.coverage.invalidRows - rows.length),
+			capped: ["capped", "partial"].includes(completeness),
+			rowLimit: limit,
+			completeness: partial ? "partial" : "complete",
+			providerRequests: {
+				methods: [summary.request.endpoint, backlinks.request.endpoint],
+				maxConcurrentRequests: 1
+			},
+			providerCoverage: {
+				targetCountRows: {
+					returnedRows: targetCounts.length,
+					retainedRows: targetCounts.length,
+					invalidRows: 0
+				},
+				detailRows: {
+					returnedRows: backlinks.coverage.returnedRows ?? rows.length,
+					retainedRows: rows.length,
+					invalidRows: backlinks.coverage.invalidRows
+				},
+				summaryRows: {
+					returnedRows: summary.coverage.returnedRows ?? 0,
+					retainedRows: summary.coverage.retainedRows ?? 0,
+					invalidRows: summary.coverage.invalidRows
+				},
+				backlinkRows: {
+					returnedRows: backlinks.coverage.returnedRows ?? rows.length,
+					retainedRows: rows.length,
+					invalidRows: backlinks.coverage.invalidRows,
+					providerTotalRows: backlinks.coverage.providerTotalRows
+				}
+			}
+		},
+		externalProvider: {
+			summary,
+			backlinks
+		},
+		warnings: [
+			...summary.warnings.map((warning) => warning.message),
+			...backlinks.warnings.map((warning) => warning.message),
+			...representative ? ["The link list retains one representative backlink per referring domain. Provider summary counts remain separate from retained rows."] : [],
+			...!representative && partial ? ["The link list is bounded or partial. Provider summary counts remain separate from retained rows."] : []
+		]
+	};
+}
+//#endregion
 //#region packages/core/dist/links/import.js
 const DEFAULT_ROW_LIMIT$1 = 1e4;
 const MAX_ROW_LIMIT$1 = 1e5;
@@ -37171,6 +38281,10 @@ async function importLinkEvidence(input) {
 //#region packages/core/dist/links/report.js
 const DEFAULT_OUTPUT_LIMIT = 100;
 const MAX_OUTPUT_LIMIT = 500;
+const MAX_TARGET_COUNTS = 100;
+const MAX_CONTEXT_ROWS = 100;
+const MAX_FINDINGS = 50;
+const MAX_STRUCTURED_DETAIL_ROWS = 750;
 function boundedLimit(value) {
 	const limit = value ?? DEFAULT_OUTPUT_LIMIT;
 	if (!Number.isInteger(limit) || limit < 1 || limit > MAX_OUTPUT_LIMIT) throw new SeoError("INVALID_INPUT", `Link report limit must be between 1 and ${MAX_OUTPUT_LIMIT}.`);
@@ -37182,7 +38296,7 @@ function targetCounts(rows) {
 	return [...counts].map(([targetUrl, observedLinks]) => ({
 		targetUrl,
 		observedLinks
-	})).sort((a, b) => b.observedLinks - a.observedLinks || a.targetUrl.localeCompare(b.targetUrl, "en"));
+	})).sort((a, b) => b.observedLinks - a.observedLinks || (a.targetUrl < b.targetUrl ? -1 : a.targetUrl > b.targetUrl ? 1 : 0));
 }
 function linkEvidenceReport(input) {
 	const limit = boundedLimit(input.limit);
@@ -37190,8 +38304,24 @@ function linkEvidenceReport(input) {
 	const domains = new Set(input.evidence.rows.map((row) => row.sourceDomain));
 	const observedTargets = targetCounts(input.evidence.rows);
 	const counts = input.evidence.targetCounts.length ? input.evidence.targetCounts : observedTargets;
+	const providerEvidence = input.evidence.externalProvider ? {
+		summary: input.evidence.externalProvider.summary,
+		backlinks: {
+			...input.evidence.externalProvider.backlinks,
+			data: {
+				target: input.evidence.externalProvider.backlinks.data.target,
+				mode: input.evidence.externalProvider.backlinks.data.mode,
+				totalRows: input.evidence.externalProvider.backlinks.data.totalRows,
+				retainedRows: input.evidence.externalProvider.backlinks.data.rows.length
+			}
+		}
+	} : null;
+	const targetCountsOutput = counts.slice(0, MAX_TARGET_COUNTS);
+	const contextRows = input.targetContext?.rows.slice(0, MAX_CONTEXT_ROWS) ?? [];
+	const findings = input.targetContext?.findings.slice(0, MAX_FINDINGS) ?? [];
+	const returnedDetailRows = rows.length + targetCountsOutput.length + contextRows.length + findings.length;
 	return {
-		schemaVersion: 1,
+		schemaVersion: 2,
 		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
 		dataStatus: input.evidence.provenance.completeness === "complete" ? "complete" : "partial",
 		summary: {
@@ -37200,6 +38330,8 @@ function linkEvidenceReport(input) {
 			targetPages: new Set(input.evidence.rows.map((row) => row.targetUrl)).size,
 			providerTargetPages: counts.length
 		},
+		providerSummary: providerEvidence?.summary.data ?? null,
+		providerEvidence,
 		provenance: input.evidence.provenance,
 		selection: {
 			availableRows: input.evidence.rows.length,
@@ -37207,13 +38339,45 @@ function linkEvidenceReport(input) {
 			omittedRows: Math.max(0, input.evidence.rows.length - rows.length),
 			limit
 		},
-		targetCounts: counts.slice(0, 100),
+		outputBudget: {
+			unit: "structured-detail-rows",
+			limit: MAX_STRUCTURED_DETAIL_ROWS,
+			returned: returnedDetailRows,
+			omitted: Math.max(0, input.evidence.rows.length - rows.length + Math.max(0, counts.length - targetCountsOutput.length) + Math.max(0, (input.targetContext?.rows.length ?? 0) - contextRows.length) + Math.max(0, (input.targetContext?.findings.length ?? 0) - findings.length)),
+			sections: {
+				links: {
+					limit: MAX_OUTPUT_LIMIT,
+					returned: rows.length
+				},
+				targetCounts: {
+					limit: MAX_TARGET_COUNTS,
+					returned: targetCountsOutput.length
+				},
+				targetContext: {
+					limit: MAX_CONTEXT_ROWS,
+					returned: contextRows.length
+				},
+				findings: {
+					limit: MAX_FINDINGS,
+					returned: findings.length
+				}
+			}
+		},
+		targetCounts: targetCountsOutput,
 		links: rows,
-		warnings: input.evidence.warnings,
+		targetContext: input.targetContext ? {
+			...input.targetContext,
+			rows: contextRows,
+			findings
+		} : null,
+		findings,
+		warnings: [...input.evidence.warnings, ...input.targetContext?.warnings ?? []],
 		caveats: [
 			"This is bounded provider or imported evidence, not a complete backlink index.",
 			"A missing link is not proof that no link exists, and an observed link is not a quality or ranking verdict.",
-			"Referring-domain counts describe the retained rows only."
+			"Referring-domain counts describe the retained rows only.",
+			...providerEvidence ? ["Provider profile counts describe its current index. The representative link rows are a separate bounded sample.", "Provider rank and spam metrics keep their provider names and scales. They are context, not ranking factors or universal authority scores."] : [],
+			...input.targetContext ? ["Search Console page rows are retained first-party evidence. Missing or capped rows are never treated as zero.", "Saved crawl findings describe the recorded crawl time. Verify the live target before changing it."] : []
 		]
 	};
 }
@@ -40635,9 +41799,14 @@ function registerProviderTools(server) {
 		}
 	});
 	server.registerTool("seo_link_evidence", {
-		description: "Review bounded referring-link evidence from Bing Webmaster or a local export",
+		description: "Review bounded referring-link evidence from DataForSEO, Bing Webmaster or a local export",
 		inputSchema: {
 			site: z$1.string().url().max(2e3).optional(),
+			provider: z$1.enum(["dataforseo", "bing"]).optional(),
+			target: z$1.string().trim().min(1).max(2048).optional(),
+			scope: z$1.enum(["domain", "page"]).optional(),
+			includeSubdomains: z$1.boolean().optional(),
+			searchConsoleSite: z$1.string().trim().min(1).max(2048).optional(),
 			file: z$1.string().min(1).max(4096).optional(),
 			format: z$1.enum([
 				"csv",
@@ -40647,23 +41816,43 @@ function registerProviderTools(server) {
 			rowLimit: z$1.number().int().min(1).max(1e5).optional(),
 			targetLimit: z$1.number().int().min(1).max(50).optional(),
 			detailPagesPerTarget: z$1.number().int().min(1).max(3).optional(),
-			limit: z$1.number().int().min(1).max(500).optional()
+			limit: z$1.number().int().min(1).max(500).optional(),
+			days: z$1.number().int().min(1).max(548).optional(),
+			refresh: z$1.boolean().optional()
 		}
-	}, async ({ site, file, format, rowLimit, targetLimit, detailPagesPerTarget, limit }) => {
+	}, async ({ site, provider, target, scope, includeSubdomains, searchConsoleSite, file, format, rowLimit, targetLimit, detailPagesPerTarget, limit, days, refresh }) => {
 		try {
-			if (Boolean(site) === Boolean(file)) throw new SeoError("INVALID_INPUT", "Pass exactly one of site for Bing or file for a local import.");
+			const liveProvider = provider ?? (target ? "dataforseo" : "bing");
+			if (Number(Boolean(file)) + Number(Boolean(site)) + Number(Boolean(target)) !== 1) throw new SeoError("INVALID_INPUT", "Pass one link source: file, site for Bing, or target for DataForSEO.");
+			if (file && provider) throw new SeoError("INVALID_INPUT", "Do not pass provider with a local link file.");
+			if (liveProvider === "dataforseo" && !target) throw new SeoError("INVALID_INPUT", "Pass target for DataForSEO link evidence.");
+			if (liveProvider === "bing" && !site && !file) throw new SeoError("INVALID_INPUT", "Pass site for Bing link evidence.");
+			const evidence = file ? await importLinkEvidence({
+				file,
+				format,
+				rowLimit
+			}) : liveProvider === "dataforseo" ? await collectDataForSeoLinkEvidence({
+				target: target ?? "",
+				scope,
+				includeSubdomains,
+				rowLimit,
+				refresh
+			}) : await collectBingLinkEvidence({
+				site: site ?? "",
+				rowLimit,
+				targetLimit,
+				detailPagesPerTarget
+			});
 			const report = linkEvidenceReport({
-				evidence: file ? await importLinkEvidence({
-					file,
-					format,
-					rowLimit
-				}) : await collectBingLinkEvidence({
-					site: site ?? "",
-					rowLimit,
-					targetLimit,
-					detailPagesPerTarget
-				}),
-				limit
+				evidence,
+				limit,
+				targetContext: searchConsoleSite || evidence.provenance.provider === "dataforseo" ? await linkTargetContext({
+					evidence,
+					searchConsoleSite,
+					crawlSite: searchConsoleSite ?? target,
+					days,
+					refresh
+				}) : void 0
 			});
 			return toolSuccess(`${report.summary.observedLinks} referring links were retained from ${report.provenance.provider}.`, report);
 		} catch (error) {
@@ -41078,15 +42267,18 @@ const REPORT_DEPTH = {
 	"link-evidence": {
 		readOrder: [
 			"dataStatus, provenance, warnings, and caveats",
-			"selection and summary coverage counts",
-			"targetCounts, then the bounded links list"
+			"providerSummary and providerEvidence coverage, cache, cost, filters, and observation time when present",
+			"selection, outputBudget, and retained summary counts",
+			"findings and targetContext with crawl and Search Console evidence states",
+			"targetCounts, then the bounded representative links list and provider-native metrics"
 		],
 		doNotClaim: [
-			"The retained rows are not a complete backlink index.",
-			"Missing rows do not prove a link does not exist.",
-			"Observed links do not establish quality, authority, value, or ranking impact."
+			"The retained rows are not a complete backlink index, and missing rows do not prove a link does not exist.",
+			"Observed links do not establish quality, authority, value, or ranking impact.",
+			"Provider rank and spam metrics keep their provider-specific scales. They are not search-engine ranking factors or interchangeable authority scores.",
+			"A missing Search Console row is not zero, and a saved crawl finding does not prove the target still has that state."
 		],
-		verify: "Open a selected referring URL and confirm the link is still present before acting on it.",
+		verify: "Open a selected referring URL to confirm the link, then check any flagged target live with redirect-trace or audit-page before changing it.",
 		related: [
 			{
 				id: "link-recovery",
@@ -41099,6 +42291,10 @@ const REPORT_DEPTH = {
 			{
 				id: "site-crawl",
 				reason: "Checks internal links and live pages."
+			},
+			{
+				id: "search-performance-overview",
+				reason: "Adds broader first-party search context."
 			}
 		]
 	},
@@ -42827,10 +44023,14 @@ const REPORT_GUIDANCE = {
 	},
 	"link-evidence": {
 		name: "Referring link evidence",
-		description: "Review a bounded set of pages that link to the site from Bing Webmaster or a local export.",
-		useWhen: ["You want concrete referring URLs and anchor text where available.", "You need one normalized view of Bing or an exported CSV, JSON, or JSONL file."],
-		avoidWhen: ["You need a complete backlink index or a domain authority score.", "You want to find broken internal links during a crawl."],
-		outcome: "A bounded, deduplicated link list with target-page counts and explicit source coverage."
+		description: "Review bounded referring-link evidence from a live provider, Bing Webmaster or a local export.",
+		useWhen: [
+			"You want concrete referring URLs and anchor text where available.",
+			"You want to compare a live provider summary with saved crawl and Search Console evidence for linked target pages.",
+			"You need one normalized view of DataForSEO, Bing or an exported CSV, JSON, or JSONL file."
+		],
+		avoidWhen: ["You need a complete backlink index or a universal authority score.", "You want to find broken internal links during a crawl."],
+		outcome: "Provider summary counts, representative links, target-page search and crawl context, and bounded technical findings with explicit source coverage."
 	},
 	"server-log-analysis": {
 		name: "Server log crawler analysis",