seo 0.15.2 → 0.16.1

package/dist/mcp.js

@@ -1,11 +1,11 @@
 import { createRequire as __seoCreateRequire } from 'node:module'; const require = __seoCreateRequire(import.meta.url);
-import { i as __toESM, n as version, r as __commonJSMin, t as load } from "./esm-Dt4JJZ0P.js";
+import { i as __toESM, n as version, r as __commonJSMin, t as load } from "./esm-Cvmg0qhZ.js";
 import { createHash, randomUUID, sign } from "node:crypto";
 import { ZodOptional, z } from "zod";
 import { arch, homedir, platform, tmpdir, totalmem } from "node:os";
 import { dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
 import "open";
-import { chmodSync, createReadStream, existsSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { chmodSync, createReadStream, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import lockfile from "proper-lockfile";
 import "node:http";
 import { Headers as Headers$1, fetch as fetch$1 } from "undici";
@@ -12461,6 +12461,24 @@ const RULE_DEFINITIONS = [
 			suggestedCommands: ["seo crawl <url> --max-pages 1 --json"]
 		}
 	},
+	{
+		id: "crawl_single_page_reach",
+		title: "Crawl could reach only the start page",
+		category: "links",
+		defaultSeverity: "high",
+		whyItMatters: "The start page had no crawlable internal links and no sitemap returned URLs, so the crawl checked one page. Every other finding in this report covers that page only. The page probably builds its links with JavaScript.",
+		howToFix: "Rerun with `--rendering on` so the crawler reads the links a browser sees, or pass the pages to check with `--mode list`. For crawlers that do not run JavaScript, put plain `<a href>` links in the initial HTML and publish a sitemap.",
+		impactIfIgnored: "Crawlers and audits that do not run JavaScript can find only this page, so the rest of the site stays unchecked and harder to discover.",
+		howToVerify: "Rerun the crawl and confirm it retains more than one page and the start page reports internal links.",
+		agentHints: {
+			evidenceFields: [
+				"page.outgoingInternalCount",
+				"report.sitemapDiscovery.urlsReturned",
+				"page.fetchDiagnostics.rendering"
+			],
+			suggestedCommands: ["seo crawl <url> --rendering on --json", "seo crawl --mode list --urls <url>,<url> --json"]
+		}
+	},
 	{
 		id: "soft_404",
 		title: "Unknown URLs return a successful response",
@@ -12469,7 +12487,7 @@ const RULE_DEFINITIONS = [
 		whyItMatters: "Known-nonexistent URLs returned a successful response or redirected to another successful page. Search engines and users cannot reliably distinguish missing content from a real page.",
 		howToFix: "Return 404 or 410 for missing URLs. If a replacement exists, redirect only the specific retired URL to its closest relevant replacement rather than sending every unknown path to a generic page.",
 		impactIfIgnored: "Missing URLs can remain in crawl queues, waste crawl attention, and create confusing search or monitoring evidence.",
-		howToVerify: "Request several known-nonexistent paths and confirm each returns 404 or 410 without redirecting to a generic successful page.",
+		howToVerify: "Request several made-up paths, including one at the site root and one nested path, and confirm each returns 404 or 410 without redirecting to a generic successful page.",
 		agentHints: {
 			evidenceFields: ["report.siteChecks.soft404"],
 			suggestedCommands: ["seo crawl <url> --json"]
@@ -13918,7 +13936,7 @@ function day$3(value) {
 	const date = legacy ? new Date(Number(legacy[1])) : new Date(value);
 	return Number.isNaN(date.getTime()) ? null : date.toISOString().slice(0, 10);
 }
-const count$3 = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+const count$4 = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
 function list$2(data, label) {
 	if (!Array.isArray(data)) throw new SeoError("OPTIONAL_PROVIDER_UNAVAILABLE", `Bing Webmaster returned an invalid ${label}.`);
 	return data.filter((item) => Boolean(item) && typeof item === "object");
@@ -13934,8 +13952,8 @@ async function bingTraffic(call, site) {
 	let invalidRows = 0;
 	for (const row of list$2(await call("GetRankAndTrafficStats", { siteUrl: site }), "traffic list")) {
 		const date = day$3(row.Date);
-		const clicks = count$3(row.Clicks);
-		const impressions = count$3(row.Impressions);
+		const clicks = count$4(row.Clicks);
+		const impressions = count$4(row.Impressions);
 		if (!date || clicks === null || impressions === null) {
 			invalidRows += 1;
 			continue;
@@ -13958,9 +13976,9 @@ async function keyed(call, method, params) {
 	for (const row of list$2(await call(method, params), "row list")) {
 		const date = day$3(row.Date);
 		const key = typeof row.Query === "string" ? row.Query.trim() : "";
-		const clicks = count$3(row.Clicks);
-		const impressions = count$3(row.Impressions);
-		const position = count$3(row.AvgImpressionPosition);
+		const clicks = count$4(row.Clicks);
+		const impressions = count$4(row.Impressions);
+		const position = count$4(row.AvgImpressionPosition);
 		if (!date || !key || clicks === null || impressions === null) {
 			invalidRows += 1;
 			continue;
@@ -14491,6 +14509,14 @@ function sharedReader(read, redirects = /* @__PURE__ */ new Map()) {
 	};
 }
 const MAX_STATUS_BYTES = 10485760;
+async function rankingUpdates() {
+	const incidents = await fetch("https://status.search.google.com/incidents.json", { signal: AbortSignal.timeout(8e3) }).then((response) => response.ok ? readJson(response, "Google Search Status", { maxBytes: MAX_STATUS_BYTES }) : null).catch(() => null);
+	if (!Array.isArray(incidents)) return "Google Search Status could not be read.";
+	return searchUpdatesFromIncidents(withRankingHistory(incidents), {
+		product: "Ranking",
+		limit: Number.POSITIVE_INFINITY
+	});
+}
 async function googleUpdates(window) {
 	if (!window) return [];
 	const incidents = await fetch("https://status.search.google.com/incidents.json", { signal: AbortSignal.timeout(8e3) }).then((response) => response.ok ? readJson(response, "Google Search Status", { maxBytes: MAX_STATUS_BYTES }) : null).catch(() => null);
@@ -19132,17 +19158,15 @@ function recordHostFetch(input) {
 	const cfg = input.rate.backpressure;
 	health.durations.push(input.durationMs);
 	if (health.durations.length > 20) health.durations.shift();
-	const blocked = [
-		401,
-		403,
-		429
-	].includes(input.status);
-	const errored = input.status >= 500;
+	const rateLimited = input.status === 429 || input.status === 503 && input.retryAfterMs !== void 0;
+	const blocked = [401, 403].includes(input.status);
+	const errored = input.status >= 500 && !rateLimited;
 	const slow = input.durationMs >= cfg.slowMs;
 	health.consecutiveBlocked = blocked ? health.consecutiveBlocked + 1 : 0;
 	health.consecutiveErrors = errored ? health.consecutiveErrors + 1 : 0;
 	health.consecutiveSlow = slow ? health.consecutiveSlow + 1 : 0;
-	if (!blocked && !errored && !slow) health.reason = void 0;
+	if (!blocked && !errored && !slow && !rateLimited) health.reason = void 0;
+	if (rateLimited) health.reason = `origin rate limited the crawler (HTTP ${input.status})`;
 	const retryDelay = input.retryAfterMs === void 0 ? 0 : Math.min(input.retryAfterMs, cfg.retryAfterCapMs);
 	if (retryDelay > 0) {
 		health.reason = `origin sent Retry-After (${Math.round(retryDelay / 1e3)}s)`;
@@ -19543,6 +19567,56 @@ function systemBrowserCandidates(input) {
 		product: path.includes("google-chrome") ? "Google Chrome" : "Chromium"
 	}));
 }
+function listDirectorySafely(path) {
+	try {
+		return readdirSync(path);
+	} catch {
+		return [];
+	}
+}
+function versionParts(name) {
+	return (name.match(/\d+/g) ?? []).map(Number);
+}
+function newestFirst(left, right) {
+	const a = versionParts(left);
+	const b = versionParts(right);
+	for (let index = 0; index < Math.max(a.length, b.length); index += 1) {
+		const difference = (b[index] ?? -1) - (a[index] ?? -1);
+		if (difference) return difference;
+	}
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+const MAX_CACHED_BROWSER_VERSIONS = 20;
+function versionDirectories(root, prefix, listDirectory) {
+	return listDirectory(root).filter((name) => name.startsWith(prefix)).sort(newestFirst).slice(0, MAX_CACHED_BROWSER_VERSIONS).map((name) => join(root, name));
+}
+const CHROME_FOR_TESTING_APP = join("Google Chrome for Testing.app", "Contents", "MacOS", "Google Chrome for Testing");
+/**
+* Browsers that other local tools already downloaded: agent-browser keeps
+* Chrome for Testing builds and Playwright keeps one Chromium per revision.
+*/
+function cachedBrowserCandidates(input) {
+	const agentBrowserExecutables = input.platform === "darwin" ? [CHROME_FOR_TESTING_APP] : input.platform === "win32" ? ["chrome.exe"] : ["chrome"];
+	const agentBrowser = versionDirectories(join(input.homeDirectory, ".agent-browser", "browsers"), "chrome-", input.listDirectory).flatMap((directory) => agentBrowserExecutables.map((executable) => ({
+		path: join(directory, executable),
+		source: "agent-browser-cache",
+		product: "agent-browser Chrome for Testing"
+	})));
+	const configuredRoot = input.environment.PLAYWRIGHT_BROWSERS_PATH?.trim();
+	const playwrightRoot = configuredRoot && configuredRoot !== "0" ? configuredRoot : input.platform === "darwin" ? join(input.homeDirectory, "Library", "Caches", "ms-playwright") : input.platform === "win32" ? join(input.environment.LOCALAPPDATA ?? join(input.homeDirectory, "AppData", "Local"), "ms-playwright") : join(input.environment.XDG_CACHE_HOME ?? join(input.homeDirectory, ".cache"), "ms-playwright");
+	const playwrightExecutables = input.platform === "darwin" ? [
+		join("chrome-mac-arm64", CHROME_FOR_TESTING_APP),
+		join("chrome-mac-x64", CHROME_FOR_TESTING_APP),
+		join("chrome-mac", CHROME_FOR_TESTING_APP),
+		join("chrome-mac", "Chromium.app", "Contents", "MacOS", "Chromium")
+	] : input.platform === "win32" ? [join("chrome-win64", "chrome.exe"), join("chrome-win", "chrome.exe")] : [join("chrome-linux64", "chrome"), join("chrome-linux", "chrome")];
+	const playwright = versionDirectories(playwrightRoot, "chromium-", input.listDirectory).flatMap((directory) => playwrightExecutables.map((executable) => ({
+		path: join(directory, executable),
+		source: "playwright-cache",
+		product: "Playwright Chromium"
+	})));
+	return [...agentBrowser, ...playwright];
+}
 /**
 * Resolve a browser without downloading one during normal package installation.
 * The explicit path wins so CI and managed workstations can select their own
@@ -19574,11 +19648,23 @@ function resolveBrowserExecutable(playwrightExecutablePath, dependencies = {}) {
 			product: "Playwright Chromium"
 		}
 	};
-	const browser = systemBrowserCandidates({
-		platform: dependencies.platform ?? process.platform,
-		homeDirectory: dependencies.homeDirectory ?? homedir(),
+	const platform = dependencies.platform ?? process.platform;
+	const homeDirectory = dependencies.homeDirectory ?? homedir();
+	const systemBrowser = systemBrowserCandidates({
+		platform,
+		homeDirectory,
 		environment
 	}).find((candidate) => fileExists(candidate.path));
+	if (systemBrowser) return {
+		status: "available",
+		browser: systemBrowser
+	};
+	const browser = cachedBrowserCandidates({
+		platform,
+		homeDirectory,
+		environment,
+		listDirectory: dependencies.listDirectory ?? listDirectorySafely
+	}).find((candidate) => fileExists(candidate.path));
 	return browser ? {
 		status: "available",
 		browser
@@ -22574,6 +22660,17 @@ function isAuditableHtmlPage(page) {
 	const contentAuditAllowed = page.contentAuditAllowed ?? (!page.blocked && page.robotsTxt?.allowed !== false);
 	return isSuccessfulResponse(page) && isHtmlPage(page) && !isRedirectedPage(page) && contentAuditAllowed;
 }
+/**
+* Cloudflare serves its own endpoints under `/cdn-cgi/`, such as the email
+* obfuscation link `/cdn-cgi/l/email-protection`. They are not site pages.
+*/
+function isCdnUtilityUrl(value) {
+	try {
+		return new URL(value).pathname.startsWith("/cdn-cgi/");
+	} catch {
+		return false;
+	}
+}
 // packages/core/dist/analyze/crawler/audit.js
 function sameUrl(a, b) {
 	if (!a || !b) return false;
@@ -22686,38 +22783,61 @@ function isValuablePage(page) {
 function normalizedMetadata(value) {
 	return value?.trim().replace(/\s+/g, " ").toLowerCase() || void 0;
 }
-function metadataDuplicates(pages, read) {
-	const counts = /* @__PURE__ */ new Map();
+/**
+* A page whose canonical names another crawled page in its group is already
+* handled. A group counts only when two or more of its pages are
+* self-canonical or declare no canonical, and only those pages are reported.
+*/
+function duplicateGroups(pages, read) {
+	const grouped = /* @__PURE__ */ new Map();
 	for (const page of pages) {
 		if (!isAuditableHtmlPage(page)) continue;
-		const raw = read(page)?.trim();
-		const key = normalizedMetadata(raw);
-		if (!key || !raw) continue;
-		const existing = counts.get(key) ?? {
-			count: 0,
-			sampleUrls: [],
-			value: raw
+		const entry = read(page);
+		if (!entry) continue;
+		const group = grouped.get(entry.key) ?? {
+			value: entry.value,
+			pages: []
 		};
-		existing.count += 1;
-		if (existing.sampleUrls.length < 10) existing.sampleUrls.push(page.url);
-		counts.set(key, existing);
+		group.pages.push(page);
+		grouped.set(entry.key, group);
+	}
+	const duplicates = /* @__PURE__ */ new Map();
+	for (const [key, group] of grouped) {
+		if (group.pages.length < 2) continue;
+		const groupUrls = /* @__PURE__ */ new Set();
+		for (const page of group.pages) for (const value of [page.url, page.finalUrl]) {
+			const url = urlKey(value);
+			if (url) groupUrls.add(url);
+		}
+		const counted = group.pages.filter((page) => {
+			const canonical = urlKey(page.canonical);
+			return !canonical || canonical === urlKey(page.url) || canonical === urlKey(page.finalUrl) || !groupUrls.has(canonical);
+		});
+		if (counted.length < 2) continue;
+		duplicates.set(key, {
+			count: counted.length,
+			sampleUrls: counted.slice(0, 10).map((page) => page.url),
+			value: group.value,
+			urls: new Set(counted.map((page) => page.url))
+		});
 	}
-	return new Map([...counts].filter(([, value]) => value.count > 1));
+	return duplicates;
+}
+function metadataDuplicates(pages, read) {
+	return duplicateGroups(pages, (page) => {
+		const value = read(page)?.trim();
+		const key = normalizedMetadata(value);
+		return key && value ? {
+			key,
+			value
+		} : void 0;
+	});
 }
 function contentDuplicates(pages) {
-	const counts = /* @__PURE__ */ new Map();
-	for (const page of pages) {
-		if (!isAuditableHtmlPage(page)) continue;
-		if (page.wordCount < 20 || !page.mainContentHash) continue;
-		const existing = counts.get(page.mainContentHash) ?? {
-			count: 0,
-			sampleUrls: []
-		};
-		existing.count += 1;
-		if (existing.sampleUrls.length < 10) existing.sampleUrls.push(page.url);
-		counts.set(page.mainContentHash, existing);
-	}
-	return new Map([...counts].filter(([, value]) => value.count > 1));
+	return duplicateGroups(pages, (page) => page.wordCount >= 20 && page.mainContentHash ? {
+		key: page.mainContentHash,
+		value: page.mainContentHash
+	} : void 0);
 }
 const QUERY_STOP_WORDS = /* @__PURE__ */ new Set([
 	"a",
@@ -22820,7 +22940,7 @@ function auditCrawlPages(pages, opts = {}) {
 		if (page.accessBlock) continue;
 		if (page.status >= 500) {
 			issues.push(issue$1("server_error", page, String(page.status), { status: page.status }));
-			if ((page.internalInlinkCount ?? 0) > 0) issues.push(issue$1("broken_internal_link", page, String(page.status), {
+			if ((page.internalInlinkCount ?? 0) > 0 && !isCdnUtilityUrl(page.url)) issues.push(issue$1("broken_internal_link", page, String(page.status), {
 				status: page.status,
 				internalInlinkCount: page.internalInlinkCount
 			}));
@@ -22828,7 +22948,7 @@ function auditCrawlPages(pages, opts = {}) {
 		}
 		if (page.status >= 400) {
 			issues.push(issue$1("client_error", page, String(page.status), { status: page.status }));
-			if (isBrokenLinkStatus(page.status) && (page.internalInlinkCount ?? 0) > 0) issues.push(issue$1("broken_internal_link", page, String(page.status), {
+			if (isBrokenLinkStatus(page.status) && (page.internalInlinkCount ?? 0) > 0 && !isCdnUtilityUrl(page.url)) issues.push(issue$1("broken_internal_link", page, String(page.status), {
 				status: page.status,
 				internalInlinkCount: page.internalInlinkCount
 			}));
@@ -22927,7 +23047,7 @@ function auditCrawlPages(pages, opts = {}) {
 			title,
 			...titleWidth
 		}));
-		if (title && duplicateTitle) issues.push(issue$1("title_duplicate", page, duplicateTitle.value, {
+		if (title && duplicateTitle?.urls.has(page.url)) issues.push(issue$1("title_duplicate", page, duplicateTitle.value, {
 			title,
 			duplicateCount: duplicateTitle.count,
 			sampleUrls: duplicateTitle.sampleUrls
@@ -22935,7 +23055,7 @@ function auditCrawlPages(pages, opts = {}) {
 		const metaDescription = page.metaDescription?.trim();
 		const duplicateDescription = duplicateDescriptions.get(normalizedMetadata(metaDescription) ?? "");
 		if (!metaDescription) issues.push(issue$1("missing_meta_description", page));
-		if (metaDescription && duplicateDescription) issues.push(issue$1("meta_description_duplicate", page, duplicateDescription.value, {
+		if (metaDescription && duplicateDescription?.urls.has(page.url)) issues.push(issue$1("meta_description_duplicate", page, duplicateDescription.value, {
 			metaDescription,
 			duplicateCount: duplicateDescription.count,
 			sampleUrls: duplicateDescription.sampleUrls
@@ -22983,7 +23103,7 @@ function auditCrawlPages(pages, opts = {}) {
 			finalUrl: page.finalUrl
 		}));
 		const contentDuplicate = page.mainContentHash ? duplicateContent.get(page.mainContentHash) : void 0;
-		if (contentDuplicate) issues.push(issue$1("duplicate_content", page, "Duplicate main content", {
+		if (contentDuplicate?.urls.has(page.url)) issues.push(issue$1("duplicate_content", page, "Duplicate main content", {
 			mainContentHash: page.mainContentHash,
 			duplicateCount: contentDuplicate.count,
 			sampleUrls: contentDuplicate.sampleUrls
@@ -23051,6 +23171,7 @@ function auditCrawlPages(pages, opts = {}) {
 // packages/core/dist/analyze/crawler/crawl-skip-reasons.js
 const CRAWL_SKIP_REASONS = [
 	"asset-url",
+	"cdn-utility-url",
 	"configured-exclusion",
 	"duplicate-normalization",
 	"invalid-url",
@@ -23058,12 +23179,14 @@ const CRAWL_SKIP_REASONS = [
 	"off-origin",
 	"origin-backpressure",
 	"queue-safety-limit",
+	"query-variant-limit",
 	"robots-disallowed",
 	"robots-uncertain",
 	"legacy-unclassified"
 ];
 const SKIP_IMPACT = {
 	"asset-url": "non-impacting",
+	"cdn-utility-url": "non-impacting",
 	"configured-exclusion": "non-impacting",
 	"duplicate-normalization": "non-impacting",
 	"invalid-url": "non-impacting",
@@ -23071,6 +23194,7 @@ const SKIP_IMPACT = {
 	"off-origin": "non-impacting",
 	"origin-backpressure": "coverage-affecting",
 	"queue-safety-limit": "coverage-affecting",
+	"query-variant-limit": "coverage-affecting",
 	"robots-disallowed": "coverage-affecting",
 	"robots-uncertain": "coverage-affecting",
 	"legacy-unclassified": "coverage-affecting"
@@ -23123,157 +23247,85 @@ function crawlSkipReasonCountsFromRecord(input = {}) {
 		count
 	})) }).skipReasons;
 }
-// packages/core/dist/analyze/crawler/top-fixes.js
-const SEVERITY_SCORE = {
-	high: 5e3,
-	medium: 1200,
-	low: 100
-};
-const EFFORT_BY_CATEGORY = {
-	canonical: "medium",
-	content: "high",
-	agents: "low",
-	headings: "low",
-	images: "medium",
-	indexability: "medium",
-	international: "low",
-	metadata: "low",
-	mobile: "low",
-	response: "medium",
-	security: "medium",
-	social: "low",
-	"structured-data": "medium"
-};
-const EFFORT_SCORE = {
-	low: 60,
-	medium: 30,
-	high: 0
-};
-const AFFECTED_URL_WEIGHT = {
-	high: 25,
-	medium: 15,
-	low: 2
-};
-const VALUE_WEIGHT = {
-	high: 1,
-	medium: .75,
-	low: .15
-};
-function matchesPattern(pattern, value) {
-	if (!pattern.includes("*")) return value.includes(pattern);
-	const parts = pattern.split("*");
-	let position = 0;
-	for (const part of parts) {
-		if (!part) continue;
-		const found = value.slice(position).indexOf(part);
-		if (found === -1) return false;
-		position += found + part.length;
-	}
-	return true;
+// packages/core/dist/analyze/crawler/crawl-url-queue.js
+function before(left, right) {
+	return left.depth < right.depth || left.depth === right.depth && left.url < right.url;
 }
-function filteredIssues(report, filters) {
-	return report.issues.filter((issue) => {
-		if (filters.category && issue.category !== filters.category) return false;
-		if (filters.severity && issue.severity !== filters.severity) return false;
-		if (filters.url && !matchesPattern(filters.url, issue.url)) return false;
-		if ((filters.recommendation ?? "fix") !== recommendationForRule(issue.ruleId)) return false;
+var CrawlUrlQueue = class {
+	#items = [];
+	#positions = /* @__PURE__ */ new Map();
+	get size() {
+		return this.#items.length;
+	}
+	has(url) {
+		return this.#positions.has(url);
+	}
+	push(item) {
+		if (this.has(item.url)) throw new Error(`URL is already queued: ${item.url}`);
+		const index = this.#items.length;
+		this.#items.push(item);
+		this.#positions.set(item.url, index);
+		this.#bubbleUp(index);
+	}
+	decreaseDepth(url, depth) {
+		const index = this.#positions.get(url);
+		if (index === void 0) return false;
+		const item = this.#items[index];
+		if (!item || depth >= item.depth) return false;
+		item.depth = depth;
+		this.#bubbleUp(index);
 		return true;
-	});
-}
-function groupIssues(issues) {
-	const groups = /* @__PURE__ */ new Map();
-	for (const issue of issues) {
-		const existing = groups.get(issue.ruleId) ?? {
-			ruleId: issue.ruleId,
-			title: issue.title,
-			category: issue.category,
-			severity: issue.severity,
-			count: 0,
-			sampleUrls: []
-		};
-		existing.count += 1;
-		if (existing.sampleUrls.length < 10) existing.sampleUrls.push(issue.url);
-		groups.set(issue.ruleId, existing);
 	}
-	return [...groups.values()];
-}
-function searchValueForGroup(report, urls) {
-	const wanted = new Set(urls);
-	const pages = report.pages.filter((page) => wanted.has(page.url) || wanted.has(page.finalUrl));
-	const metrics = pages.map((page) => page.searchMetrics).filter((item) => Boolean(item));
-	const clicks = metrics.reduce((sum, item) => sum + item.clicks, 0);
-	const impressions = metrics.reduce((sum, item) => sum + item.impressions, 0);
-	const sessions = pages.reduce((sum, page) => sum + (page.analytics?.sessions ?? 0), 0);
-	const observedMetrics = new Set(report.dataSources?.analytics.observedMetrics ?? [
-		"sessions",
-		"totalUsers",
-		"conversions"
-	]);
-	const totalUsers = observedMetrics.has("totalUsers") ? pages.reduce((sum, page) => sum + (page.analytics?.totalUsers ?? 0), 0) : void 0;
-	const conversions = observedMetrics.has("conversions") ? pages.reduce((sum, page) => sum + (page.analytics?.conversions ?? 0), 0) : void 0;
-	const avgPosition = metrics.length ? metrics.reduce((sum, item) => sum + item.position, 0) / metrics.length : void 0;
-	return {
-		searchVisibleUrls: metrics.length,
-		clicks,
-		impressions,
-		sessions,
-		totalUsers,
-		conversions,
-		avgPosition
-	};
-}
-function whyThisRanks(input, recommendation, searchStatus, analyticsProvider) {
-	const visibility = input.searchVisibleUrls ? `${input.searchVisibleUrls} affected URLs have GSC visibility (${input.clicks} clicks, ${input.impressions} impressions).` : searchStatus && !["joined", "none"].includes(searchStatus) ? `No joined GSC visibility is available for these affected URLs; Search Console evidence is ${searchStatus}.` : "No affected URL has joined GSC visibility yet.";
-	const analyticsDetails = analyticsProvider ? analyticsProviderDetails(analyticsProvider) : analyticsProviderDetails("google");
-	const analyticsLabel = analyticsDetails.label;
-	const sessionLabel = analyticsDetails.landingMetricLabel;
-	return `${visibility}${input.sessions ? ` ${analyticsLabel} adds ${input.sessions} ${sessionLabel}${input.conversions === void 0 ? "" : ` and ${input.conversions} conversions`} from affected pages.` : ""} ${recommendation === "review" ? "This is a review observation. Confirm it before scheduling implementation work." : `This ranks as a fix. Severity is ${input.severity}; ${input.affectedUrls} URL${input.affectedUrls === 1 ? " is" : "s are"} affected; estimated effort is ${input.effort}.`}`;
-}
-function verificationCommand(report, severity) {
-	return `seo crawl ${report.config.url} --severity ${severity} --max-pages ${Math.min(report.config.maxPages, 100)}`;
-}
-function topFixes(report, filters = {}) {
-	return groupIssues(filteredIssues(report, filters)).map((group) => {
-		const search = searchValueForGroup(report, group.sampleUrls);
-		const effort = EFFORT_BY_CATEGORY[group.category] ?? "medium";
-		const scoreFactors = {
-			severity: SEVERITY_SCORE[group.severity],
-			affectedUrls: group.count,
-			searchVisibleUrls: search.searchVisibleUrls,
-			clicks: search.clicks,
-			impressions: search.impressions,
-			sessions: search.sessions,
-			totalUsers: search.totalUsers,
-			conversions: search.conversions,
-			avgPosition: search.avgPosition,
-			effort,
-			effortScore: EFFORT_SCORE[effort]
-		};
-		const valueWeight = VALUE_WEIGHT[group.severity];
-		const score = scoreFactors.severity + scoreFactors.affectedUrls * AFFECTED_URL_WEIGHT[group.severity] + scoreFactors.searchVisibleUrls * 100 * valueWeight + scoreFactors.clicks * 20 * valueWeight + Math.min(scoreFactors.impressions, 1e4) / 25 * valueWeight + scoreFactors.sessions * 2 * valueWeight + (scoreFactors.conversions ?? 0) * 100 * valueWeight + scoreFactors.effortScore;
-		const rule = explainRule(group.ruleId);
-		const recommendation = recommendationForRule(group.ruleId);
-		return {
-			...group,
-			recommendation,
-			score: Math.round(score),
-			scoreFactors,
-			whyThisRanks: whyThisRanks(scoreFactors, recommendation, report.dataSources?.searchConsole.status, report.dataSources?.analytics.provider),
-			howToFix: rule?.howToFix ?? "",
-			howToVerify: rule?.howToVerify ?? "",
-			verification: {
-				command: verificationCommand(report, group.severity),
-				expected: rule?.howToVerify ?? ""
-			}
-		};
-	}).sort((a, b) => b.score - a.score || SEVERITY_SCORE[b.severity] - SEVERITY_SCORE[a.severity] || b.count - a.count || a.ruleId.localeCompare(b.ruleId)).slice(0, filters.limit ?? 10);
-}
-function reviewObservations(report, filters = {}) {
-	return topFixes(report, {
-		...filters,
-		recommendation: "review"
-	});
-}
+	take() {
+		const first = this.#items[0];
+		if (!first) return void 0;
+		const last = this.#items.pop();
+		this.#positions.delete(first.url);
+		if (last && last !== first) {
+			this.#items[0] = last;
+			this.#positions.set(last.url, 0);
+			this.#bubbleDown(0);
+		}
+		return first;
+	}
+	#swap(left, right) {
+		const leftItem = this.#items[left];
+		const rightItem = this.#items[right];
+		if (!leftItem || !rightItem) return;
+		this.#items[left] = rightItem;
+		this.#items[right] = leftItem;
+		this.#positions.set(rightItem.url, left);
+		this.#positions.set(leftItem.url, right);
+	}
+	#bubbleUp(start) {
+		let index = start;
+		while (index > 0) {
+			const parent = Math.floor((index - 1) / 2);
+			const item = this.#items[index];
+			const parentItem = this.#items[parent];
+			if (!item || !parentItem || !before(item, parentItem)) break;
+			this.#swap(index, parent);
+			index = parent;
+		}
+	}
+	#bubbleDown(start) {
+		let index = start;
+		while (true) {
+			const left = index * 2 + 1;
+			const right = left + 1;
+			let next = index;
+			const item = this.#items[next];
+			const leftItem = this.#items[left];
+			const rightItem = this.#items[right];
+			if (leftItem && item && before(leftItem, item)) next = left;
+			const nextItem = this.#items[next];
+			if (rightItem && nextItem && before(rightItem, nextItem)) next = right;
+			if (next === index) return;
+			this.#swap(index, next);
+			index = next;
+		}
+	}
+};
 // packages/core/dist/analyze/crawler/report.js
 const MAX_CRAWL_PAGES = 1e4;
 const MAX_CRAWL_CONCURRENCY = 16;
@@ -23443,6 +23495,10 @@ function sanitizeMessages(values = []) {
 function compareText$15(left, right) {
 	return left < right ? -1 : left > right ? 1 : 0;
 }
+function compareCaveats(left, right) {
+	const rank = (value) => value.startsWith("Coverage incomplete:") ? 0 : 1;
+	return rank(left) - rank(right) || compareText$15(left, right);
+}
 function sortPages(pages) {
 	return [...pages].sort((left, right) => compareText$15(left.url, right.url));
 }
@@ -23677,9 +23733,229 @@ function createCrawlReport(input) {
 		...input.externalLinkVerification ? { externalLinkVerification: sanitizeTenantValue(input.externalLinkVerification) } : {},
 		...input.siteChecks ? { siteChecks: sanitizeTenantValue(input.siteChecks) } : {},
 		warnings: sanitizeMessages(input.warnings).sort(compareText$15),
-		caveats: sanitizeMessages(input.caveats).sort(compareText$15)
+		caveats: sanitizeMessages(input.caveats).sort(compareCaveats)
 	};
 }
+// packages/core/dist/analyze/crawler/crawl-caveats.js
+/** Reports rank a caveat with this prefix first and lead with it. */
+const CRAWL_COVERAGE_CAVEAT_PREFIX = "Coverage incomplete:";
+function rateLimitRerunCommand(config, intervalMs) {
+	const scope = config.strategy === "health" ? " --health" : config.mode === "site" ? "" : ` --mode ${config.mode}`;
+	const sitemap = config.sitemapUrl ? ` --sitemap-url ${config.sitemapUrl}` : "";
+	const slowMs = Math.min(8e3, Math.max(2e3, intervalMs * 2));
+	return `seo crawl ${config.url}${scope}${sitemap} --max-pages ${config.maxPages} --concurrency 1 --fetch-interval-cap 1 --fetch-interval-ms ${slowMs}`;
+}
+/** Set when the sitemaps list more URLs than the page limit let the crawl read. */
+function sitemapLimitCaveatInput(config, discovery, defaulted) {
+	if (!discovery || discovery.urlsReturned < config.maxPages || !discovery.roots.some((root) => root.possiblyTruncated)) return;
+	return {
+		maxPages: config.maxPages,
+		defaulted,
+		ceiling: MAX_CRAWL_PAGES,
+		health: config.strategy === "health",
+		url: config.url
+	};
+}
+function crawlCaveats(input) {
+	const caveats = input.cancelled ? ["Crawl cancelled before all queued URLs finished."] : input.pageLimitReached ? [`Stopped after reaching maxPages (${input.maxPages}).`] : [];
+	if (input.queueSafetySkippedUrls > 0) caveats.push(input.queueSafetyInventoryCapped ? `Left at least ${input.queueSafetySkippedUrls} unique eligible same-origin URLs unqueued to keep this crawl bounded. The excluded-URL inventory reached its reporting cap. Increase --max-pages to inspect more.` : `Left ${input.queueSafetySkippedUrls} unique eligible same-origin URLs unqueued to keep this crawl bounded. Increase --max-pages to inspect more.`);
+	if (input.originBackpressureSkippedUrls > 0) caveats.push(`Stopped ${input.originBackpressureSkippedUrls} queued URL${input.originBackpressureSkippedUrls === 1 ? "" : "s"} because the origin stayed slow. This is incomplete crawl evidence, not a failed URL check.`);
+	if (input.rateLimit) {
+		const { readPages, skippedUrls, rerunCommand } = input.rateLimit;
+		caveats.push(`${CRAWL_COVERAGE_CAVEAT_PREFIX} read ${readPages} of ${readPages + skippedUrls} pages because the origin kept rate limiting the crawl (HTTP 429) after it backed off. Rerun slower: ${rerunCommand}`);
+	}
+	if (input.sitemapLimit) {
+		const { maxPages, defaulted, ceiling, health, url } = input.sitemapLimit;
+		caveats.push(`Checked only the first ${maxPages} sitemap URLs because the page limit is ${maxPages}${defaulted ? " by default" : ""}, and the sitemaps list more. Raise --max-pages, up to ${ceiling.toLocaleString("en-US")}, to check more: seo crawl ${url}${health ? " --health" : ""} --max-pages ${ceiling}`);
+	}
+	if (input.memoryPressureSkippedUrls > 0) caveats.push(`Left ${input.memoryPressureSkippedUrls} eligible URL${input.memoryPressureSkippedUrls === 1 ? "" : "s"} unchecked after the local memory safety limit was reached. Start with --health or lower --max-pages.`);
+	const renderingFallbackUrls = input.renderingFallbackUrls ?? 0;
+	if (renderingFallbackUrls > 0) caveats.push(`JavaScript rendering could not run for ${renderingFallbackUrls} page${renderingFallbackUrls === 1 ? "" : "s"}, so ${renderingFallbackUrls === 1 ? "it was" : "they were"} audited from raw HTML. Client-rendered content, metadata and links may be missing. Install Chromium or set SEO_BROWSER_EXECUTABLE_PATH, then rerun.`);
+	const queryVariantSkippedUrls = input.queryVariantSkippedUrls ?? 0;
+	if (queryVariantSkippedUrls > 0) caveats.push(`Left ${queryVariantSkippedUrls} query-string variant${queryVariantSkippedUrls === 1 ? "" : "s"} unqueued after 5 variants of the same path, so tracking parameters do not fill the crawl.`);
+	for (const issue of input.reachIssues ?? []) if (issue.detail) caveats.push(issue.detail);
+	return caveats;
+}
+/**
+* A site crawl that found no internal links on the start page and no sitemap
+* URLs checked one page, so its other findings cannot stand for the site.
+*/
+function crawlReachIssues(input) {
+	const [page] = input.pages;
+	if (input.crawledPages !== 1 || input.pages.length !== 1 || !page || page.outgoingInternalCount > 0 || input.sitemapUrlsReturned > 0) return [];
+	const rule = explainRule("crawl_single_page_reach");
+	if (!rule) throw new Error("Missing rule guidance for crawl_single_page_reach");
+	return [{
+		ruleId: "crawl_single_page_reach",
+		title: rule.title,
+		category: rule.category,
+		severity: rule.defaultSeverity,
+		url: page.url,
+		detail: page.usedJs ? "The rendered start page had 0 internal links and no sitemap returned URLs, so the crawl checked only this page. List the pages to check with --mode list." : "The start page had 0 internal links in its HTML and no sitemap returned URLs, so the crawl checked only this page. It probably builds its links with JavaScript. Rerun with --rendering on, or list the pages with --mode list.",
+		evidence: {
+			startUrl: input.startUrl,
+			crawledPages: 1,
+			outgoingInternalCount: 0,
+			sitemapUrlsReturned: 0,
+			rendered: Boolean(page.usedJs)
+		}
+	}];
+}
+// packages/core/dist/analyze/crawler/top-fixes.js
+const SEVERITY_SCORE = {
+	high: 5e3,
+	medium: 1200,
+	low: 100
+};
+const EFFORT_BY_CATEGORY = {
+	canonical: "medium",
+	content: "high",
+	agents: "low",
+	headings: "low",
+	images: "medium",
+	indexability: "medium",
+	international: "low",
+	metadata: "low",
+	mobile: "low",
+	response: "medium",
+	security: "medium",
+	social: "low",
+	"structured-data": "medium"
+};
+const EFFORT_SCORE = {
+	low: 60,
+	medium: 30,
+	high: 0
+};
+const AFFECTED_URL_WEIGHT = {
+	high: 25,
+	medium: 15,
+	low: 2
+};
+const VALUE_WEIGHT = {
+	high: 1,
+	medium: .75,
+	low: .15
+};
+const CRAWL_REACH_RULES = /* @__PURE__ */ new Set(["crawl_single_page_reach"]);
+function reachRank(ruleId) {
+	return CRAWL_REACH_RULES.has(ruleId) ? 0 : 1;
+}
+function matchesPattern(pattern, value) {
+	if (!pattern.includes("*")) return value.includes(pattern);
+	const parts = pattern.split("*");
+	let position = 0;
+	for (const part of parts) {
+		if (!part) continue;
+		const found = value.slice(position).indexOf(part);
+		if (found === -1) return false;
+		position += found + part.length;
+	}
+	return true;
+}
+function filteredIssues(report, filters) {
+	return report.issues.filter((issue) => {
+		if (filters.category && issue.category !== filters.category) return false;
+		if (filters.severity && issue.severity !== filters.severity) return false;
+		if (filters.url && !matchesPattern(filters.url, issue.url)) return false;
+		if ((filters.recommendation ?? "fix") !== recommendationForRule(issue.ruleId)) return false;
+		return true;
+	});
+}
+function groupIssues(issues) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const issue of issues) {
+		const existing = groups.get(issue.ruleId) ?? {
+			ruleId: issue.ruleId,
+			title: issue.title,
+			category: issue.category,
+			severity: issue.severity,
+			count: 0,
+			sampleUrls: []
+		};
+		existing.count += 1;
+		if (existing.sampleUrls.length < 10) existing.sampleUrls.push(issue.url);
+		groups.set(issue.ruleId, existing);
+	}
+	return [...groups.values()];
+}
+function searchValueForGroup(report, urls) {
+	const wanted = new Set(urls);
+	const pages = report.pages.filter((page) => wanted.has(page.url) || wanted.has(page.finalUrl));
+	const metrics = pages.map((page) => page.searchMetrics).filter((item) => Boolean(item));
+	const clicks = metrics.reduce((sum, item) => sum + item.clicks, 0);
+	const impressions = metrics.reduce((sum, item) => sum + item.impressions, 0);
+	const sessions = pages.reduce((sum, page) => sum + (page.analytics?.sessions ?? 0), 0);
+	const observedMetrics = new Set(report.dataSources?.analytics.observedMetrics ?? [
+		"sessions",
+		"totalUsers",
+		"conversions"
+	]);
+	const totalUsers = observedMetrics.has("totalUsers") ? pages.reduce((sum, page) => sum + (page.analytics?.totalUsers ?? 0), 0) : void 0;
+	const conversions = observedMetrics.has("conversions") ? pages.reduce((sum, page) => sum + (page.analytics?.conversions ?? 0), 0) : void 0;
+	const avgPosition = metrics.length ? metrics.reduce((sum, item) => sum + item.position, 0) / metrics.length : void 0;
+	return {
+		searchVisibleUrls: metrics.length,
+		clicks,
+		impressions,
+		sessions,
+		totalUsers,
+		conversions,
+		avgPosition
+	};
+}
+function whyThisRanks(input, recommendation, searchStatus, analyticsProvider) {
+	const visibility = input.searchVisibleUrls ? `${input.searchVisibleUrls} affected URLs have GSC visibility (${input.clicks} clicks, ${input.impressions} impressions).` : searchStatus && !["joined", "none"].includes(searchStatus) ? `No joined GSC visibility is available for these affected URLs; Search Console evidence is ${searchStatus}.` : "No affected URL has joined GSC visibility yet.";
+	const analyticsDetails = analyticsProvider ? analyticsProviderDetails(analyticsProvider) : analyticsProviderDetails("google");
+	const analyticsLabel = analyticsDetails.label;
+	const sessionLabel = analyticsDetails.landingMetricLabel;
+	return `${visibility}${input.sessions ? ` ${analyticsLabel} adds ${input.sessions} ${sessionLabel}${input.conversions === void 0 ? "" : ` and ${input.conversions} conversions`} from affected pages.` : ""} ${recommendation === "review" ? "This is a review observation. Confirm it before scheduling implementation work." : `This ranks as a fix. Severity is ${input.severity}; ${input.affectedUrls} URL${input.affectedUrls === 1 ? " is" : "s are"} affected; estimated effort is ${input.effort}.`}`;
+}
+function verificationCommand(report, severity) {
+	return `seo crawl ${report.config.url} --severity ${severity} --max-pages ${Math.min(report.config.maxPages, 100)}`;
+}
+function topFixes(report, filters = {}) {
+	return groupIssues(filteredIssues(report, filters)).map((group) => {
+		const search = searchValueForGroup(report, group.sampleUrls);
+		const effort = EFFORT_BY_CATEGORY[group.category] ?? "medium";
+		const scoreFactors = {
+			severity: SEVERITY_SCORE[group.severity],
+			affectedUrls: group.count,
+			searchVisibleUrls: search.searchVisibleUrls,
+			clicks: search.clicks,
+			impressions: search.impressions,
+			sessions: search.sessions,
+			totalUsers: search.totalUsers,
+			conversions: search.conversions,
+			avgPosition: search.avgPosition,
+			effort,
+			effortScore: EFFORT_SCORE[effort]
+		};
+		const valueWeight = VALUE_WEIGHT[group.severity];
+		const score = scoreFactors.severity + scoreFactors.affectedUrls * AFFECTED_URL_WEIGHT[group.severity] + scoreFactors.searchVisibleUrls * 100 * valueWeight + scoreFactors.clicks * 20 * valueWeight + Math.min(scoreFactors.impressions, 1e4) / 25 * valueWeight + scoreFactors.sessions * 2 * valueWeight + (scoreFactors.conversions ?? 0) * 100 * valueWeight + scoreFactors.effortScore;
+		const rule = explainRule(group.ruleId);
+		const recommendation = recommendationForRule(group.ruleId);
+		return {
+			...group,
+			recommendation,
+			score: Math.round(score),
+			scoreFactors,
+			whyThisRanks: whyThisRanks(scoreFactors, recommendation, report.dataSources?.searchConsole.status, report.dataSources?.analytics.provider),
+			howToFix: rule?.howToFix ?? "",
+			howToVerify: rule?.howToVerify ?? "",
+			verification: {
+				command: verificationCommand(report, group.severity),
+				expected: rule?.howToVerify ?? ""
+			}
+		};
+	}).sort((a, b) => reachRank(a.ruleId) - reachRank(b.ruleId) || b.score - a.score || SEVERITY_SCORE[b.severity] - SEVERITY_SCORE[a.severity] || b.count - a.count || a.ruleId.localeCompare(b.ruleId)).slice(0, filters.limit ?? 10);
+}
+function reviewObservations(report, filters = {}) {
+	return topFixes(report, {
+		...filters,
+		recommendation: "review"
+	});
+}
 // packages/core/dist/analyze/crawler/site-checks-schema.js
 const crawlSiteChecksSchema = z.object({ soft404: z.object({
 	status: z.enum([
@@ -24106,6 +24382,7 @@ const crawlPageSnapshotSchema = z.object({
 				source: z.enum([
 					"environment",
 					"playwright-cache",
+					"agent-browser-cache",
 					"system"
 				]),
 				product: z.string(),
@@ -24794,14 +25071,6 @@ function agentReadyIssues(input) {
 	}
 	return issues;
 }
-// packages/core/dist/analyze/crawler/crawl-caveats.js
-function crawlCaveats(input) {
-	const caveats = input.cancelled ? ["Crawl cancelled before all queued URLs finished."] : input.pageLimitReached ? [`Stopped after reaching maxPages (${input.maxPages}).`] : [];
-	if (input.queueSafetySkippedUrls > 0) caveats.push(input.queueSafetyInventoryCapped ? `Left at least ${input.queueSafetySkippedUrls} unique eligible same-origin URLs unqueued to keep this crawl bounded. The excluded-URL inventory reached its reporting cap. Increase --max-pages to inspect more.` : `Left ${input.queueSafetySkippedUrls} unique eligible same-origin URLs unqueued to keep this crawl bounded. Increase --max-pages to inspect more.`);
-	if (input.originBackpressureSkippedUrls > 0) caveats.push(`Stopped ${input.originBackpressureSkippedUrls} queued URL${input.originBackpressureSkippedUrls === 1 ? "" : "s"} because the origin stayed slow. This is incomplete crawl evidence, not a failed URL check.`);
-	if (input.memoryPressureSkippedUrls > 0) caveats.push(`Left ${input.memoryPressureSkippedUrls} eligible URL${input.memoryPressureSkippedUrls === 1 ? "" : "s"} unchecked after the local memory safety limit was reached. Start with --health or lower --max-pages.`);
-	return caveats;
-}
 // packages/core/dist/analyze/crawler/crawl-control.js
 const CRAWL_CANCELLED = Symbol("crawl-cancelled");
 function abortController(input) {
@@ -24843,83 +25112,94 @@ function crawlRssLimitBytes(totalMemoryBytes) {
 function crawlMemoryPressure(input) {
 	return input.memoryUsage.heapUsed + input.memoryUsage.external >= crawlMemoryLimitBytes(input.totalMemoryBytes) || input.memoryUsage.rss >= crawlRssLimitBytes(input.totalMemoryBytes);
 }
-// packages/core/dist/analyze/crawler/crawl-url-queue.js
-function before(left, right) {
-	return left.depth < right.depth || left.depth === right.depth && left.url < right.url;
+// packages/core/dist/analyze/crawler/crawl-rate-limit.js
+const RETRIES_PER_URL = 3;
+const BASE_BACKOFF_MS = 2e3;
+const MAX_BACKOFF_MS = 3e4;
+const COOLDOWN_BUDGET_MS = 18e4;
+const LIMITED_INTERVAL_MS = 1e3;
+const LIMITED_MAX_INTERVAL_MS = 4e3;
+function rateLimitEvidence(result, status, nowMs) {
+	if (status !== 429 && status !== 503) return void 0;
+	const header = retryAfterMs(result.page?.responseHeaders?.["retry-after"]);
+	const cooldownUntil = Date.parse(result.page?.fetchDiagnostics?.backpressure?.cooldownUntil ?? "");
+	const fromCooldown = Number.isFinite(cooldownUntil) ? Math.max(0, cooldownUntil - nowMs) : void 0;
+	const wait = header ?? fromCooldown;
+	if (status === 503 && wait === void 0) return void 0;
+	return wait === void 0 ? {} : { retryAfterMs: Math.min(wait, MAX_BACKOFF_MS) };
 }
-var CrawlUrlQueue = class {
-	#items = [];
-	#positions = /* @__PURE__ */ new Map();
-	get size() {
-		return this.#items.length;
-	}
-	has(url) {
-		return this.#positions.has(url);
-	}
-	push(item) {
-		if (this.has(item.url)) throw new Error(`URL is already queued: ${item.url}`);
-		const index = this.#items.length;
-		this.#items.push(item);
-		this.#positions.set(item.url, index);
-		this.#bubbleUp(index);
-	}
-	decreaseDepth(url, depth) {
-		const index = this.#positions.get(url);
-		if (index === void 0) return false;
-		const item = this.#items[index];
-		if (!item || depth >= item.depth) return false;
-		item.depth = depth;
-		this.#bubbleUp(index);
-		return true;
-	}
-	take() {
-		const first = this.#items[0];
-		if (!first) return void 0;
-		const last = this.#items.pop();
-		this.#positions.delete(first.url);
-		if (last && last !== first) {
-			this.#items[0] = last;
-			this.#positions.set(last.url, 0);
-			this.#bubbleDown(0);
-		}
-		return first;
-	}
-	#swap(left, right) {
-		const leftItem = this.#items[left];
-		const rightItem = this.#items[right];
-		if (!leftItem || !rightItem) return;
-		this.#items[left] = rightItem;
-		this.#items[right] = leftItem;
-		this.#positions.set(rightItem.url, left);
-		this.#positions.set(leftItem.url, right);
+/**
+* Rate-limit state for one crawl. After the first 429 the crawl drops to one
+* request at a time with a per-host interval and never speeds back up.
+*/
+var CrawlRateLimit = class {
+	rate;
+	responses = 0;
+	skippedUrls = 0;
+	pendingMs = 0;
+	spentMs = 0;
+	#level = 0;
+	#budgetSpent = false;
+	#retries = /* @__PURE__ */ new Map();
+	constructor(rate) {
+		this.rate = rate;
+	}
+	get limited() {
+		return this.responses > 0;
+	}
+	get intervalMs() {
+		return this.rate.intervalMs ?? LIMITED_INTERVAL_MS;
+	}
+	/** The cool-down before probes that run after the crawl. */
+	get settleMs() {
+		return Math.min(MAX_BACKOFF_MS, BASE_BACKOFF_MS * 2 ** this.#level);
 	}
-	#bubbleUp(start) {
-		let index = start;
-		while (index > 0) {
-			const parent = Math.floor((index - 1) / 2);
-			const item = this.#items[index];
-			const parentItem = this.#items[parent];
-			if (!item || !parentItem || !before(item, parentItem)) break;
-			this.#swap(index, parent);
-			index = parent;
-		}
+	/**
+	* `retry` requeues the URL after `pendingMs`. `skip` gives it up, and
+	* `stop` gives up the rest of the queue too once the budget is spent.
+	*/
+	observe(url, result, status, nowMs) {
+		const evidence = rateLimitEvidence(result, status, nowMs);
+		if (!evidence) return void 0;
+		this.responses += 1;
+		if (this.pendingMs === 0) this.#level += 1;
+		const step = 2 ** Math.max(0, this.#level - 1);
+		const waitMs = evidence.retryAfterMs ?? Math.min(MAX_BACKOFF_MS, BASE_BACKOFF_MS * step);
+		this.rate = {
+			...this.rate,
+			concurrency: 1,
+			intervalCap: 1,
+			intervalMs: Math.min(LIMITED_MAX_INTERVAL_MS, Math.max(this.rate.intervalMs ?? 0, LIMITED_INTERVAL_MS * step))
+		};
+		const nextMs = Math.max(this.pendingMs, waitMs);
+		if (this.spentMs + nextMs > COOLDOWN_BUDGET_MS) this.#budgetSpent = true;
+		const retries = this.#retries.get(url) ?? 0;
+		if (!this.#budgetSpent && retries < RETRIES_PER_URL) {
+			this.#retries.set(url, retries + 1);
+			this.pendingMs = nextMs;
+			return "retry";
+		}
+		this.skippedUrls += 1;
+		return this.#budgetSpent ? "stop" : "skip";
+	}
+	async settle(sleep, signal) {
+		if (this.pendingMs <= 0) return;
+		await sleep(this.pendingMs, signal);
+		this.spentMs += this.pendingMs;
+		this.pendingMs = 0;
+	}
+	caveatInput(config, readPages) {
+		if (this.skippedUrls === 0) return void 0;
+		return {
+			readPages,
+			skippedUrls: this.skippedUrls,
+			rerunCommand: rateLimitRerunCommand(config, this.intervalMs)
+		};
 	}
-	#bubbleDown(start) {
-		let index = start;
-		while (true) {
-			const left = index * 2 + 1;
-			const right = left + 1;
-			let next = index;
-			const item = this.#items[next];
-			const leftItem = this.#items[left];
-			const rightItem = this.#items[right];
-			if (leftItem && item && before(leftItem, item)) next = left;
-			const nextItem = this.#items[next];
-			if (rightItem && nextItem && before(rightItem, nextItem)) next = right;
-			if (next === index) return;
-			this.#swap(index, next);
-			index = next;
-		}
+	warning() {
+		if (!this.limited) return void 0;
+		const plural = (count, noun) => `${count} ${noun}${count === 1 ? "" : "s"}`;
+		return `The origin rate limited ${plural(this.responses, "request")}. The crawl slowed to one request at a time, at least ${Math.round(this.intervalMs / 1e3)}s apart, and waited ${Math.round(this.spentMs / 1e3)}s in cool-downs${this.skippedUrls > 0 ? `, then left ${plural(this.skippedUrls, "URL")} unread` : " before reading every queued URL"}.`;
 	}
 };
 // packages/core/dist/analyze/crawler/external-link-checks.js
@@ -25154,11 +25434,15 @@ function observationFromPage(requestedUrl, page) {
 	};
 }
 // packages/core/dist/analyze/crawler/site-checks.js
-const PROBE_COUNT = 2;
+const PROBE_COUNT = 3;
 function probeUrls(startUrl) {
 	const origin = new URL(startUrl).origin;
 	const seed = createHash("sha256").update(origin).digest("hex").slice(0, 12);
-	return Array.from({ length: PROBE_COUNT }, (_, index) => new URL(`/.well-known/seo-audit/not-found-${seed}-${index + 1}`, origin).toString());
+	return [
+		`/${seed}-not-found`,
+		`/${seed}-not-found/${seed}-missing`,
+		`/.well-known/seo-audit/not-found-${seed}-1`
+	].map((path) => new URL(path, origin).toString());
 }
 function probeObservation(url, result) {
 	const request = result.request;
@@ -25178,29 +25462,40 @@ function probeObservation(url, result) {
 		error: request.outcome === "failure" ? request.error : `Probe skipped: ${request.reason}`
 	};
 }
+function isConclusive(probe) {
+	return probe.status !== void 0 && !probe.accessBlocked && probe.status !== 429 && probe.status !== 503;
+}
 async function collectCrawlSiteChecks(input) {
+	const probe = async (url) => probeObservation(url, await input.fetchStatusPage(url, {
+		js: "off",
+		refresh: true,
+		timeoutMs: input.timeoutMs,
+		signal: input.signal,
+		writeCache: false,
+		respectRobots: input.respectRobots,
+		...input.rate ? { rate: input.rate } : {}
+	}));
 	const probes = [];
 	for (const url of probeUrls(input.startUrl)) {
 		if (input.signal?.aborted) break;
-		const result = await input.fetchStatusPage(url, {
-			js: "off",
-			refresh: true,
-			timeoutMs: input.timeoutMs,
-			signal: input.signal,
-			writeCache: false,
-			respectRobots: input.respectRobots
-		});
-		probes.push(probeObservation(url, result));
+		probes.push(await probe(url));
+	}
+	if (input.sleep && !input.signal?.aborted && probes.some((item) => !isConclusive(item))) {
+		await input.sleep(input.retryDelayMs ?? 2e3, input.signal);
+		for (const [index, item] of probes.entries()) {
+			if (input.signal?.aborted) break;
+			if (!isConclusive(item)) probes[index] = await probe(item.url);
+		}
 	}
-	const conclusive = probes.filter((probe) => probe.status !== void 0 && !probe.accessBlocked);
+	const conclusive = probes.filter(isConclusive);
 	const successful = conclusive.filter((probe) => (probe.status ?? 0) >= 200 && (probe.status ?? 0) < 400);
 	const correctMissing = conclusive.filter((probe) => probe.status === 404 || probe.status === 410);
-	const status = conclusive.length !== PROBE_COUNT ? "unknown" : successful.length === PROBE_COUNT ? "warning" : correctMissing.length === PROBE_COUNT ? "pass" : "unknown";
+	const status = successful.length > 0 ? "warning" : correctMissing.length === PROBE_COUNT ? "pass" : "unknown";
 	const checks = { soft404: {
 		status,
 		probes,
 		probeLimit: PROBE_COUNT,
-		complete: probes.length === PROBE_COUNT
+		complete: conclusive.length === PROBE_COUNT
 	} };
 	if (status !== "warning") return {
 		checks,
@@ -25216,7 +25511,7 @@ async function collectCrawlSiteChecks(input) {
 			category: rule.category,
 			severity: rule.defaultSeverity,
 			url: new URL("/", input.startUrl).toString(),
-			detail: `${successful.length} known-nonexistent paths returned a successful response or redirect.`,
+			detail: `${successful.length} of ${probes.length} made-up paths returned a successful response or redirect: ${successful.map((probe) => `${new URL(probe.url).pathname} (${probe.status})`).join(", ")}.`,
 			evidence: checks.soft404
 		}]
 	};
@@ -27648,6 +27943,18 @@ async function fetchLandingPageValues(input, dependencies = defaultDependencies$
 	}[connection.provider](connection);
 }
 // packages/core/dist/analyze/crawler/site-crawl-dependencies.js
+function sleep$2(ms, signal) {
+	return new Promise((resolve) => {
+		if (signal?.aborted) return resolve();
+		const done = () => {
+			clearTimeout(timer);
+			signal?.removeEventListener("abort", done);
+			resolve();
+		};
+		const timer = setTimeout(done, ms);
+		signal?.addEventListener("abort", done, { once: true });
+	});
+}
 function resolveCrawlSiteDependencies(dependencies = {}) {
 	const hasInjectedPerPageSearchProvider = Boolean(dependencies.queryPageMetrics || dependencies.queryPageTopQuery);
 	const hasInjectedLegacyBulkSearchProvider = Boolean(dependencies.queryPagesMetrics || dependencies.queryPagesTopQueries);
@@ -27668,6 +27975,7 @@ function resolveCrawlSiteDependencies(dependencies = {}) {
 		fetchLandingPageValues: dependencies.fetchLandingPageValues ?? fetchLandingPageValues,
 		landingValueForUrl: dependencies.landingValueForUrl ?? landingValueForUrl,
 		now: dependencies.now ?? (() => /* @__PURE__ */ new Date()),
+		sleep: dependencies.sleep ?? sleep$2,
 		memoryUsage: dependencies.memoryUsage ?? (() => process.memoryUsage()),
 		totalMemory: dependencies.totalMemory ?? totalmem
 	};
@@ -27883,6 +28191,10 @@ async function crawlSite(input, dependencies) {
 	const queueSafetyDeferredUrls = /* @__PURE__ */ new Set();
 	const maxTrackedQueueSafetyUrls = Math.min(5e4, Math.max(1e3, config.maxPages * 5));
 	let queueSafetyInventoryCapped = false;
+	const queryVariantsByPath = /* @__PURE__ */ new Map();
+	const queryVariantSkipped = /* @__PURE__ */ new Set();
+	let renderingFallbackUrls = 0;
+	const rateLimit = new CrawlRateLimit(config.fetchRate);
 	let failedUrls = 0;
 	let observedInternalLinks = 0;
 	let memoryLimited = false;
@@ -27967,6 +28279,15 @@ async function crawlSite(input, dependencies) {
 				});
 				return;
 			}
+			if (isCdnUtilityUrl(normalized)) {
+				recordSkip("cdn-utility-url");
+				emitStatus("url_skipped", {
+					url: normalized,
+					depth,
+					reason: "cdn_utility_url"
+				});
+				return;
+			}
 			if (isLikelyAsset(normalized)) {
 				recordSkip("asset-url");
 				emitStatus("url_skipped", {
@@ -27985,6 +28306,20 @@ async function crawlSite(input, dependencies) {
 				});
 				return;
 			}
+			const parsed = new URL(normalized);
+			const pathKey = parsed.search ? `${parsed.origin}${parsed.pathname}` : "";
+			if (pathKey && (queryVariantsByPath.get(pathKey) ?? 0) >= 5) {
+				if (!queryVariantSkipped.has(normalized) && queryVariantSkipped.size < maxTrackedQueueSafetyUrls) {
+					queryVariantSkipped.add(normalized);
+					recordSkip("query-variant-limit");
+					emitStatus("url_skipped", {
+						url: normalized,
+						depth,
+						reason: "query_variant_limit"
+					});
+				}
+				return;
+			}
 			if (queue.size + visited.size + inFlight.size >= config.maxPages * 5) {
 				if (!queueSafetyDeferredUrls.has(normalized)) {
 					if (queueSafetyDeferredUrls.size < maxTrackedQueueSafetyUrls) {
@@ -28000,6 +28335,7 @@ async function crawlSite(input, dependencies) {
 				}
 				return;
 			}
+			if (pathKey) queryVariantsByPath.set(pathKey, (queryVariantsByPath.get(pathKey) ?? 0) + 1);
 			discovered.add(normalized);
 			queuedUrls += 1;
 			queue.push({
@@ -28056,7 +28392,7 @@ async function crawlSite(input, dependencies) {
 					js: config.js,
 					refresh: config.refresh,
 					timeoutMs: config.timeoutMs,
-					rate: config.fetchRate,
+					rate: rateLimit.rate,
 					signal,
 					writeCache: false,
 					respectRobots: config.respectRobots,
@@ -28087,7 +28423,11 @@ async function crawlSite(input, dependencies) {
 			});
 		};
 		while (!isCancelled() && (queue.size || inFlight.size) && (!memoryLimited || inFlight.size > 0) && pages.length < config.maxPages) {
-			while (!isCancelled() && !memoryLimited && inFlight.size < activeConcurrency && pages.length + inFlight.size < config.maxPages) {
+			if (rateLimit.pendingMs > 0 && inFlight.size === 0) {
+				await rateLimit.settle(deps.sleep, signal);
+				if (isCancelled()) break;
+			}
+			while (!isCancelled() && !memoryLimited && rateLimit.pendingMs === 0 && inFlight.size < activeConcurrency && pages.length + inFlight.size < config.maxPages) {
 				const item = nextQueueItem();
 				if (!item) break;
 				startTask(item);
@@ -28107,11 +28447,46 @@ async function crawlSite(input, dependencies) {
 				error: result.warning ?? "Crawler returned no page snapshot.",
 				extraction: "not-applicable"
 			});
+			const limited = rateLimit.observe(task.url, result, request.outcome === "response" ? request.status : void 0, deps.now().getTime());
+			if (limited) {
+				activeConcurrency = 1;
+				healthyProbeStreak = 0;
+			}
+			if (limited === "retry") {
+				visited.delete(task.url);
+				if (!queue.has(task.url)) queue.push({
+					url: task.url,
+					depth: task.depth
+				});
+				emitStatus("url_queued", {
+					url: task.url,
+					depth: task.depth,
+					reason: "rate_limited_retry",
+					message: `The origin rate limited ${task.url}. Waiting ${Math.ceil(rateLimit.pendingMs / 1e3)}s, then retrying one request at a time.`
+				});
+				continue;
+			}
+			if (limited) {
+				requests.push(request);
+				recordSkip("origin-backpressure");
+				emitStatus("page_skipped", {
+					url: task.url,
+					depth: task.depth,
+					reason: "origin-backpressure"
+				});
+				if (limited === "stop") {
+					let left = 0;
+					while (queue.take()) left += 1;
+					recordSkips("origin-backpressure", left);
+					rateLimit.skippedUrls += left;
+				}
+				continue;
+			}
 			requests.push(request);
 			if (healthStrategy) {
 				if (request.outcome === "response" && request.status < 400 && !request.accessBlock) {
 					healthyProbeStreak += 1;
-					activeConcurrency = Math.min(config.concurrency, 1 + Math.floor(healthyProbeStreak / 20));
+					activeConcurrency = Math.min(rateLimit.limited ? 1 : config.concurrency, 1 + Math.floor(healthyProbeStreak / 20));
 				} else {
 					healthyProbeStreak = 0;
 					activeConcurrency = 1;
@@ -28152,6 +28527,9 @@ async function crawlSite(input, dependencies) {
 				continue;
 			}
 			const page = result.page;
+			const rendering = page.fetchDiagnostics?.rendering;
+			if (rendering?.status === "unavailable" && config.js === "on") throw new SeoError("INVALID_INPUT", `--rendering on needs a local Chrome or Chromium browser, and none could start. ${rendering.error ?? ""} Install Chromium, or set SEO_BROWSER_EXECUTABLE_PATH to a Chromium executable, then rerun. Use --rendering auto to accept raw HTML.`.replace(/\s+/g, " ").trim());
+			if (rendering?.status === "unavailable" || rendering?.status === "failed") renderingFallbackUrls += 1;
 			const finalUrl = normalizeUrl$1(page.finalUrl, config.url);
 			if (!finalUrl) {
 				failedUrls += 1;
@@ -28181,7 +28559,7 @@ async function crawlSite(input, dependencies) {
 			const storeDocument = (urls) => {
 				const sourceRequest = normalizeUrl$1(task.url, config.url) ?? task.url;
 				const directlyRequested = sourceRequest === finalUrl;
-				const normalizedLinks = urls.map((url) => normalizeUrl$1(url, finalUrl)).filter((url) => Boolean(url));
+				const normalizedLinks = urls.map((url) => normalizeUrl$1(url, finalUrl)).filter((url) => Boolean(url) && !isCdnUtilityUrl(url ?? ""));
 				const syncLinkEvidence = (target, links) => {
 					const sortedLinks = [...links].sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
 					target.outgoingInternalCount = sortedLinks.length;
@@ -28260,7 +28638,7 @@ async function crawlSite(input, dependencies) {
 			if (followLinks && task.depth < config.maxDepth) {
 				if (memoryLimited) for (const value of result.urls) {
 					const normalized = normalizeUrl$1(value, finalUrl);
-					if (normalized && sameOrigin(normalized, origin) && !isLikelyAsset(normalized) && passesFilters(normalized, config.include, config.exclude) && !visited.has(normalized) && !queue.has(normalized)) {
+					if (normalized && sameOrigin(normalized, origin) && !isCdnUtilityUrl(normalized) && !isLikelyAsset(normalized) && passesFilters(normalized, config.include, config.exclude) && !visited.has(normalized) && !queue.has(normalized)) {
 						discovered.add(normalized);
 						memoryDeferredUrls.add(normalized);
 					}
@@ -28285,6 +28663,8 @@ async function crawlSite(input, dependencies) {
 		cancelled = isCancelled();
 		const robotsDisallowed = skipReasonCounts["robots-disallowed"] ?? 0;
 		if (robotsDisallowed > 0) warnings.push(`${robotsDisallowed} URL${robotsDisallowed === 1 ? "" : "s"} disallowed ${SEO_CRAWLER_USER_AGENT} in robots.txt. If the audit should reach them, allow the SEO-Skill token on only those public paths.`);
+		const rateLimitWarning = rateLimit.warning();
+		if (rateLimitWarning) warnings.push(rateLimitWarning);
 		if (cancelled) {
 			warnings.push("Crawl cancelled; returning a partial report.");
 			emitStatus("cancelled", {
@@ -28296,7 +28676,7 @@ async function crawlSite(input, dependencies) {
 		const sitemapEvidencePartial = sitemapDiscovery?.dataStatus === "partial";
 		const accessEvidencePartial = requests.some((request) => request.outcome === "response" && request.accessBlock);
 		const requiredSitemapUnavailable = config.mode === "sitemap" && sitemapDiscovery?.dataStatus === "unavailable";
-		const partial = cancelled || failedUrls > 0 || pageLimitReached || robotsDeferredUrls > 0 || originBackpressureSkippedUrls > 0 || queueSafetySkippedUrls > 0 || queue.size > 0 || inFlight.size > 0 || stoppedForMemory || sitemapEvidencePartial || accessEvidencePartial || requiredSitemapUnavailable;
+		const partial = cancelled || failedUrls > 0 || pageLimitReached || robotsDeferredUrls > 0 || originBackpressureSkippedUrls > 0 || rateLimit.skippedUrls > 0 || queueSafetySkippedUrls > 0 || queue.size > 0 || inFlight.size > 0 || stoppedForMemory || sitemapEvidencePartial || accessEvidencePartial || requiredSitemapUnavailable;
 		const failed = !cancelled && pages.length === 0 && (requiredSitemapUnavailable || requests.length > 0 && requests.every((request) => request.outcome === "failure"));
 		const requestEvidenceStatus = cancelled && inFlight.size > 0 ? "partial" : "available";
 		const dataSources = await crawlDataSources({
@@ -28343,7 +28723,10 @@ async function crawlSite(input, dependencies) {
 			timeoutMs: config.timeoutMs,
 			fetchStatusPage: deps.fetchStatusPage,
 			respectRobots: config.respectRobots,
-			signal
+			signal,
+			rate: rateLimit.rate,
+			sleep: deps.sleep,
+			retryDelayMs: rateLimit.settleMs
 		}) : void 0;
 		for (const page of pages) {
 			if (!page.geo || !llmsTxt) continue;
@@ -28374,6 +28757,12 @@ async function crawlSite(input, dependencies) {
 				...startPage.responseHeaders?.["content-signal"] ? { contentSignal: startPage.responseHeaders["content-signal"] } : {}
 			} } : {}
 		} : aiSignals?.signals;
+		const reachIssues = followLinks && config.maxDepth > 0 && config.maxPages > 1 && !cancelled ? crawlReachIssues({
+			startUrl: config.url,
+			pages: pages.filter((page) => page.status >= 200 && page.status < 300),
+			crawledPages: pages.length,
+			sitemapUrlsReturned: sitemapDiscovery?.urlsReturned ?? 0
+		}) : [];
 		const report = createCrawlReport({
 			config,
 			site,
@@ -28388,6 +28777,7 @@ async function crawlSite(input, dependencies) {
 			...externalLinkVerification ? { externalLinkVerification } : {},
 			...siteCheckResult ? { siteChecks: siteCheckResult.checks } : {},
 			additionalIssues: [
+				...reachIssues,
 				...siteCheckResult?.issues ?? [],
 				...sitemapDiscovery ? sitemapHostIssues(sitemapDiscovery, config.url) : [],
 				...ai ? agentReadyIssues({
@@ -28405,7 +28795,12 @@ async function crawlSite(input, dependencies) {
 				queueSafetySkippedUrls,
 				queueSafetyInventoryCapped,
 				originBackpressureSkippedUrls,
-				memoryPressureSkippedUrls
+				rateLimit: rateLimit.caveatInput(config, pages.length),
+				sitemapLimit: sitemapLimitCaveatInput(config, sitemapDiscovery, input.maxPages === void 0),
+				memoryPressureSkippedUrls,
+				queryVariantSkippedUrls: queryVariantSkipped.size,
+				renderingFallbackUrls,
+				reachIssues
 			}),
 			stats: {
 				discoveredUrls: discovered.size,
@@ -28958,7 +29353,7 @@ function analyzeCtrUnderperformersFromRows(input) {
 // packages/core/dist/analyze/ctr-underperformers-report.js
 const MAX_GSC_ROWS$3 = 1e5;
 const DEFAULT_DAYS$3 = 28;
-const MAX_DAYS$2 = 548;
+const MAX_DAYS$3 = 548;
 function plural$8(count, singular, pluralLabel = `${singular}s`) {
 	return count === 1 ? singular : pluralLabel;
 }
@@ -28977,12 +29372,12 @@ async function ctrUnderperformersReportWith(input, dependencies) {
 		maximum: 100,
 		label: "limit"
 	});
-	const explicitRange = explicitDateRange(input, MAX_DAYS$2);
+	const explicitRange = explicitDateRange(input, MAX_DAYS$3);
 	const days = explicitRange?.days ?? integerOption$1({
 		value: input.days,
 		fallback: DEFAULT_DAYS$3,
 		minimum: 1,
-		maximum: MAX_DAYS$2,
+		maximum: MAX_DAYS$3,
 		label: "Days"
 	});
 	const now = dependencies.now();
@@ -32171,7 +32566,7 @@ function quickWinTemplateSummaries(items) {
 }
 // packages/core/dist/analyze/site-diagnostics/quick-wins-report.js
 const DEFAULT_DAYS$2 = 28;
-const MAX_DAYS$1 = 548;
+const MAX_DAYS$2 = 548;
 const DEFAULT_VERIFY_LIMIT$1 = 5;
 const MAX_VERIFY_LIMIT = 100;
 const MAX_SOURCE_ROWS$2 = 1e5;
@@ -32189,12 +32584,12 @@ function applyVerification$1(item, coverage) {
 	};
 }
 async function quickWinsReportWith(input, dependencies) {
-	const explicitRange = explicitDateRange(input, MAX_DAYS$1);
+	const explicitRange = explicitDateRange(input, MAX_DAYS$2);
 	const days = explicitRange?.days ?? integerOption$1({
 		value: input.days,
 		fallback: DEFAULT_DAYS$2,
 		minimum: 1,
-		maximum: MAX_DAYS$1,
+		maximum: MAX_DAYS$2,
 		label: "Days"
 	});
 	const verifyLimit = integerOption$1({
@@ -32613,7 +33008,7 @@ function analyzeStrikingDistanceRows(input) {
 }
 // packages/core/dist/analyze/striking-distance-report.js
 const DEFAULT_DAYS$1 = 28;
-const MAX_DAYS = 548;
+const MAX_DAYS$1 = 548;
 const DEFAULT_VERIFY_LIMIT = 5;
 const MAX_SOURCE_ROWS$1 = 1e5;
 function boundedInteger$2(value, fallback, minimum, maximum) {
@@ -32622,7 +33017,7 @@ function boundedInteger$2(value, fallback, minimum, maximum) {
 }
 function reportDays(value) {
 	if (value === void 0) return DEFAULT_DAYS$1;
-	if (!Number.isInteger(value) || value < 1 || value > MAX_DAYS) throw new SeoError("INVALID_INPUT", `Days must be a whole number between 1 and ${MAX_DAYS}.`);
+	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}.`);
 	return value;
 }
 function dateRange(days, now) {
@@ -32662,7 +33057,7 @@ function verdict$1(analysis) {
 	return `${countLabel(analysis.summary.eligibleRows, "eligible query/page row")} found; ${countLabel(analysis.summary.returnedRows, "row")} returned for review.`;
 }
 async function strikingDistanceWith(input, dependencies) {
-	const explicitRange = explicitDateRange(input, MAX_DAYS);
+	const explicitRange = explicitDateRange(input, MAX_DAYS$1);
 	const days = explicitRange?.days ?? reportDays(input.days);
 	const generatedAt = dependencies.now().toISOString();
 	const range = explicitRange?.range ?? dateRange(days, new Date(generatedAt));
@@ -41868,6 +42263,7 @@ const wait = (ms) => new Promise((done) => setTimeout(done, ms));
 function requireInput(input) {
 	const needsKeywords = input.action === "keyword_metrics" || input.action === "serp";
 	if (needsKeywords && input.keywords.length === 0) throw new CommandError("INVALID_INPUT", `${input.action} needs keywords.`);
+	if (input.action === "link_gap" && !input.target) throw new CommandError("INVALID_INPUT", "link_gap needs a target domain and competitors.");
 	if (!needsKeywords && !input.target) throw new CommandError("INVALID_INPUT", `${input.action} needs a target domain or URL.`);
 }
 async function eachKeyword(keywords, missed, rowsFor) {
@@ -41885,14 +42281,17 @@ async function eachKeyword(keywords, missed, rowsFor) {
 }
 async function research(provider, headers, input) {
 	requireInput(input);
+	if (input.action === "link_gap") return linkGap(provider, headers, input);
 	const keys = need(headers, provider);
 	if (provider === "dataforseo") return dataForSeo(keys, input);
 	const missed = [];
+	const rows = await ahrefs(keys[0] ?? "", input, missed);
 	return {
-		rows: await ahrefs(keys[0] ?? "", input, missed),
+		rows,
 		costUsd: null,
 		partial: false,
-		missed
+		missed,
+		noData: withoutData(input, rows, missed, 100)
 	};
 }
 function countryName(code) {
@@ -41944,7 +42343,8 @@ async function dataForSeoTask([login, password], path, task) {
 	if (result?.status_code === NO_RESULTS) return {
 		cost: result.cost ?? 0,
 		result: null,
-		partial: false
+		partial: false,
+		noResults: true
 	};
 	if (!result || result.status_code >= 4e4 && result.status_code !== PARTIAL) throw Object.assign(new CommandError("PROVIDER_ERROR", `dataforseo: ${result?.status_message ?? "no task result"}`), { cost: result?.cost ?? 0 });
 	return {
@@ -41985,18 +42385,29 @@ async function dataForSeo(keys, input) {
 		partial: false,
 		missed: []
 	};
+	const rows = await dataForSeoRows(keys, input, spent);
 	return {
-		rows: await dataForSeoRows(keys, input, spent),
+		rows,
 		costUsd: Math.round(spent.cost * 1e4) / 1e4,
 		partial: spent.partial,
-		missed: spent.missed
+		missed: spent.missed,
+		noData: withoutData(input, rows, spent.missed, 700)
 	};
 }
+function withoutData(input, rows, missed, keywordLimit) {
+	if (input.action === "keyword_metrics" || input.action === "serp") {
+		const max = input.action === "serp" ? 5 : keywordLimit;
+		const answered = new Set(rows.map((row) => String(row.keyword ?? "").toLowerCase()));
+		const failed = new Set(missed);
+		return input.keywords.slice(0, max).filter((keyword) => !failed.has(keyword) && !answered.has(keyword.toLowerCase()));
+	}
+	return [];
+}
 async function dataForSeoRows(keys, input, spent) {
 	const language = dataForSeoLanguage(input.country);
 	if (!language && input.action !== "serp" && input.action !== "backlinks") throw new CommandError("INVALID_INPUT", `DataForSEO has no ${input.action} data for country "${input.country}".`);
 	const market = dataForSeoMarket(input.country, language);
-	const post = async (path, task) => {
+	const post = async (path, task, attempts = 1) => {
 		const done = await dataForSeoTask(keys, path, {
 			...market,
 			...task
@@ -42006,6 +42417,7 @@ async function dataForSeoRows(keys, input, spent) {
 		});
 		spent.cost += done.cost;
 		spent.partial ||= done.partial;
+		if (done.noResults && attempts > 1) return post(path, task, attempts - 1);
 		return done.result?.items ?? [];
 	};
 	const get = (value, path) => path.split(".").reduce((current, key) => current && typeof current === "object" ? current[key] : void 0, value);
@@ -42035,7 +42447,7 @@ async function dataForSeoRows(keys, input, spent) {
 		return (await post("v3/serp/google/organic/live/advanced", {
 			keyword,
 			depth: Math.min(input.limit, 100)
-		})).filter((item) => item.type === "organic").map((item) => {
+		}, 2)).filter((item) => item.type === "organic").map((item) => {
 			const row = pick(item, {
 				position: "rank_absolute",
 				url: "url",
@@ -42043,9 +42455,11 @@ async function dataForSeoRows(keys, input, spent) {
 				title: "title"
 			});
 			if (/^https?:\/\/(www\.)?google\.[a-z.]+\/goto\b/.test(String(row.url))) {
-				const site = /^https?:\/\/([^/\s›]+)/.exec(String(item.breadcrumb ?? ""));
+				const crumb = String(item.breadcrumb ?? "");
+				const site = /^https?:\/\/([^/\s›]+)/.exec(crumb);
 				row.url = null;
 				row.domain = site?.[1] ?? null;
+				row.url_hint = site ? crumb.replace(/^https?:\/\//, "") : null;
 			}
 			return {
 				keyword,
@@ -42075,6 +42489,93 @@ async function dataForSeoRows(keys, input, spent) {
 		organic_etv: "full_domain_metrics.organic.etv"
 	}));
 }
+const GAP_DOMAINS = 1e3;
+const GAP_COMPETITORS = 5;
+const SHORTENERS = [
+	"bit.ly",
+	"tinyurl.com",
+	"t.co",
+	"ow.ly",
+	"buff.ly",
+	"is.gd",
+	"cutt.ly",
+	"rebrand.ly",
+	"shorturl.at",
+	"rb.gy",
+	"lnkd.in"
+];
+const FREE_APP_HOSTS = [
+	"web.app",
+	"firebaseapp.com",
+	"pages.dev"
+];
+const LINK_LIST_NAME = /(subdomain|whois|login|signin|coupon|promo|voucher|discount|sitelike|similarsite|sitesimilar|siteprice|sitevalue|siteworth|websiteworth|hypestat|statshow|websiteoutlook|siteinfo|domaininfo|domainstat|domaintools|ipaddress|dnslookup|linkdirectory|webdirectory|alternativeto-)/;
+function isLinkList(domain) {
+	const within = (name) => domain === name || domain.endsWith(`.${name}`);
+	if (SHORTENERS.some(within)) return true;
+	if (FREE_APP_HOSTS.some((name) => domain.endsWith(`.${name}`))) return true;
+	return LINK_LIST_NAME.test(domain.replace(/[-.]/g, ""));
+}
+async function linkGap(provider, headers, input) {
+	const target = bareTarget(input.target).replace(/^www\./, "");
+	const competitors = [...new Set((input.competitors ?? []).map((site) => bareTarget(site).replace(/^www\./, "")))].filter((site) => site && site !== target);
+	if (competitors.length < 2 || competitors.length > GAP_COMPETITORS) throw new CommandError("INVALID_INPUT", `link_gap needs a target and 2 to ${GAP_COMPETITORS} competitors.`);
+	const score = provider === "ahrefs" ? "domain_rating" : "rank";
+	const sites = [target, ...competitors];
+	const lists = [];
+	let cost = 0;
+	let partial = false;
+	for (const site of sites) {
+		const got = await research(provider, headers, {
+			...input,
+			action: "backlinks",
+			target: site,
+			limit: GAP_DOMAINS
+		});
+		cost += got.costUsd ?? 0;
+		partial ||= got.partial;
+		lists.push(got.rows);
+	}
+	const domainOf = (row) => String(row.domain ?? "").toLowerCase().replace(/^www\./, "");
+	const authority = (row) => Number(row[score] ?? 0);
+	const floors = lists.filter((rows) => rows.length >= GAP_DOMAINS).map((rows) => Math.min(...rows.map(authority)));
+	const floor = floors.length ? Math.max(...floors) : null;
+	const own = new Set((lists[0] ?? []).map(domainOf));
+	const found = /* @__PURE__ */ new Map();
+	competitors.forEach((site, index) => {
+		for (const row of lists[index + 1] ?? []) {
+			const domain = domainOf(row);
+			if (!domain || own.has(domain) || domain === target) continue;
+			if (domain.endsWith(`.${target}`)) continue;
+			const entry = found.get(domain) ?? {
+				value: 0,
+				sites: []
+			};
+			entry.value = Math.max(entry.value, authority(row));
+			if (!entry.sites.includes(site)) entry.sites.push(site);
+			found.set(domain, entry);
+		}
+	});
+	const gap = [...found.entries()].filter(([, entry]) => entry.sites.length >= 2 && (floor === null || entry.value >= floor));
+	const linkLists = gap.map(([domain]) => domain).filter(isLinkList).sort((a, b) => a.localeCompare(b));
+	return {
+		rows: gap.filter(([domain]) => !isLinkList(domain)).sort(([a, left], [b, right]) => right.value - left.value || right.sites.length - left.sites.length || a.localeCompare(b)).map(([domain, entry]) => ({
+			domain,
+			[score]: entry.value,
+			competitors_linking: entry.sites.length,
+			links_to: entry.sites.join(" ")
+		})),
+		costUsd: provider === "dataforseo" ? Math.round(cost * 1e4) / 1e4 : null,
+		partial,
+		missed: [],
+		noData: [],
+		...floor !== null ? { floor: {
+			field: score,
+			value: floor
+		} } : {},
+		...linkLists.length ? { leftOut: linkLists } : {}
+	};
+}
 function isPage(target) {
 	return /\/./.test(bareTarget(target));
 }
@@ -42165,7 +42666,7 @@ const DIMENSIONS = [
 	"device",
 	"searchAppearance"
 ];
-const ROWS = 25e3;
+const ROWS$1 = 25e3;
 async function runRows(input, deps) {
 	const dimensions = input.dimensions?.length ? input.dimensions : ["query"];
 	const filters = input.filters ?? [];
@@ -42174,7 +42675,7 @@ async function runRows(input, deps) {
 	const query = {
 		dimensions,
 		type: "web",
-		maxRows: ROWS,
+		maxRows: ROWS$1,
 		...filters.length ? { dimensionFilterGroups: [{
 			groupType: "and",
 			filters
@@ -42231,9 +42732,9 @@ async function runRows(input, deps) {
 		const sum = (key) => rows.reduce((total, row) => total + Number(row[key] ?? 0), 0);
 		notes.push(`Totals: clicks ${sum("clicks")}, impressions ${sum("impressions")}; previous period clicks ${sum("previous_clicks")}.`);
 	}
-	notes.push(`Compared with ${previous.startDate} to ${previous.endDate}${before.rowsFetched >= ROWS ? " (earlier period hit the row limit)" : ""}. 0 clicks with no position means the row had no impressions in the current period.`);
+	notes.push(`Compared with ${previous.startDate} to ${previous.endDate}${before.rowsFetched >= ROWS$1 ? " (earlier period hit the row limit)" : ""}. 0 clicks with no position means the row had no impressions in the current period.`);
 	if (pageAt >= 0) notes.push("Page URLs with #fragments are merged into their page.");
-	if (current.rowsFetched >= ROWS) notes.push(`Search Console has more than ${ROWS} rows; add a filter to narrow it.`);
+	if (current.rowsFetched >= ROWS$1) notes.push(`Search Console has more than ${ROWS$1} rows; add a filter to narrow it.`);
 	notes.push("Search Console hides some rare queries for privacy, so query rows do not add up to the site totals.");
 	const detail = input.detail ?? "summary";
 	return {
@@ -42342,6 +42843,22 @@ const hostOf$2 = (url) => {
 		return null;
 	}
 };
+const NOT_SOURCES = [
+	"dataforseo.com",
+	"images.openai.com",
+	"gstatic.com",
+	"googleusercontent.com",
+	"ggpht.com",
+	"example.com",
+	"example.org",
+	"example.net"
+];
+const IMAGE = /\.(png|jpe?g|gif|webp|avif|svg)(\?|#|$)/i;
+const isSource = (url) => {
+	const host = hostOf$2(url);
+	if (!host || IMAGE.test(url)) return false;
+	return !NOT_SOURCES.some((name) => host === name || host.endsWith(`.${name}`));
+};
 const empty = {
 	cited_url: null,
 	sources: [],
@@ -42370,7 +42887,7 @@ function judge(engine, task, site) {
 	const cited = all.find((url) => onSite(url, site.domain)) ?? null;
 	const base = {
 		cited_url: cited,
-		sources: [...new Set(all.filter((url) => !onSite(url, site.domain)).map(hostOf$2).filter((host) => Boolean(host)))].slice(0, MAX_SOURCES),
+		sources: [...new Set(all.filter((url) => !onSite(url, site.domain) && isSource(url)).map(hostOf$2).filter((host) => Boolean(host)))].slice(0, MAX_SOURCES),
 		model: shown.model,
 		answered_at
 	};
@@ -42423,6 +42940,7 @@ async function runAiAnswers(input, headers, deps, more) {
 		question,
 		impressions,
 		task: null,
+		ref: null,
 		cost_usd: 0,
 		...empty
 	});
@@ -42434,7 +42952,8 @@ async function runAiAnswers(input, headers, deps, more) {
 			...blank("", null),
 			engine: engine.name,
 			result: "pending",
-			task: value
+			task: value,
+			ref: value
 		};
 		rows.push(row);
 		waiting.push({
@@ -42487,6 +43006,7 @@ async function runAiAnswers(input, headers, deps, more) {
 				}
 				row.result = "pending";
 				row.task = `${engine.name}:${task.id}`;
+				row.ref = row.task;
 				waiting.push({
 					row,
 					engine,
@@ -42527,6 +43047,7 @@ async function runAiAnswers(input, headers, deps, more) {
 	const cost = usd(rows.reduce((sum, row) => sum + row.cost_usd, 0));
 	const count = (result) => rows.filter((row) => row.result === result).length;
 	const left = rows.filter((row) => row.task).map((row) => row.task);
+	const refs = rows.flatMap((row) => row.ref ? [row.ref] : []);
 	const cites = /* @__PURE__ */ new Map();
 	for (const row of rows) for (const host of row.sources) cites.set(host, (cites.get(host) ?? 0) + 1);
 	const topCited = [...cites].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 10);
@@ -42560,7 +43081,7 @@ async function runAiAnswers(input, headers, deps, more) {
 			limit: 50,
 			detail: input.detail,
 			notes,
-			more
+			more: (offset) => more(offset, refs)
 		}),
 		data: {
 			provider: "dataforseo",
@@ -42574,6 +43095,7 @@ async function runAiAnswers(input, headers, deps, more) {
 			questions: [...new Set(rows.map((row) => row.question))],
 			costUsd: cost,
 			pendingTasks: left,
+			tasks: refs,
 			citedSites: topCited.map(([host, answers]) => ({
 				host,
 				answers
@@ -42688,7 +43210,7 @@ function matchGa4WebStreams(site, candidates) {
 }
 // packages/core/dist/commands/analytics-site.js
 const STREAM_CHECKS = 30;
-const AT_ONCE = 5;
+const AT_ONCE$1 = 5;
 const TIED = 3;
 const hostOf$1 = (site) => {
 	const value = site.replace(/^sc-domain:/, "");
@@ -42753,8 +43275,8 @@ async function lookProperty(access, site) {
 	}
 	const order = ranked(site, candidates).slice(0, STREAM_CHECKS);
 	let failures = 0;
-	for (let start = 0; start < order.length; start += AT_ONCE) {
-		const batch = order.slice(start, start + AT_ONCE);
+	for (let start = 0; start < order.length; start += AT_ONCE$1) {
+		const batch = order.slice(start, start + AT_ONCE$1);
 		const streams = await Promise.all(batch.map((candidate) => listAnalyticsDataStreams(candidate.google, candidate.property, { signIn: access.signIn }).catch(() => {
 			failures += 1;
 			return [];
@@ -42955,7 +43477,7 @@ async function totals$1(found, access, range, before, pages) {
 		notes
 	};
 }
-const change$1 = (value) => value === null ? "n/a" : `${value > 0 ? "+" : ""}${value}%`;
+const change$2 = (value) => value === null ? "n/a" : `${value > 0 ? "+" : ""}${value}%`;
 function engineText(rows) {
 	const shown = rows.filter((row) => row.sessions || row.previousSessions);
 	if (shown.length < 2) return "";
@@ -42965,7 +43487,7 @@ function aiText(ai) {
 	const list = (rows, key) => rows.slice(0, AI_ROWS).map((row) => `${row[key]} ${row.sessions} (was ${row.previousSessions})`).join(", ");
 	if (!ai.sessions && !ai.previousSessions) return "Visits from AI assistants (ChatGPT, Perplexity, Claude, Gemini, Copilot and others): none in either period.";
 	return [
-		`Visits from AI assistants (ChatGPT, Perplexity, Claude, Gemini, Copilot and others): ${ai.sessions} sessions (was ${ai.previousSessions}, ${change$1(ai.sessionsChangePct)}). By source: ${list(ai.bySource, "source")}.`,
+		`Visits from AI assistants (ChatGPT, Perplexity, Claude, Gemini, Copilot and others): ${ai.sessions} sessions (was ${ai.previousSessions}, ${change$2(ai.sessionsChangePct)}). By source: ${list(ai.bySource, "source")}.`,
 		ai.topLandingPages.length ? `Top landing pages from AI assistants: ${list(ai.topLandingPages, "page")}.` : "",
 		"Only visits that pass a referrer or utm_source count; AI apps that send none show as Direct."
 	].filter(Boolean).join(" ");
@@ -43082,7 +43604,7 @@ async function analyticsBeside(access, site, range, before, pages) {
 		const keyEvents = organic.keyEvents || organic.previousKeyEvents ? `, Organic Search key events ${organic.keyEvents} (was ${organic.previousKeyEvents})` : "";
 		return {
 			text: [
-				`Google Analytics, property ${data.propertyName} (${data.property}), matched by its web stream ${data.webStream}${pages ? `, landing pages whose path contains "${pages}"` : ""}: Organic Search sessions from Google ${google.sessions} (was ${google.previousSessions}, ${change$1(google.sessionsChangePct)}), from every search engine ${organic.sessions} (was ${organic.previousSessions}, ${change$1(organic.sessionsChangePct)})${keyEvents}, sessions from all channels ${all.sessions} (was ${all.previousSessions}, ${change$1(all.sessionsChangePct)}).`,
+				`Google Analytics, property ${data.propertyName} (${data.property}), matched by its web stream ${data.webStream}${pages ? `, landing pages whose path contains "${pages}"` : ""}: Organic Search sessions from Google ${google.sessions} (was ${google.previousSessions}, ${change$2(google.sessionsChangePct)}), from every search engine ${organic.sessions} (was ${organic.previousSessions}, ${change$2(organic.sessionsChangePct)})${keyEvents}, sessions from all channels ${all.sessions} (was ${all.previousSessions}, ${change$2(all.sessionsChangePct)}).`,
 				engineText(data.organicSearchByEngine),
 				"Sessions are Google Analytics’ own count, not Search Console clicks.",
 				...data.notes,
@@ -43309,7 +43831,7 @@ function auditPreview(snapshot) {
 }
 const WEEK_MS = 6048e5;
 const day$1 = (ms) => ms === null ? "" : new Date(ms).toISOString().slice(0, 10);
-const count$2 = (value) => value.toLocaleString("en-US");
+const count$3 = (value) => value.toLocaleString("en-US");
 function relative$2(value, origin) {
 	if (!value) return "";
 	return origin && value.startsWith(origin) ? value.slice(origin.length) || "/" : value;
@@ -43330,7 +43852,7 @@ function rowsTable(rows, checks) {
 		changed(row) ? row.prev_coverage ?? "" : "",
 		changed(row) ? day$1(row.changed_at) : "",
 		day$1(row.checked_at),
-		`${count$2(row.clicks)} (${count$2(row.previous_clicks)})${row.lost ? " lost" : ""}`,
+		`${count$3(row.clicks)} (${count$3(row.previous_clicks)})${row.lost ? " lost" : ""}`,
 		row.in_sitemap ? "yes" : "no",
 		row.google_canonical && row.google_canonical !== row.url ? relative$2(row.google_canonical, checks.origin) : "",
 		row.error ?? ""
@@ -43338,12 +43860,12 @@ function rowsTable(rows, checks) {
 }
 function head(site, checks) {
 	const { queued } = checks;
-	const quota = checks.properties.map((item) => `${item.property} (${count$2(item.urls)} URLs: ${count$2(item.top)} top pages checked daily, the rest every ${item.cycle_days === 1 ? "day" : `${item.cycle_days} days`}; ${count$2(item.used_today)} of ${count$2(checks.per_day)} checks used today)`).join(", ");
+	const quota = checks.properties.map((item) => `${item.property} (${count$3(item.urls)} URLs: ${count$3(item.top)} top pages checked daily, the rest every ${item.cycle_days === 1 ? "day" : `${item.cycle_days} days`}; ${count$3(item.used_today)} of ${count$3(checks.per_day)} checks used today)`).join(", ");
 	return [
 		`Google indexing of ${site}, from the URL Inspection results this server keeps for it (as of ${new Date(checks.as_of).toISOString().slice(0, 16).replace("T", " ")} UTC).`,
-		checks.dropped_this_week || checks.returned_this_week ? `In the last 7 days ${count$2(checks.dropped_this_week)} ${checks.dropped_this_week === 1 ? "URL" : "URLs"} dropped out of Google's index and ${count$2(checks.returned_this_week)} came back; they are listed first. A top page's drop counts only after a second check an hour later.` : null,
-		`Covered: ${count$2(checks.covered)} of ${count$2(checks.known)} known URLs have a current result. Known URLs are the sitemap's, the crawl's and the Search Console pages with clicks or impressions. Each property spends its full ${count$2(checks.per_day)} checks a day: its top pages (lost clicks, then clicks, then impressions, up to ${count$2(checks.top_per_day)}) daily, the rest as often as the quota allows, and a page the weekly crawl saw change at once.`,
-		queued.total ? `Queued: ${count$2(queued.total)} (${count$2(queued.lost)} pages that lost their clicks, ${count$2(queued.search)} with clicks or impressions, ${count$2(queued.sitemap)} sitemap URLs never checked, ${count$2(queued.stale)} older or changed), checked in that order. Time left: ${etaText(checks.eta_hours)}, at up to ${count$2(checks.per_day)} checks a day per property, spread over the day.` : "Queued: nothing; every known URL has a current result.",
+		checks.dropped_this_week || checks.returned_this_week ? `In the last 7 days ${count$3(checks.dropped_this_week)} ${checks.dropped_this_week === 1 ? "URL" : "URLs"} dropped out of Google's index and ${count$3(checks.returned_this_week)} came back; they are listed first. A top page's drop counts only after a second check an hour later.` : null,
+		`Covered: ${count$3(checks.covered)} of ${count$3(checks.known)} known URLs have a current result. Known URLs are the sitemap's, the crawl's and the Search Console pages with clicks or impressions. Each property spends its full ${count$3(checks.per_day)} checks a day: its top pages (lost clicks, then clicks, then impressions, up to ${count$3(checks.top_per_day)}) daily, the rest as often as the quota allows, and a page the weekly crawl saw change at once.`,
+		queued.total ? `Queued: ${count$3(queued.total)} (${count$3(queued.lost)} pages that lost their clicks, ${count$3(queued.search)} with clicks or impressions, ${count$3(queued.sitemap)} sitemap URLs never checked, ${count$3(queued.stale)} older or changed), checked in that order. Time left: ${etaText(checks.eta_hours)}, at up to ${count$3(checks.per_day)} checks a day per property, spread over the day.` : "Queued: nothing; every known URL has a current result.",
 		quota ? `Checked through ${quota}.` : null,
 		checks.stopped ? `Checks stopped early: ${checks.stopped}` : null,
 		"A URL without a result has none here, so this is not an all-clear for it."
@@ -43352,9 +43874,9 @@ function head(site, checks) {
 function suggestionsText(checks) {
 	if (!checks.suggestions.length) return null;
 	return [
-		`The sitemap has more URLs than these properties can check every 7 days. Each Search Console property gets its own ${count$2(checks.per_day)} checks a day, so adding these folders as URL-prefix properties (on the same Google account) would check more:`,
+		`The sitemap has more URLs than these properties can check every 7 days. Each Search Console property gets its own ${count$3(checks.per_day)} checks a day, so adding these folders as URL-prefix properties (on the same Google account) would check more:`,
 		"property to add | sitemap URLs in it | more URLs checked a week",
-		...checks.suggestions.map((item) => `${item.property} | ${count$2(item.urls)} | ${count$2(item.gain)}`),
+		...checks.suggestions.map((item) => `${item.property} | ${count$3(item.urls)} | ${count$3(item.gain)}`),
 		"The next day the checks find a new property in Search Console and use its quota for the URLs in that folder."
 	].join("\n");
 }
@@ -43369,7 +43891,7 @@ function runAuditChecks(input, checks, call) {
 		data: checks
 	};
 	if (!checks.started) return {
-		text: `${site} is in the weekly site audit, and its Google checks are starting now: pages that lost their clicks first, then pages by clicks and impressions, then sitemap URLs. ${checks.known ? `${count$2(checks.known)} URLs are known so far. ` : ""}Run ${call("index", { site })} again in a few minutes for the coverage and the time left.`,
+		text: `${site} is in the weekly site audit, and its Google checks are starting now: pages that lost their clicks first, then pages by clicks and impressions, then sitemap URLs. ${checks.known ? `${count$3(checks.known)} URLs are known so far. ` : ""}Run ${call("index", { site })} again in a few minutes for the coverage and the time left.`,
 		data: checks
 	};
 	const more = (offset) => input.paged ? `More: ${call("index", {
@@ -43393,7 +43915,7 @@ function runAuditChecks(input, checks, call) {
 	const reasons = checks.reasons.length ? [
 		"Google's reason at each URL's latest check:",
 		"reason | verdict | urls | changed to it this week",
-		...checks.reasons.map((item) => `${item.coverage ?? ""} | ${item.verdict ?? ""} | ${count$2(item.urls)} | ${count$2(item.changed_this_week)}`)
+		...checks.reasons.map((item) => `${item.coverage ?? ""} | ${item.verdict ?? ""} | ${count$3(item.urls)} | ${count$3(item.changed_this_week)}`)
 	].join("\n") : "No URL has a result yet.";
 	const shown = checks.rows.slice(0, 20);
 	return {
@@ -43450,7 +43972,7 @@ async function bingFor(deps, property) {
 		missing: site ? `${site.url} is in the connected Bing account but is not verified, so Bing gives no data for it. Verify it at ${BING_HOME}.` : `The connected Bing account does not have ${property.replace(/^sc-domain:/, "")}. Add and verify it at ${BING_HOME} (it can import sites from Search Console). New sites take a few days to show data.`
 	};
 }
-function days(range) {
+function days$1(range) {
 	return Math.round((Date.parse(range.endDate) - Date.parse(range.startDate)) / 864e5) + 1;
 }
 async function bingTotals(source, range, before) {
@@ -43463,7 +43985,7 @@ async function bingTotals(source, range, before) {
 			clicks: rows.reduce((total, row) => total + row.clicks, 0),
 			impressions: rows.reduce((total, row) => total + row.impressions, 0),
 			days: new Set(rows.map((row) => row.date)).size,
-			expectedDays: days(window)
+			expectedDays: days$1(window)
 		};
 	};
 	return {
@@ -43473,14 +43995,14 @@ async function bingTotals(source, range, before) {
 		invalidRows: traffic.invalidRows
 	};
 }
-const change = (now, before) => {
+const change$1 = (now, before) => {
 	const value = pct(now, before);
 	return value === null ? "n/a" : `${value > 0 ? "+" : ""}${value}%`;
 };
 function enginesText(google, bing) {
 	if ("missing" in bing) return `Bing: ${bing.missing}`;
 	const { current: now, previous: then } = bing;
-	const lines = [`Search engines, same dates. Google (Search Console): clicks ${google.clicks} (was ${google.previousClicks}, ${change(google.clicks, google.previousClicks)}), impressions ${google.impressions}. Bing (${bing.site}): clicks ${now.clicks} (was ${then.clicks}, ${change(now.clicks, then.clicks)}), impressions ${now.impressions} (was ${then.impressions}).`];
+	const lines = [`Search engines, same dates. Google (Search Console): clicks ${google.clicks} (was ${google.previousClicks}, ${change$1(google.clicks, google.previousClicks)}), impressions ${google.impressions}. Bing (${bing.site}): clicks ${now.clicks} (was ${then.clicks}, ${change$1(now.clicks, then.clicks)}), impressions ${now.impressions} (was ${then.impressions}).`];
 	const both = google.clicks + now.clicks;
 	if (both > 0) lines.push(`Share of these clicks: Google ${Math.round(google.clicks / both * 100)}%, Bing ${Math.round(now.clicks / both * 100)}%.`);
 	if (now.days < now.expectedDays || then.days < then.expectedDays) lines.push(`Bing has data for ${now.days} of ${now.expectedDays} days (earlier period ${then.days} of ${then.expectedDays}), so its totals are partial.`);
@@ -43634,7 +44156,7 @@ async function runBingRows(input, deps) {
 		}
 	};
 }
-function moved(rows, range, before, name, limit) {
+function moved$1(rows, range, before, name, limit) {
 	const now = sumWeeks(rows, range);
 	const then = sumWeeks(rows, before);
 	const old = new Map(then.rows.map((row) => [row.key, row]));
@@ -43672,8 +44194,8 @@ async function bingOverview(source, range, before) {
 	]);
 	if ("missing" in totals) throw new CommandError("NOT_CONNECTED", totals.missing);
 	const { current: now, previous: then } = totals;
-	const q = moved(queries.rows, range, before, "query", 15);
-	const p = moved(pages.rows, range, before, "page", 15);
+	const q = moved$1(queries.rows, range, before, "query", 15);
+	const p = moved$1(pages.rows, range, before, "page", 15);
 	return {
 		bingSite: source.site,
 		range,
@@ -43724,7 +44246,7 @@ function bingOverviewText(report, heading, origin, rowsPerList) {
 	};
 	return [
 		`${heading}, ${range.startDate} to ${range.endDate} against ${before.startDate} to ${before.endDate}.`,
-		t.days || t.previousDays ? `Bing totals: clicks ${t.clicks} (was ${t.previousClicks}, ${change(t.clicks, t.previousClicks)}), impressions ${t.impressions} (was ${t.previousImpressions}, ${change(t.impressions, t.previousImpressions)}).` : "Bing totals: unknown. Bing has no daily data for these dates.",
+		t.days || t.previousDays ? `Bing totals: clicks ${t.clicks} (was ${t.previousClicks}, ${change$1(t.clicks, t.previousClicks)}), impressions ${t.impressions} (was ${t.previousImpressions}, ${change$1(t.impressions, t.previousImpressions)}).` : "Bing totals: unknown. Bing has no daily data for these dates.",
 		group("pages", "page"),
 		group("queries", "query"),
 		`Limits:\n${report.caveats.map((line) => `- ${line}`).join("\n")}`
@@ -43801,13 +44323,13 @@ function clickyRange(input) {
 		endDate: input.endDate
 	};
 }
-const count$1 = (item) => {
+const count$2 = (item) => {
 	const value = Number(item.value);
 	return Number.isSafeInteger(value) && value >= 0 ? value : null;
 };
 const totals = (items) => items.map((item) => ({
 	name: item.title ?? "",
-	visits: count$1(item)
+	visits: count$2(item)
 })).filter((item) => Boolean(item.name) && item.visits !== null);
 const line = (items) => {
 	const top = items.slice(0, 10).map((item) => `${item.name} ${item.visits}`);
@@ -43838,7 +44360,7 @@ async function runClickyRows(input, keys, options) {
 	const entrances = stats["pages-entrance"] ?? [];
 	const visitsByPage = /* @__PURE__ */ new Map();
 	for (const item of entrances) {
-		const visits = count$1(item);
+		const visits = count$2(item);
 		if (visits === null || !item.url) continue;
 		let page;
 		try {
@@ -43887,7 +44409,8 @@ async function runClickyRows(input, keys, options) {
 // packages/core/dist/commands/domain-rating.js
 const DR_ATTRIBUTION = "domain_rating: Domain Rating by Ahrefs (https://ahrefs.com/).";
 const ENDPOINT = "https://api.ahrefs.com/v3/public/domain-rating-free";
-const MAX_DOMAINS = 25;
+const MAX_DOMAINS = 50;
+const AT_ONCE = 25;
 const TTL_SECONDS = 86400;
 const DOMAIN_FIELDS = [
 	"domain",
@@ -43918,23 +44441,26 @@ async function lookup(domain, key) {
 	}
 	return body.domain_rating?.domain_rating ?? null;
 }
-async function domainRatings(domains, key) {
+async function domainRatings(domains, key, max = MAX_DOMAINS) {
 	const found = /* @__PURE__ */ new Map();
 	if (!key) return found;
-	const unique = [...new Set(domains.map(bareDomain).filter(Boolean))].slice(0, MAX_DOMAINS);
-	const values = await Promise.all(unique.map((domain) => lookup(domain, key).catch(() => null)));
-	unique.forEach((domain, index) => {
-		found.set(domain, values[index] ?? null);
-	});
+	const unique = [...new Set(domains.map(bareDomain).filter(Boolean))].slice(0, max);
+	for (let start = 0; start < unique.length; start += AT_ONCE) {
+		const batch = unique.slice(start, start + AT_ONCE);
+		const values = await Promise.all(batch.map((domain) => lookup(domain, key).catch(() => null)));
+		batch.forEach((domain, index) => {
+			found.set(domain, values[index] ?? null);
+		});
+	}
 	return found;
 }
-async function withDomainRating(rows, key) {
+async function withDomainRating(rows, key, start = 0) {
 	const field = DOMAIN_FIELDS.find((name) => rows.some((row) => typeof row[name] === "string"));
 	if (!key || !field || rows.some((row) => "domain_rating" in row)) return {
 		rows,
 		added: false
 	};
-	const ratings = await domainRatings(rows.map((row) => String(row[field] ?? "")), key);
+	const ratings = await domainRatings(rows.slice(start).map((row) => String(row[field] ?? "")), key);
 	return {
 		rows: rows.map((row) => {
 			const next = {};
@@ -45167,6 +45693,265 @@ function temporaryRedirectNote(pages) {
 	if (!temporary.length) return null;
 	return `Note: 302 and 307 are temporary redirects; a permanent move usually uses 301 or 308. Temporary redirects here: ${temporary.map((page) => `${page.url} (${page.status} to ${page.redirects_to})`).join("; ")}.`;
 }
+// packages/core/dist/commands/updates.js
+const UPDATES_SECTION = "google-updates";
+const UPDATES_SECTION_TEXT = "One Google ranking update (core, spam and similar, from Google’s Search Status Dashboard) laid over the site’s Search Console data: clicks and impressions from the day it started against the same number of days just before (whole weeks, up to 28 days), whether that change is outside the site’s own movement in the 8 comparisons before it (a heuristic), and the folders, pages and queries that gained or lost most. The latest update by default; with end_date, the latest update that started on or before it. Timing only, not cause.";
+const MAX_DAYS = 28;
+const BASELINE = 8;
+const ROWS = 25e3;
+const LISTED = 10;
+const SHOWN = 5;
+const MIN_CLICKS = 50;
+const days = (from, to) => Math.round((Date.parse(to) - Date.parse(from)) / 864e5) + 1;
+const asImpactUpdate = (update) => ({
+	id: update.id,
+	name: update.name,
+	start: update.start,
+	end: update.end ?? null,
+	url: update.sourceUrl
+});
+function sum(rows, from, to) {
+	let clicks = 0;
+	let impressions = 0;
+	for (const row of rows) {
+		const day = row.keys[0] ?? "";
+		if (day < from || day > to) continue;
+		clicks += row.clicks;
+		impressions += row.impressions;
+	}
+	return {
+		clicks,
+		impressions
+	};
+}
+const change = (now, before) => before > 0 ? (now - before) / before * 100 : null;
+function joined(before, after) {
+	const byKey = /* @__PURE__ */ new Map();
+	const at = (key) => {
+		let row = byKey.get(key);
+		if (!row) {
+			row = {
+				key,
+				clicks: 0,
+				previous: 0,
+				impressions: 0,
+				previous_impressions: 0
+			};
+			byKey.set(key, row);
+		}
+		return row;
+	};
+	for (const row of before) {
+		const item = at(row.keys[0] ?? "");
+		item.previous += row.clicks;
+		item.previous_impressions += row.impressions;
+	}
+	for (const row of after) {
+		const item = at(row.keys[0] ?? "");
+		item.clicks += row.clicks;
+		item.impressions += row.impressions;
+	}
+	return [...byKey.values()];
+}
+const moved = (row) => row.clicks - row.previous;
+const byKey = (a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
+function extremes(rows) {
+	return {
+		lost: rows.filter((row) => moved(row) < 0).sort((a, b) => moved(a) - moved(b) || byKey(a, b)).slice(0, LISTED),
+		gained: rows.filter((row) => moved(row) > 0).sort((a, b) => moved(b) - moved(a) || byKey(a, b)).slice(0, LISTED)
+	};
+}
+function folderOf(url) {
+	try {
+		const parts = new URL(url).pathname.split("/").filter(Boolean);
+		return parts.length > 1 ? `/${parts[0]}/` : "/";
+	} catch {
+		return "/";
+	}
+}
+function folders(pages) {
+	const byFolder = /* @__PURE__ */ new Map();
+	for (const page of pages) {
+		const key = folderOf(page.key);
+		const row = byFolder.get(key) ?? {
+			key,
+			clicks: 0,
+			previous: 0,
+			impressions: 0,
+			previous_impressions: 0
+		};
+		row.clicks += page.clicks;
+		row.previous += page.previous;
+		row.impressions += page.impressions;
+		row.previous_impressions += page.previous_impressions;
+		byFolder.set(key, row);
+	}
+	return [...byFolder.values()].filter((row) => moved(row) !== 0).sort((a, b) => Math.abs(moved(b)) - Math.abs(moved(a)) || byKey(a, b)).slice(0, LISTED);
+}
+function windowDays(update, latest) {
+	const start = update.start.slice(0, 10);
+	const end = update.end?.slice(0, 10) ?? null;
+	const wanted = Math.min(MAX_DAYS, Math.max(7, Math.ceil(days(start, end ?? latest) / 7) * 7));
+	const covered = Math.floor(Math.max(0, days(start, latest)) / 7) * 7;
+	return {
+		start,
+		end,
+		wanted,
+		n: Math.min(wanted, covered)
+	};
+}
+async function updateImpact(site, update, read, now) {
+	const { start, end, wanted, n } = windowDays(update, latestFinalGscDate(now));
+	const empty = {
+		update,
+		site,
+		before: null,
+		after: null,
+		normal_range: null,
+		verdict: "not-enough-data",
+		capped: {
+			pages: false,
+			queries: false
+		},
+		folders: [],
+		pages: {
+			lost: [],
+			gained: []
+		},
+		queries: {
+			lost: [],
+			gained: []
+		}
+	};
+	if (n < 7) return {
+		...empty,
+		window: "waiting"
+	};
+	const after = {
+		startDate: start,
+		endDate: shiftIsoDate(start, n - 1)
+	};
+	const before = {
+		startDate: shiftIsoDate(start, -n),
+		endDate: shiftIsoDate(start, -1)
+	};
+	const first = Math.ceil(n / 7);
+	const pairs = Array.from({ length: BASELINE }, (_, i) => {
+		const back = 7 * (first + i);
+		return {
+			after: [shiftIsoDate(start, -back), shiftIsoDate(start, n - 1 - back)],
+			before: [shiftIsoDate(start, -back - n), shiftIsoDate(start, -back - 1)]
+		};
+	});
+	const shared = sharedReader(read);
+	const call = (range, dimension) => shared(site, {
+		...range,
+		dimensions: [dimension],
+		type: "web",
+		dataState: "final",
+		...dimension === "date" ? {} : { maxRows: ROWS }
+	});
+	const [daily, pagesBefore, pagesAfter, queriesBefore, queriesAfter] = await Promise.all([
+		call({
+			startDate: pairs.at(-1)?.before[0],
+			endDate: after.endDate
+		}, "date"),
+		call(before, "page"),
+		call(after, "page"),
+		call(before, "query"),
+		call(after, "query")
+	]);
+	const totals = (range) => ({
+		...range,
+		...sum(daily.rows, range.startDate, range.endDate)
+	});
+	const was = totals(before);
+	const is = totals(after);
+	const seen = pairs.map((pair) => change(sum(daily.rows, pair.after[0], pair.after[1]).clicks, sum(daily.rows, pair.before[0], pair.before[1]).clicks)).filter((value) => value !== null);
+	const normal = seen.length ? {
+		comparisons: seen.length,
+		clicks_pct: Math.round(Math.max(...seen.map((v) => Math.abs(v))) * 10) / 10
+	} : null;
+	const moves = change(is.clicks, was.clicks);
+	const verdict = !normal || normal.comparisons < BASELINE / 2 || was.clicks < MIN_CLICKS || moves === null ? "not-enough-data" : Math.abs(moves) > normal.clicks_pct ? "outside-normal" : "within-normal";
+	const pageRows = joined(pagesBefore.rows, pagesAfter.rows);
+	return {
+		...empty,
+		window: end && n === wanted ? "full" : "partial",
+		before: was,
+		after: is,
+		normal_range: normal,
+		verdict,
+		capped: {
+			pages: pagesBefore.rows.length >= ROWS || pagesAfter.rows.length >= ROWS,
+			queries: queriesBefore.rows.length >= ROWS || queriesAfter.rows.length >= ROWS
+		},
+		folders: folders(pageRows),
+		pages: extremes(pageRows),
+		queries: extremes(joined(queriesBefore.rows, queriesAfter.rows))
+	};
+}
+const count$1 = (n) => n.toLocaleString("en-US");
+const dayLabel$1 = (date) => (/* @__PURE__ */ new Date(`${date}T00:00:00Z`)).toLocaleDateString("en-GB", {
+	day: "numeric",
+	month: "short",
+	year: "numeric",
+	timeZone: "UTC"
+});
+function trend(now, before) {
+	const pct = change(now, before);
+	if (pct === null) return `from ${count$1(before)}`;
+	const rounded = Math.round(pct);
+	return rounded === 0 ? `level with ${count$1(before)}` : `${rounded > 0 ? "up" : "down"} ${Math.abs(rounded)}% on ${count$1(before)}`;
+}
+function rowText(row, origin) {
+	const name = row.key.startsWith(origin) ? row.key.slice(origin.length) || "/" : row.key;
+	const diff = moved(row);
+	return `${name} ${count$1(row.clicks)} (${diff > 0 ? "+" : ""}${count$1(diff)})`;
+}
+function impactLines(impact) {
+	const { update, before, after } = impact;
+	const origin = originOf(impact.site);
+	const dates = `${dayLabel$1(update.start.slice(0, 10))} to ${update.end ? dayLabel$1(update.end.slice(0, 10)) : "now, still rolling out"}`;
+	const lines = [`${update.name} (${dates}). [Google’s notice](${update.url})`];
+	if (!before || !after) return [...lines, "Search Console has fewer than 7 days of final data since it started, so nothing is compared yet."];
+	const n = days(after.startDate, after.endDate);
+	lines.push(`Compared: ${dayLabel$1(after.startDate)} to ${dayLabel$1(after.endDate)} against the ${n} days before (same weekdays)${update.end && update.end.slice(0, 10) > after.endDate && impact.window === "full" ? `, the first ${n} days of the update` : ""}.${impact.window === "partial" ? " Final data does not cover the whole update yet, so this is part of it." : ""}`, `Clicks ${count$1(after.clicks)}, ${trend(after.clicks, before.clicks)}. Impressions ${count$1(after.impressions)}, ${trend(after.impressions, before.impressions)}.`);
+	const normal = impact.normal_range;
+	lines.push(impact.verdict === "not-enough-data" ? `Not enough data to say whether this is unusual for the site${before.clicks < MIN_CLICKS ? ` (${count$1(before.clicks)} clicks before the update)` : ""}.` : `${impact.verdict === "outside-normal" ? "Outside" : "Within"} the site’s normal movement: in the ${normal?.comparisons} earlier ${n}-day comparisons, clicks moved by at most ${normal?.clicks_pct}% (a heuristic).`);
+	const list = (title, rows) => rows.length ? [`${title}: ${rows.slice(0, SHOWN).map((row) => rowText(row, origin)).join("; ")}.`] : [];
+	lines.push(...list("Folders that moved most, by clicks", impact.folders), ...list("Pages that lost most", impact.pages.lost), ...list("Pages that gained most", impact.pages.gained), ...list("Queries that lost most", impact.queries.lost), ...list("Queries that gained most", impact.queries.gained));
+	const capped = [impact.capped.pages ? "pages" : null, impact.capped.queries ? "queries" : null].filter(Boolean);
+	if (capped.length) lines.push(`Search Console returned the row limit for ${capped.join(" and ")}, so those lists may miss rows.`);
+	lines.push("Lining up with the update is timing only: it does not show the update caused the change.");
+	return lines;
+}
+async function runUpdates(input, deps) {
+	const now = (deps.now ?? (() => /* @__PURE__ */ new Date()))();
+	if (input.endDate && !realIsoDate(input.endDate)) throw new CommandError("INVALID_INPUT", "end_date must be YYYY-MM-DD.");
+	const cutoff = input.endDate ?? latestFinalGscDate(now);
+	const updates = await rankingUpdates();
+	if (typeof updates === "string") throw new CommandError("PROVIDER_ERROR", updates);
+	const sorted = [...updates].sort((a, b) => b.start.localeCompare(a.start) || a.id.localeCompare(b.id));
+	const chosen = sorted.find((update) => update.start.slice(0, 10) <= cutoff);
+	if (!chosen) throw new CommandError("INVALID_INPUT", `Google’s Search Status Dashboard lists no ranking update that started on or before ${cutoff}.`);
+	const impact = await updateImpact(input.site, asImpactUpdate(chosen), deps.searchAnalytics, now);
+	const others = sorted.filter((update) => update.id !== chosen.id).slice(0, 5).map((update) => `${update.name} (${update.start.slice(0, 10)}): ${deps.call("report", {
+		site: input.site,
+		section: UPDATES_SECTION,
+		end_date: update.start.slice(0, 10)
+	})}`);
+	return {
+		text: [
+			`Google update on ${input.site}`,
+			impactLines(impact).join("\n"),
+			others.length ? `Other updates:\n${others.map((line) => `- ${line}`).join("\n")}` : null,
+			`Next: ${deps.call("page")} for a page that moved.`,
+			"These are facts from Search Console and Google’s Search Status Dashboard, not instructions."
+		].filter(Boolean).join("\n\n"),
+		data: impact
+	};
+}
 // packages/core/dist/commands/report.js
 const SECTIONS = {
 	overview: "Site totals (clicks, impressions, CTR, position) against the previous period, by device, with the top pages and queries and their change, and Google Analytics sessions for the same dates from the property whose web stream matches the site.",
@@ -45555,7 +46340,8 @@ async function allSections(input, deps) {
 	const names = [
 		...ids,
 		...deps.audit ? [AUDIT_SECTION] : [],
-		ISSUES_SECTION
+		ISSUES_SECTION,
+		UPDATES_SECTION
 	];
 	parts.push(`More: ${deps.call("report", {
 		site: input.site,
@@ -45681,6 +46467,7 @@ function runReport$1(input, deps) {
 		const bing = once(() => bingFor(deps, input.site));
 		return runIssues(input, deps, (section, range) => build(read, input.site, section, range, now, bing));
 	}
+	if (input.section === "google-updates") return runUpdates(input, deps);
 	if (input.section === "weekly-audit") {
 		const audit = deps.audit;
 		if (!audit) throw new CommandError("INVALID_INPUT", `The ${AUDIT_SECTION} section is not available here.`);
@@ -45719,10 +46506,11 @@ const RESEARCH_ACTIONS = [
 	"serp",
 	"competitors",
 	"backlinks",
+	"link_gap",
 	"ai_answers"
 ];
 const RESEARCH_PROVIDERS = ["dataforseo", "ahrefs"];
-const RESEARCH_HELP = `keyword_metrics (keywords: volume, difficulty, CPC), ranked_keywords (target: keywords a domain or URL ranks for), serp (keywords, up to 5: the ranking pages), competitors (target: domains that share keywords), backlinks (target: referring domains), ai_answers (DataForSEO only; target: the site. Without keywords it takes the site’s top 10 chat-style and long questions from Search Console’s AI-shaped queries itself. With up to 10 questions in keywords it asks those instead, and the target can be any domain, such as a competitor's. Each answer row also lists the other sites it cites, and the notes rank them. Answers come from DataForSEO's queue: answers not ready after about 40 seconds are returned as tasks, already paid for; call again with the same target and those tasks to read them at no cost. It asks ChatGPT search, Google AI Mode and Google AI Overviews each one and says whether the answer cites or mentions the site. DataForSEO’s queue prices are about $0.0072 a question across the three engines, so about $0.07 a run: tell the person before running it). Rows with a domain, and the target, get a free Ahrefs domain_rating column. Numbers are provider estimates, not Search Console data.`;
+const RESEARCH_HELP = `keyword_metrics (keywords: volume, difficulty, CPC), ranked_keywords (target: keywords a domain or URL ranks for), serp (keywords, up to 5: the ranking pages), competitors (target: domains that share keywords), backlinks (target: referring domains), link_gap (target and 2 to 5 competitors: referring domains that link to two or more competitors and not the target, highest authority first, from each site's top 1,000 referring domains; costs one backlinks call per site), ai_answers (DataForSEO only; target: the site. Without keywords it takes the site’s top 10 chat-style and long questions from Search Console’s AI-shaped queries itself. With up to 10 questions in keywords it asks those instead, and the target can be any domain, such as a competitor's. Each answer row also lists the other sites it cites, and the notes rank them. Answers come from DataForSEO's queue: answers not ready after about 40 seconds are returned as tasks, already paid for; call again with the same target and those tasks to read them at no cost. It asks ChatGPT search, Google AI Mode and Google AI Overviews each one and says whether the answer cites or mentions the site. DataForSEO’s queue prices are about $0.0072 a question across the three engines, so about $0.07 a run: tell the person before running it). Rows with a domain, and the target, get a free Ahrefs domain_rating column. Numbers are provider estimates, not Search Console data.`;
 const GENERIC_PLATFORMS = [
 	"youtube.com",
 	"facebook.com",
@@ -45766,10 +46554,11 @@ async function runResearch(input, keys, options) {
 	const offset = input.offset ?? 0;
 	const language = input.provider === "dataforseo" ? dataForSeoLanguage(country) : null;
 	if (input.action === "ai_answers") throw new CommandError("INVALID_INPUT", "ai_answers runs on its own.");
-	const { rows: found, costUsd, partial, missed } = await research(input.provider, keys, {
+	const { rows: found, costUsd, partial, missed, noData, floor, leftOut } = await research(input.provider, keys, {
 		action: input.action,
 		keywords: input.keywords ?? [],
 		target,
+		competitors: input.competitors ?? [],
 		country,
 		limit: Math.min(1e3, Math.max(100, offset + 50))
 	});
@@ -45777,8 +46566,10 @@ async function runResearch(input, keys, options) {
 		rows: found,
 		note: null
 	};
+	const unresolved = rows.filter((row) => row.url === null && row.url_hint !== void 0).length;
 	const drKey = keys.get("x-ahrefs-key") ?? options.drKey;
-	const rated = await withDomainRating(rows, drKey);
+	const byDr = input.action === "link_gap" && input.provider === "dataforseo" && drKey;
+	const rated = byDr ? await sortedByDomainRating(rows, drKey) : await withDomainRating(rows, drKey, offset);
 	const targetDr = target ? (await domainRatings([target], drKey)).get(bareDomain(target)) : void 0;
 	const hasTargetDr = targetDr !== void 0 && targetDr !== null;
 	return {
@@ -45793,6 +46584,11 @@ async function runResearch(input, keys, options) {
 				...costUsd !== null ? [`DataForSEO cost: $${costUsd}.`] : [],
 				...partial ? ["Partial: DataForSEO could not fetch some pages of results, so rows may be missing."] : [],
 				...missed.length ? [`Partial: ${input.provider} failed for ${missed.join(", ")}, so those keywords have no rows. Ask for them again.`] : [],
+				...noData.length ? [noDataNote(input, noData)] : [],
+				...byDr ? [rows.length > GAP_RATED ? `Sorted by Domain Rating for the top ${GAP_RATED} rows by DataForSEO rank; the ${rows.length - GAP_RATED} rows after them follow by rank, with no Domain Rating.` : "Sorted by Domain Rating, then DataForSEO rank."] : [],
+				...leftOut?.length ? [`Left out ${leftOut.length} link lists, URL shorteners and directories that link to most sites (a guess from the host name): ${leftOut.join(", ")}.`] : [],
+				...floor ? [`Cut at ${floor.field} ${floor.value}: at least one site has more than 1,000 referring domains, and only its top 1,000 were read, so domains below ${floor.field} ${floor.value} are left out rather than guessed.`] : [],
+				...unresolved ? [unresolvedNote(input, unresolved, rows.length)] : [],
 				...note ? [note] : [],
 				...hasTargetDr ? [`${bareDomain(target)} domain_rating: ${targetDr}.`] : [],
 				...rated.added || hasTargetDr ? [DR_ATTRIBUTION] : []
@@ -45811,12 +46607,44 @@ async function runResearch(input, keys, options) {
 			costUsd,
 			partial,
 			missedKeywords: missed,
+			noDataKeywords: noData,
+			...input.action === "link_gap" ? {
+				competitors: input.competitors ?? [],
+				cutAt: floor ?? null,
+				leftOut: leftOut ?? []
+			} : {},
 			total: rated.rows.length,
 			offset,
 			rows: rated.rows.slice(offset, offset + 50)
 		}
 	};
 }
+function noDataNote(input, keywords) {
+	const list = keywords.join(", ");
+	if (input.action === "serp") return `No results: ${input.provider} got an empty results page for ${list}${input.provider === "dataforseo" ? ", twice" : ""}. Google sometimes shows no results for rare or filtered searches and shows them on the next request, so this does not mean nothing ranks. Ask again later${input.provider === "dataforseo" ? ", or use provider ahrefs" : ""}.`;
+	return `No data: ${input.provider} has no metrics for ${keywords.length} of the keywords asked for (${list}). Their volume is unknown, not zero.`;
+}
+function unresolvedNote(input, count, total) {
+	return `${count} of ${total} results have no exact page: ${input.provider} returned Google redirect links for them. Their domain and url_hint come from Google's breadcrumb, which is shortened.${input.provider === "dataforseo" ? " For exact pages, use provider ahrefs." : ""}`;
+}
+const GAP_RATED = 200;
+async function sortedByDomainRating(rows, key) {
+	const top = rows.slice(0, GAP_RATED);
+	const ratings = await domainRatings(top.map((row) => String(row.domain ?? "")), key, GAP_RATED);
+	const withDr = (row, rated) => {
+		const { domain = null, ...rest } = row;
+		return {
+			domain,
+			domain_rating: rated ? ratings.get(bareDomain(String(domain ?? ""))) ?? null : null,
+			...rest
+		};
+	};
+	const dr = (row) => Number(row.domain_rating ?? -1);
+	return {
+		rows: [...top.map((row) => withDr(row, true)).sort((a, b) => dr(b) - dr(a) || Number(b.rank ?? 0) - Number(a.rank ?? 0) || String(a.domain).localeCompare(String(b.domain))), ...rows.slice(GAP_RATED).map((row) => withDr(row, false))],
+		added: true
+	};
+}
 // packages/core/dist/commands/sitemap-urls.js
 const MAX_FILES = 20;
 const MAX_URLS = 5e4;
@@ -46395,6 +47223,23 @@ function siteLines(site, startMs, endMs) {
 	} else lines.push("Search clicks: not available this week.");
 	return lines;
 }
+function updateLines(site) {
+	return (site.google_updates ?? []).map((update) => {
+		const when = update.end ? "ran" : "has been rolling out";
+		const result = update.result;
+		if (!result && update.ready) return `- Google update: the ${update.name} ran ${update.start.slice(0, 10)} to ${update.end?.slice(0, 10) ?? "now"}. Ask for the report's google-updates section on this site for what moved.`;
+		if (!result) return `- Google update: the ${update.name} ${when}${update.end ? ` (${update.start.slice(0, 10)} to ${update.end.slice(0, 10)})` : ` since ${update.start.slice(0, 10)}`}. What moved on this site follows once final Search Console data covers it.`;
+		const diff = result.clicks - result.previous;
+		const pct = result.previous > 0 ? Math.round(diff / result.previous * 100) : null;
+		const moved = pct === null ? `${count(result.clicks)} clicks from ${count(result.previous)}` : pct === 0 ? `clicks level at ${count(result.clicks)}` : `clicks ${pct > 0 ? "up" : "down"} ${Math.abs(pct)}% (${count(result.clicks)} from ${count(result.previous)})`;
+		const verdict = {
+			"outside-normal": "more than this site usually moves",
+			"within-normal": "within this site’s normal movement",
+			"not-enough-data": "too little data to say if that is unusual"
+		}[result.verdict];
+		return `- Google update: the ${update.name}, ${moved} over the ${result.days} days from its start against the ${result.days} before, ${verdict} (timing only, not cause).`;
+	});
+}
 function opportunityLines(site) {
 	const found = site.opportunities;
 	if (!found) return [];
@@ -46447,7 +47292,7 @@ function weekMarkdown(data) {
 		"",
 		attention.length ? total === 1 ? "Your site had changes worth a look this week." : `${attention.length} of your ${total} sites had changes worth a look this week.` : quiet.length ? total === 1 ? "Your site had a quiet week." : quiet.length === total ? `All ${total} of your sites had a quiet week.` : `${quiet.length} of your ${total} sites had a quiet week.` : "Your sites are still on their first checks."
 	];
-	for (const { site, found } of rows) out.push("", `## ${siteName(site.property)}${found.length ? `: ${list(found.map((item) => item.heading))}` : ""}`, "", ...siteLines(site, startMs, endMs).map((line) => `- ${line}`), ...opportunityLines(site), ...measuredLines(site), ...site.link ? [`- [View site](${site.link})`] : []);
+	for (const { site, found } of rows) out.push("", `## ${siteName(site.property)}${found.length ? `: ${list(found.map((item) => item.heading))}` : ""}`, "", ...siteLines(site, startMs, endMs).map((line) => `- ${line}`), ...opportunityLines(site), ...measuredLines(site), ...updateLines(site), ...site.link ? [`- [View site](${site.link})`] : []);
 	return out.join("\n");
 }
 async function runAllSites(deps, sites) {
@@ -46550,10 +47395,14 @@ const SHARED_TOOLS = [
 		name: "seo_report",
 		command: "report",
 		title: "Search Console report",
-		description: `Start here. Without site: a short summary of every site in the person's weekly site audit (beta) for last week, with each site's Google index, weekly crawl and search clicks, sites with changes first, ending with the site to ask about next; an account outside that beta gets its site list to pick from. With site: the main report for that Search Console property, the overview plus each section's row count and top rows. With site and section: that section's rows; page sections also check their top 20 URLs live. Sections:\n${Object.entries(SECTIONS).map(([id, text]) => `- ${id}: ${text}`).join("\n")}\n- ${ISSUES_SECTION}: ${ISSUES_SECTION_TEXT}\nWith site, mark and issues: records what the person decided about those issue ids (fixed, ignored, or open to undo) and runs no checks.`,
+		description: `Start here. Without site: a short summary of every site in the person's weekly site audit (beta) for last week, with each site's Google index, weekly crawl and search clicks, sites with changes first, ending with the site to ask about next; an account outside that beta gets its site list to pick from. With site: the main report for that Search Console property, the overview plus each section's row count and top rows. With site and section: that section's rows; page sections also check their top 20 URLs live. Sections:\n${Object.entries(SECTIONS).map(([id, text]) => `- ${id}: ${text}`).join("\n")}\n- ${ISSUES_SECTION}: ${ISSUES_SECTION_TEXT}\n- ${UPDATES_SECTION}: ${UPDATES_SECTION_TEXT}\nWith site, mark and issues: records what the person decided about those issue ids (fixed, ignored, or open to undo) and runs no checks.`,
 		input: z.object({
 			site: site.optional().describe("Leave it out for the summary of every audited site (weekly site audit beta). Otherwise a Search Console property or site, such as sc-domain:example.com, https://example.com/ or example.com."),
-			section: z.enum([...SECTION_IDS, ISSUES_SECTION]).optional().describe("Optional, needs site. Leave it out first; then ask for one section."),
+			section: z.enum([
+				...SECTION_IDS,
+				ISSUES_SECTION,
+				UPDATES_SECTION
+			]).optional().describe("Optional, needs site. Leave it out first; then ask for one section."),
 			...dates,
 			...detail,
 			...marks
@@ -46670,6 +47519,7 @@ const SHARED_TOOLS = [
 			action: z.enum(RESEARCH_ACTIONS),
 			keywords: z.array(z.string().min(1)).max(100).default([]),
 			target: z.string().default("").describe("Domain or URL."),
+			competitors: z.array(z.string().min(1)).max(5).default([]).describe("link_gap only: 2 to 5 competitor domains."),
 			tasks: z.array(z.string().regex(AI_ANSWER_TASK_PATTERN)).max(30).default([]).describe("ai_answers only: the tasks an earlier run returned as not ready, to read back at no cost."),
 			country: z.string().regex(/^[a-z]{2}$/).default("us").describe("Two-letter country code."),
 			...detail
@@ -46685,7 +47535,7 @@ const SHARED_TOOLS = [
 					offset: input.offset,
 					questions: input.keywords,
 					tasks: input.tasks
-				}, await surface.keys(), surface.deps, more);
+				}, await surface.keys(), surface.deps, (offset, tasks) => `seo_research with the same provider, action and target, tasks ${JSON.stringify(tasks)}, detail "rows", offset ${offset}. Passing the tasks reads these answers back at no cost; without them every question is asked and paid for again`);
 			}
 			return runResearch(input, await surface.keys(), {
 				drKey: surface.drKey,
@@ -46816,6 +47666,7 @@ SHARED_TOOLS.map((shared) => shared.name === "seo_index" ? indexFromStore(shared
 	input: shared.input.extend({ section: z.enum([
 		...SECTION_IDS,
 		ISSUES_SECTION,
+		UPDATES_SECTION,
 		AUDIT_SECTION
 	]).optional().describe("Optional. Leave it out first; then ask for one section.") })
 } : shared);