seo 0.2.10 → 0.2.13

package/dist/mcp.js

@@ -1,9 +1,9 @@
 import { createRequire as __seoCreateRequire } from 'node:module'; const require = __seoCreateRequire(import.meta.url);
-import { n as load, t as version } from "./package-92W1Zc-o.js";
+import { n as load, t as version } from "./package-B_swz2Xd.js";
 import { Headers, fetch as fetch$1 } from "undici";
-import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { chmodSync, createReadStream, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { arch, homedir, platform, totalmem } from "node:os";
-import { dirname, join } from "node:path";
+import { dirname, extname, join, resolve } from "node:path";
 import { z } from "zod";
 import lockfile from "proper-lockfile";
 import { createHash, randomUUID, sign } from "node:crypto";
@@ -21,9 +21,9 @@ import { gunzipSync } from "node:zlib";
 import { execFile } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
+import { readFile, stat } from "node:fs/promises";
 import "pino";
 import "pino-pretty";
-import "node:fs/promises";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import * as z$1 from "zod/v4";
@@ -86,12 +86,12 @@ var SeoError = class extends Error {
 		this.retryable = errorMetadata[code].retryable;
 	}
 };
-function errorMessage$2(error) {
+function errorMessage$3(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 function toSeoError(error) {
 	if (error instanceof SeoError) return error;
-	const message = errorMessage$2(error);
+	const message = errorMessage$3(error);
 	if (/not logged in/i.test(message)) return new SeoError("AUTH_REQUIRED", message);
 	if (/oauth client config.*missing|shared seo google app/i.test(message)) return new SeoError("AUTH_CONFIG_REQUIRED", message);
 	if (/invalid_grant|refresh token.*no longer valid/i.test(message)) return new SeoError("AUTH_EXPIRED", message);
@@ -148,6 +148,7 @@ function resolveSeoCliPaths(input = {}) {
 		configFile: join(configDir, "config.json"),
 		tokensFile: join(configDir, "tokens.json"),
 		oauthClientFile: join(configDir, "oauth-client.json"),
+		providerSecretsFile: join(configDir, "provider-secrets.json"),
 		telemetryStateFile: join(configDir, "telemetry.json"),
 		cacheDbFile: join(cacheDir, "cache.db")
 	};
@@ -227,6 +228,7 @@ const clientProfileSchema = z.object({
 	watchUrls: z.array(z.string()).default([]),
 	brandTerms: z.array(z.string()).default([]),
 	analytics: analyticsConnectionsSchema,
+	searchEngines: z.object({ bing: z.object({ siteUrl: z.string() }).optional() }).optional(),
 	reportDay: z.number().int().min(1).max(31).optional(),
 	technicalWeekday: z.number().int().min(0).max(7).optional(),
 	isDefault: z.boolean().optional(),
@@ -305,7 +307,7 @@ async function deleteKeyringPassword(service, account) {
 }
 //#endregion
 //#region packages/core/dist/storage/config.js
-const KEYRING_SERVICE = "seo";
+const KEYRING_SERVICE$1 = "seo";
 const PRIVATE_FILE_MODE = 384;
 function tightenConfigPermissions(path) {
 	try {
@@ -336,7 +338,7 @@ function tokenMetadata(tokens) {
 }
 async function readKeyringTokens(tokens) {
 	const account = getKeyringAccount(tokens);
-	const [accessToken, refreshToken] = await Promise.all([getKeyringPassword(KEYRING_SERVICE, `${account}:access`), getKeyringPassword(KEYRING_SERVICE, `${account}:refresh`)]);
+	const [accessToken, refreshToken] = await Promise.all([getKeyringPassword(KEYRING_SERVICE$1, `${account}:access`), getKeyringPassword(KEYRING_SERVICE$1, `${account}:refresh`)]);
 	return {
 		accessToken: accessToken ?? void 0,
 		refreshToken: refreshToken ?? void 0
@@ -344,14 +346,14 @@ async function readKeyringTokens(tokens) {
 }
 async function writeKeyringTokens(tokens) {
 	const account = getKeyringAccount(tokens);
-	if (tokens.access_token) await setKeyringPassword(KEYRING_SERVICE, `${account}:access`, tokens.access_token);
-	else await deleteKeyringPassword(KEYRING_SERVICE, `${account}:access`);
-	if (tokens.refresh_token) await setKeyringPassword(KEYRING_SERVICE, `${account}:refresh`, tokens.refresh_token);
-	else await deleteKeyringPassword(KEYRING_SERVICE, `${account}:refresh`);
+	if (tokens.access_token) await setKeyringPassword(KEYRING_SERVICE$1, `${account}:access`, tokens.access_token);
+	else await deleteKeyringPassword(KEYRING_SERVICE$1, `${account}:access`);
+	if (tokens.refresh_token) await setKeyringPassword(KEYRING_SERVICE$1, `${account}:refresh`, tokens.refresh_token);
+	else await deleteKeyringPassword(KEYRING_SERVICE$1, `${account}:refresh`);
 }
 async function deleteKeyringTokens(tokens) {
 	const account = getKeyringAccount(tokens);
-	await Promise.all([deleteKeyringPassword(KEYRING_SERVICE, `${account}:access`), deleteKeyringPassword(KEYRING_SERVICE, `${account}:refresh`)]);
+	await Promise.all([deleteKeyringPassword(KEYRING_SERVICE$1, `${account}:access`), deleteKeyringPassword(KEYRING_SERVICE$1, `${account}:refresh`)]);
 }
 async function readTokens() {
 	ensureSeoCliDirs();
@@ -2132,6 +2134,43 @@ function extractCanonicalEvidence($, headers, baseUrl) {
 	return evidenceFromCandidates([...htmlCandidates($, baseUrl), ...headerCandidates(headers, baseUrl)]);
 }
 //#endregion
+//#region packages/core/dist/extract/content-sketch.js
+const SHINGLE_SIZE = 5;
+const MAX_HASHES = 32;
+function words(value) {
+	return value.normalize("NFKC").toLocaleLowerCase("en").match(/[\p{L}\p{N}]+/gu) ?? [];
+}
+function sampleIndexes(total, limit) {
+	if (total <= limit) return Array.from({ length: total }, (_, index) => index);
+	return Array.from({ length: limit }, (_, index) => Math.round(index * (total - 1) / (limit - 1)));
+}
+function digest(value) {
+	return createHash("sha256").update(value).digest("hex").slice(0, 16);
+}
+function contentSketch(value) {
+	const tokens = words(value);
+	const hashes = sampleIndexes(Math.max(0, tokens.length - SHINGLE_SIZE + 1), MAX_HASHES).map((index) => digest(tokens.slice(index, index + SHINGLE_SIZE).join(" ")));
+	return {
+		version: 1,
+		wordCount: tokens.length,
+		shingleSize: SHINGLE_SIZE,
+		sampledShingles: hashes.length,
+		hashes
+	};
+}
+function contentSketchCoverage(source, candidate) {
+	if (!source || source.hashes.length < 4) return null;
+	const targets = new Set(source.hashes);
+	const matched = /* @__PURE__ */ new Set();
+	const tokens = words(candidate);
+	for (let index = 0; index <= tokens.length - source.shingleSize; index += 1) {
+		const hash = digest(tokens.slice(index, index + source.shingleSize).join(" "));
+		if (targets.has(hash)) matched.add(hash);
+		if (matched.size === targets.size) break;
+	}
+	return Math.round(matched.size / targets.size * 1e3) / 1e3;
+}
+//#endregion
 //#region packages/core/dist/extract/main-content.js
 function readableError(error) {
 	return error instanceof Error ? error.message : String(error);
@@ -2749,6 +2788,48 @@ const SOCIAL_PROFILE_HOSTS = [
 	"x.com",
 	"youtube.com"
 ];
+const LOGIN_PATH_PATTERN = /(?:^|\/)(?:auth|login|log-in|signin|sign-in|sso)(?:\/|$)/iu;
+const LOGIN_TITLE_PATTERN = /\b(?:authenticate|log[ -]?in|sign[ -]?in)\b/iu;
+function softAuthenticationGate($, finalUrl, title) {
+	const passwordForms = $("form").toArray().filter((form) => $(form).find("input[type=\"password\" i]").length > 0);
+	if (passwordForms.length === 0) return void 0;
+	const pagePath = new URL(finalUrl).pathname;
+	const action = $(passwordForms[0]).attr("action");
+	const actionUrl = action ? httpUrl$1(action, finalUrl) : void 0;
+	const actionPath = actionUrl ? new URL(actionUrl).pathname : void 0;
+	const indicators = [
+		...LOGIN_PATH_PATTERN.test(pagePath) ? ["login-path"] : [],
+		...LOGIN_TITLE_PATTERN.test(title ?? "") ? ["login-title"] : [],
+		...LOGIN_PATH_PATTERN.test(actionPath ?? "") ? ["login-form-action"] : []
+	];
+	if (indicators.length === 0) return void 0;
+	return {
+		kind: "login-form",
+		indicators,
+		...actionPath ? { formActionPath: actionPath } : {}
+	};
+}
+function tabbedContent($) {
+	const groups = $("[role=\"tablist\" i]").length;
+	const panels = $("[role=\"tabpanel\" i]").toArray();
+	if (groups === 0 || panels.length === 0) return void 0;
+	const panelSketches = panels.slice(0, 12).map((panel) => {
+		const labelledBy = $(panel).attr("aria-labelledby");
+		const labelledElement = labelledBy ? $("[id]").toArray().find((element) => $(element).attr("id") === labelledBy) : void 0;
+		const label = safeText$1($(panel).attr("aria-label") ?? (labelledElement ? $(labelledElement).text() : void 0));
+		return {
+			...label ? { label: label.slice(0, 80) } : {},
+			sketch: contentSketch($(panel).text())
+		};
+	});
+	return {
+		groups,
+		panels: panels.length,
+		retainedPanels: panelSketches.length,
+		truncated: panels.length > panelSketches.length,
+		panelSketches
+	};
+}
 function safeText$1(value) {
 	const trimmed = value?.replace(/\s+/g, " ").trim();
 	return trimmed ? trimmed : void 0;
@@ -2765,7 +2846,7 @@ function absoluteUrl$2(value, base) {
 		return;
 	}
 }
-function httpUrl(value, base) {
+function httpUrl$1(value, base) {
 	const resolved = absoluteUrl$2(value, base);
 	if (!resolved) return void 0;
 	const protocol = new URL(resolved).protocol;
@@ -2917,14 +2998,14 @@ async function extractPage(fetchResult, extractor = "defuddle", dependencies = {
 	let invalidHreflangCount = 0;
 	for (const element of $("link[rel~=\"alternate\"][hreflang][href]").toArray()) {
 		const language = $(element).attr("hreflang") ?? "";
-		const href = httpUrl($(element).attr("href"), fetchResult.finalUrl);
+		const href = httpUrl$1($(element).attr("href"), fetchResult.finalUrl);
 		if (language && href) hreflang.push({
 			hreflang: language,
 			href
 		});
 		else invalidHreflangCount += 1;
 	}
-	const markdownAlternates = [...new Set($("head link[rel~=\"alternate\"][type][href]").toArray().filter((element) => $(element).attr("type")?.trim().toLowerCase() === "text/markdown").map((element) => httpUrl($(element).attr("href"), fetchResult.finalUrl)).filter((value) => Boolean(value)))].sort();
+	const markdownAlternates = [...new Set($("head link[rel~=\"alternate\"][type][href]").toArray().filter((element) => $(element).attr("type")?.trim().toLowerCase() === "text/markdown").map((element) => httpUrl$1($(element).attr("href"), fetchResult.finalUrl)).filter((value) => Boolean(value)))].sort();
 	const openGraph = Object.fromEntries($("meta[property^=\"og:\"]").toArray().map((element) => [$(element).attr("property") ?? "", $(element).attr("content") ?? ""]).filter(([key, value]) => key && value));
 	const twitter = Object.fromEntries($("meta[name^=\"twitter:\"]").toArray().map((element) => [$(element).attr("name") ?? "", $(element).attr("content") ?? ""]).filter(([key, value]) => key && value));
 	const structuredData = extractStructuredData($, fetchResult.finalUrl, { retainJsonLd: extractor !== "crawler" });
@@ -2975,10 +3056,11 @@ async function extractPage(fetchResult, extractor = "defuddle", dependencies = {
 		html: sanitizedContentHtml($, fetchResult.html, fetchResult.finalUrl)
 	}, extractor, dependencies);
 	const { text, excerpt } = content;
+	const title = safeText$1($("title").first().text());
 	return {
 		url: fetchResult.url,
 		finalUrl: fetchResult.finalUrl,
-		title: safeText$1($("title").first().text()),
+		title,
 		metaDescription: safeText$1($("meta[name=\"description\"]").attr("content")),
 		metaRobots,
 		xRobotsTag: safeText$1(headerValue$4(fetchResult.headers, "x-robots-tag")),
@@ -2998,7 +3080,10 @@ async function extractPage(fetchResult, extractor = "defuddle", dependencies = {
 			externalLinks: [...crawlerExternalLinks],
 			internalAnchorSamples,
 			externalAnchorSamples,
-			socialProfileLinks: [...socialProfileLinks]
+			socialProfileLinks: [...socialProfileLinks],
+			contentSketch: contentSketch(text),
+			softAuthenticationGate: softAuthenticationGate($, fetchResult.finalUrl, title),
+			tabbedContent: tabbedContent($)
 		} } : {},
 		markdownAlternates,
 		hreflang,
@@ -4341,7 +4426,7 @@ function urlInspectionQuotaDate(now) {
 function urlInspectionQuotaResetAt(now) {
 	return new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + 1));
 }
-function boundedLimit(value) {
+function boundedLimit$1(value) {
 	const limit = value ?? 2e3;
 	if (!Number.isInteger(limit) || limit < 1 || limit > 2e3) throw new SeoError("INVALID_INPUT", "URL Inspection daily limit must be an integer from 1 to 2000.");
 	return limit;
@@ -4374,7 +4459,7 @@ function reserveUrlInspectionQuota(input) {
 	const database = input.database ?? getDb();
 	const now = input.now ?? /* @__PURE__ */ new Date();
 	const nowMs = now.getTime();
-	const requestedLimit = boundedLimit(input.limit);
+	const requestedLimit = boundedLimit$1(input.limit);
 	const quotaDate = urlInspectionQuotaDate(now);
 	const resetAt = urlInspectionQuotaResetAt(now);
 	const result = database.transaction(() => {
@@ -6157,13 +6242,13 @@ function isLowActionabilityQuery(query) {
 //#endregion
 //#region packages/core/dist/analyze/page-opportunities-selection.js
 const DEFAULT_MIN_IMPRESSIONS$3 = 10;
-const DEFAULT_LIMIT$3 = 25;
-const MAX_LIMIT$3 = 100;
+const DEFAULT_LIMIT$4 = 25;
+const MAX_LIMIT$4 = 100;
 function integerInRange$2(value, fallback, minimum, maximum) {
 	if (value === void 0 || !Number.isFinite(value)) return fallback;
 	return Math.min(maximum, Math.max(minimum, Math.floor(value)));
 }
-function isHttpUrl$1(value) {
+function isHttpUrl$2(value) {
 	try {
 		const parsed = new URL(value);
 		return parsed.protocol === "http:" || parsed.protocol === "https:";
@@ -6185,7 +6270,7 @@ function isBrandRow(input) {
 function normalizePageOpportunityOptions(input) {
 	return {
 		minImpressions: integerInRange$2(input.minImpressions, DEFAULT_MIN_IMPRESSIONS$3, 1, Number.MAX_SAFE_INTEGER),
-		limit: integerInRange$2(input.limit, DEFAULT_LIMIT$3, 1, MAX_LIMIT$3)
+		limit: integerInRange$2(input.limit, DEFAULT_LIMIT$4, 1, MAX_LIMIT$4)
 	};
 }
 function selectTargetRows(input) {
@@ -6204,7 +6289,7 @@ function selectTargetRows(input) {
 	for (const row of input.rows) {
 		const query = row.keys[0]?.trim() ?? "";
 		const page = row.keys[1] ?? "";
-		if (row.keys.length < 2 || !query || !isHttpUrl$1(page) || !hasValidMetrics(row)) {
+		if (row.keys.length < 2 || !query || !isHttpUrl$2(page) || !hasValidMetrics(row)) {
 			selection.invalidRows++;
 			continue;
 		}
@@ -6240,7 +6325,7 @@ function selectTargetRows(input) {
 function selectBenchmarkRows$1(input) {
 	return input.rows.filter((row) => {
 		const query = row.keys[0]?.trim() ?? "";
-		return row.keys.length >= 2 && isHttpUrl$1(row.keys[1] ?? "") && hasValidMetrics(row) && row.position >= 1 && row.position <= 10 && Boolean(query) && !isLowActionabilityQuery(query) && !isBrandRow({
+		return row.keys.length >= 2 && isHttpUrl$2(row.keys[1] ?? "") && hasValidMetrics(row) && row.position >= 1 && row.position <= 10 && Boolean(query) && !isLowActionabilityQuery(query) && !isBrandRow({
 			query,
 			site: input.site,
 			brandTerms: input.brandTerms,
@@ -6422,7 +6507,7 @@ const defaultDependencies$14 = {
 	extract: extractPage,
 	now: () => /* @__PURE__ */ new Date()
 };
-function errorMessage$1(error) {
+function errorMessage$2(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 function unique$4(values) {
@@ -6443,7 +6528,7 @@ async function verifyPage(input) {
 		});
 		warnings.push(...fetched.warnings);
 	} catch (error) {
-		const reason = `Page fetch failed: ${errorMessage$1(error)}`;
+		const reason = `Page fetch failed: ${errorMessage$2(error)}`;
 		return {
 			verification: {
 				status: "failed",
@@ -6465,7 +6550,7 @@ async function verifyPage(input) {
 			warnings: unique$4(warnings)
 		};
 	} catch (error) {
-		const reason = `Page extraction failed: ${errorMessage$1(error)}`;
+		const reason = `Page extraction failed: ${errorMessage$2(error)}`;
 		return {
 			fetched,
 			verification: {
@@ -7103,6 +7188,8 @@ function markdownQuality(markdown, page) {
 	const codeFences = markdown.match(/^```/gmu)?.length ?? 0;
 	const wordCount = bodyWordCount(markdown);
 	const sourceWordCount = page.wordCount ?? 0;
+	const evaluatedPanels = (page.tabbedContent?.panelSketches ?? []).map((panel) => contentSketchCoverage(panel.sketch, markdown)).filter((coverage) => coverage !== null);
+	const retainedPanels = evaluatedPanels.filter((coverage) => coverage >= .6).length;
 	return {
 		frontmatterTitle: /^---[\s\S]*?^title:\s*.+$/mu.test(markdown),
 		h1Count: markdown.match(/^#\s+\S.+$/gmu)?.length ?? 0,
@@ -7119,7 +7206,15 @@ function markdownQuality(markdown, page) {
 		sourceWordCount,
 		wordRetentionRatio: sourceWordCount > 0 ? Math.round(wordCount / sourceWordCount * 1e3) / 1e3 : null,
 		introductoryCopyRetained: introProbe ? normalizedMarkdown.includes(introProbe) : null,
-		navigationOnly: bodyWordCount(markdown) < 25
+		navigationOnly: bodyWordCount(markdown) < 25,
+		contentSketchCoverage: contentSketchCoverage(page.contentSketch, markdown),
+		tabbedContent: {
+			detectedPanels: page.tabbedContent?.panels ?? 0,
+			evaluatedPanels: evaluatedPanels.length,
+			retainedPanels,
+			missingPanels: Math.max(0, evaluatedPanels.length - retainedPanels),
+			complete: evaluatedPanels.length === 0 ? null : retainedPanels === evaluatedPanels.length
+		}
 	};
 }
 function combinedSignal(timeoutMs, signal) {
@@ -7173,6 +7268,8 @@ async function fetchRepresentation(input) {
 				status: response.status,
 				contentType: response.headers.get("content-type") ?? void 0,
 				bytes: Buffer.byteLength(body),
+				characters: body.length,
+				estimatedTokens: Math.ceil(body.length / 4),
 				sha256: sha256(body),
 				canonicalUrl: link.find((entry) => entry.rel.includes("canonical"))?.url,
 				alternateUrl: link.find((entry) => entry.rel.includes("alternate") && entry.type === "text/markdown")?.url,
@@ -7231,11 +7328,15 @@ async function inspectMarkdownPage(input) {
 	if (explicit) observation.explicit = explicit.observation;
 	observation.negotiated = negotiated.observation;
 	observation.repeated = repeated.observation;
-	observation.explicitMatchesNegotiated = explicit?.observation.sha256 && negotiated.observation.sha256 ? explicit.observation.sha256 === negotiated.observation.sha256 : null;
-	const primary = explicit ?? negotiated;
-	observation.repeatedHashStable = primary.observation.sha256 && repeated.observation.sha256 ? primary.observation.sha256 === repeated.observation.sha256 : null;
-	observation.markdownCanonicalMatchesHtml = sameDocument(primary.observation.canonicalUrl, input.page.finalUrl);
-	if (primary.body) observation.quality = markdownQuality(primary.body, input.page);
+	const isMarkdown = (result) => result?.observation.status !== void 0 && result.observation.status >= 200 && result.observation.status < 300 && /^\s*text\/markdown\b/iu.test(result.observation.contentType ?? "");
+	const explicitMarkdown = isMarkdown(explicit) ? explicit : void 0;
+	const negotiatedMarkdown = isMarkdown(negotiated) ? negotiated : void 0;
+	const repeatedMarkdown = isMarkdown(repeated) ? repeated : void 0;
+	observation.explicitMatchesNegotiated = explicitMarkdown?.observation.sha256 && negotiatedMarkdown?.observation.sha256 ? explicitMarkdown.observation.sha256 === negotiatedMarkdown.observation.sha256 : null;
+	const primary = explicitMarkdown ?? negotiatedMarkdown;
+	observation.repeatedHashStable = primary?.observation.sha256 && repeatedMarkdown?.observation.sha256 ? primary.observation.sha256 === repeatedMarkdown.observation.sha256 : null;
+	observation.markdownCanonicalMatchesHtml = sameDocument(primary?.observation.canonicalUrl, input.page.finalUrl);
+	if (primary?.body) observation.quality = markdownQuality(primary.body, input.page);
 	return observation;
 }
 async function fetchText(input) {
@@ -7479,17 +7580,16 @@ async function inspectRouteManifest(input) {
 		const declared = Array.isArray(parsed.pages) ? parsed.pages : [];
 		const declaredHtmlRoutes = declared.map((page) => page.htmlPath).filter((path) => typeof path === "string").sort();
 		const declaredMarkdownRoutes = declared.map((page) => page.markdownPath).filter((path) => typeof path === "string").sort();
-		const crawledHtmlRoutes = new Set(input.pages.map((page) => new URL(page.finalUrl).pathname.replace(/\/$/u, "") || "/"));
-		const observedMarkdownRoutes = new Set(input.observations.flatMap((page) => page.advertisedUrls.map((value) => new URL(value).pathname)));
 		return {
 			url,
 			status: result.response.status,
 			valid: Array.isArray(parsed.pages),
 			declaredHtmlRoutes,
 			declaredMarkdownRoutes,
-			missingHtmlRoutes: declaredHtmlRoutes.filter((path) => !crawledHtmlRoutes.has(path.replace(/\/$/u, "") || "/")).sort(),
-			missingMarkdownRoutes: declaredMarkdownRoutes.filter((path) => !observedMarkdownRoutes.has(path)).sort(),
-			orphanMarkdownRoutes: [...observedMarkdownRoutes].filter((path) => !declaredMarkdownRoutes.includes(path)).sort()
+			missingHtmlRoutes: [],
+			missingMarkdownRoutes: [],
+			orphanMarkdownRoutes: [],
+			comparisonStatus: "partial"
 		};
 	} catch (error) {
 		return {
@@ -7500,6 +7600,7 @@ async function inspectRouteManifest(input) {
 			missingHtmlRoutes: [],
 			missingMarkdownRoutes: [],
 			orphanMarkdownRoutes: [],
+			comparisonStatus: "not-applicable",
 			error: safeError(error)
 		};
 	}
@@ -7543,9 +7644,7 @@ async function collectAgentDiscovery(input) {
 		}),
 		inspectRouteManifest({
 			...input,
-			origin,
-			pages,
-			observations
+			origin
 		}),
 		inspectAgentEndpoints({
 			...input,
@@ -7650,20 +7749,13 @@ async function collectAgentDiscovery(input) {
 	};
 }
 //#endregion
-//#region packages/core/dist/analyze/crawler/agent-readiness.js
-function check$1(section, input) {
+//#region packages/core/dist/analyze/crawler/agent-readiness-markdown.js
+function check$2(section, input) {
 	return {
 		section,
 		...input
 	};
 }
-function section$1(id, title, checks) {
-	return {
-		id,
-		title,
-		checks
-	};
-}
 function failedMarkdownUrls(discovery) {
 	return discovery.markdownAlternates.pages.filter((page) => {
 		const negotiatedOk = page.negotiated?.status === 200 && /^\s*text\/markdown\b/iu.test(page.negotiated.contentType ?? "") && page.negotiated.varyAccept;
@@ -7674,38 +7766,12 @@ function failedMarkdownUrls(discovery) {
 function qualityFailureUrls(discovery) {
 	return discovery.markdownAlternates.pages.filter((page) => {
 		const quality = page.quality;
-		if (!quality) return true;
-		return !quality.frontmatterTitle || quality.h1Count !== 1 || !quality.codeFenceBalanced || quality.rawHtmlTags > 0 || quality.rawSvgTags > 0 || quality.rawScriptTags > 0 || quality.rawStyleTags > 0 || quality.navigationOnly || quality.repeatedLines > 0 || quality.wordRetentionRatio !== null && quality.wordRetentionRatio < .4;
+		if (!quality) return false;
+		return !quality.frontmatterTitle || quality.h1Count !== 1 || !quality.codeFenceBalanced || quality.rawHtmlTags > 0 || quality.rawSvgTags > 0 || quality.rawScriptTags > 0 || quality.rawStyleTags > 0 || quality.navigationOnly || quality.repeatedLines > 0 || quality.contentSketchCoverage !== null && quality.contentSketchCoverage !== void 0 && quality.contentSketchCoverage < .6 || quality.tabbedContent?.complete === false || quality.wordRetentionRatio !== null && quality.wordRetentionRatio < .4;
 	}).map((page) => page.htmlUrl);
 }
-function profileChecks(discovery) {
-	return [
-		"api",
-		"application",
-		"commerce"
-	].map((profile) => check$1("profile", {
-		id: `profile-${profile}`,
-		status: "notApplicable",
-		title: `${profile[0]?.toUpperCase()}${profile.slice(1)} checks are not applicable`,
-		plainEnglish: discovery.profileApplicability[profile].reason,
-		action: "Choose this profile only when the site exposes that capability publicly.",
-		evidence: {
-			profile,
-			selectedProfile: discovery.profile
-		}
-	}));
-}
-function summariseChecks(checks) {
-	const count = (status) => checks.filter((item) => item.status === status).length;
-	return {
-		checks: checks.length,
-		passed: count("pass"),
-		warnings: count("warning"),
-		failed: count("fail"),
-		unknown: count("unknown"),
-		information: count("info"),
-		notApplicable: count("notApplicable")
-	};
+function confirmedMarkdown(page) {
+	for (const response of [page.explicit, page.negotiated]) if (response?.status !== void 0 && response.status >= 200 && response.status < 300 && /^\s*text\/markdown\b/iu.test(response.contentType ?? "")) return response;
 }
 function markdownChecks(discovery) {
 	const markdown = discovery.markdownAlternates;
@@ -7715,12 +7781,28 @@ function markdownChecks(discovery) {
 	const explicitPages = markdown.pages.filter((page) => page.htmlAlternateUnique).length;
 	const coverageComplete = markdown.eligibleHtmlPages > 0 && markdown.evaluatedPages === markdown.eligibleHtmlPages;
 	const negotiationComplete = markdown.eligibleHtmlPages > 0 && negotiatedPages === markdown.eligibleHtmlPages && markdown.pages.every((page) => page.negotiated?.varyAccept) && markdown.pages.every((page) => !page.htmlAlternateUnique || page.explicitMatchesNegotiated === true);
-	const stable = markdown.eligibleHtmlPages > 0 && markdown.stableResponses === markdown.eligibleHtmlPages;
+	const stable = markdown.evaluatedPages > 0 && markdown.stableResponses === markdown.evaluatedPages;
 	const tokenHeaders = markdown.pages.filter((page) => {
-		return (page.explicit ?? page.negotiated)?.markdownTokens !== void 0 && (!page.explicit || !page.negotiated || page.explicit.markdownTokens === page.negotiated.markdownTokens);
+		return confirmedMarkdown(page)?.markdownTokens !== void 0 && (!page.explicit || !page.negotiated || page.explicit.markdownTokens === page.negotiated.markdownTokens);
 	}).length;
+	const sizedPages = markdown.pages.filter((page) => {
+		return confirmedMarkdown(page)?.characters !== void 0;
+	});
+	const largePages = sizedPages.filter((page) => {
+		return (confirmedMarkdown(page)?.characters ?? 0) > 5e4;
+	});
+	const veryLargePages = sizedPages.filter((page) => {
+		return (confirmedMarkdown(page)?.characters ?? 0) > 1e5;
+	});
+	const maxCharacters = Math.max(0, ...sizedPages.map((page) => confirmedMarkdown(page)?.characters ?? 0));
+	const maxEstimatedTokens = Math.max(0, ...sizedPages.map((page) => confirmedMarkdown(page)?.estimatedTokens ?? 0));
+	const parityPages = markdown.pages.filter((page) => page.quality?.contentSketchCoverage !== null && page.quality?.contentSketchCoverage !== void 0);
+	const parityFailures = parityPages.filter((page) => (page.quality?.contentSketchCoverage ?? 0) < .6);
+	const tabbedPages = markdown.pages.filter((page) => (page.quality?.tabbedContent?.detectedPanels ?? 0) > 0);
+	const tabFailures = tabbedPages.filter((page) => page.quality?.tabbedContent?.complete === false);
+	const tabUnknown = tabbedPages.filter((page) => page.quality?.tabbedContent?.complete === null);
 	return [
-		check$1("representations", {
+		check$2("representations", {
 			id: "markdown-coverage",
 			status: markdown.eligibleHtmlPages === 0 ? "unknown" : coverageComplete ? "pass" : "fail",
 			title: coverageComplete ? "Every successful HTML page has a Markdown representation" : "Markdown representation coverage is incomplete",
@@ -7734,17 +7816,62 @@ function markdownChecks(discovery) {
 			},
 			urls: failedUrls.slice(0, 25)
 		}),
-		check$1("representations", {
+		check$2("representations", {
 			id: "markdown-token-estimates",
-			status: markdown.evaluatedPages === 0 ? "unknown" : tokenHeaders === markdown.evaluatedPages ? "pass" : "warning",
+			status: markdown.evaluatedPages === 0 ? "unknown" : tokenHeaders === markdown.evaluatedPages ? "pass" : "info",
 			title: tokenHeaders === markdown.evaluatedPages ? "Every Markdown response includes a token estimate" : "Some Markdown responses are missing a stable token estimate",
 			plainEnglish: `${tokenHeaders} of ${markdown.evaluatedPages} evaluated pages returned X-Markdown-Tokens. Paired explicit and negotiated responses agreed where both existed. The value is an estimate, not an exact model-specific token count.`,
-			action: "Return a stable token estimate and keep it consistent when both explicit and negotiated responses exist.",
+			action: tokenHeaders === markdown.evaluatedPages ? "Keep the estimate stable when both explicit and negotiated responses exist." : "No change is required. X-Markdown-Tokens is optional; local size estimates are reported separately.",
 			urls: markdown.pages.filter((page) => {
-				return (page.explicit ?? page.negotiated)?.markdownTokens === void 0 || page.explicit !== void 0 && page.negotiated !== void 0 && page.explicit.markdownTokens !== page.negotiated.markdownTokens;
+				return confirmedMarkdown(page)?.markdownTokens === void 0 || page.explicit !== void 0 && page.negotiated !== void 0 && page.explicit.markdownTokens !== page.negotiated.markdownTokens;
 			}).map((page) => page.htmlUrl).slice(0, 25)
 		}),
-		check$1("representations", {
+		check$2("representations", {
+			id: "markdown-size",
+			status: sizedPages.length === 0 ? "unknown" : largePages.length === 0 ? "pass" : "warning",
+			title: sizedPages.length === 0 ? "Markdown size was not measured" : largePages.length === 0 ? "Markdown representations stay within the review threshold" : "Some Markdown representations are large enough to review",
+			plainEnglish: `${sizedPages.length} Markdown responses were measured locally. ${largePages.length} exceeded 50,000 characters and ${veryLargePages.length} exceeded 100,000 characters. These are processing-risk thresholds, not universal model limits.`,
+			action: largePages.length === 0 ? "Keep important content early and retain stable section structure as pages grow." : "Split genuinely separate topics, keep navigation and repeated chrome out of Markdown, and put the most useful content early. Do not remove necessary detail just to hit a threshold.",
+			evidence: {
+				measuredPages: sizedPages.length,
+				reviewThresholdCharacters: 5e4,
+				highRiskThresholdCharacters: 1e5,
+				largePages: largePages.length,
+				veryLargePages: veryLargePages.length,
+				maxCharacters,
+				maxEstimatedTokens,
+				heuristic: true
+			},
+			urls: largePages.map((page) => page.htmlUrl).slice(0, 25)
+		}),
+		check$2("representations", {
+			id: "markdown-content-parity",
+			status: parityPages.length === 0 ? "unknown" : parityFailures.length === 0 ? "pass" : "warning",
+			title: parityPages.length === 0 ? "HTML and Markdown content parity was not measured" : parityFailures.length === 0 ? "Markdown retains sampled content from the HTML document" : "Some Markdown responses may omit important HTML content",
+			plainEnglish: `${parityPages.length} pages were compared using bounded hashes sampled across the main HTML content. ${parityFailures.length} retained less than 60% of that sample. This detects likely omissions without storing full page bodies.`,
+			action: parityFailures.length === 0 ? "Keep the shared conversion path covered as templates and components change." : "Compare the affected HTML and Markdown around the missing sections, then fix the shared converter or component serialization.",
+			evidence: {
+				evaluatedPages: parityPages.length,
+				failedPages: parityFailures.length,
+				minimumCoverage: .6,
+				sampling: "bounded-content-shingles"
+			},
+			urls: parityFailures.map((page) => page.htmlUrl).slice(0, 25)
+		}),
+		check$2("representations", {
+			id: "markdown-tab-serialization",
+			status: tabbedPages.length === 0 ? "notApplicable" : tabFailures.length > 0 ? "warning" : tabUnknown.length > 0 ? "unknown" : "pass",
+			title: tabbedPages.length === 0 ? "No accessible tabbed content was detected" : tabFailures.length > 0 ? "Some tab panels are missing from Markdown" : tabUnknown.length > 0 ? "Some tab panels were too small to compare reliably" : "Markdown retains detected tab panels",
+			plainEnglish: tabbedPages.length === 0 ? "The crawled HTML did not contain ARIA tablists with tab panels, so this check does not apply." : `${tabbedPages.length} pages contained accessible tab panels. ${tabFailures.length} did not retain every evaluated panel in Markdown, and ${tabUnknown.length} had no panel large enough for a reliable comparison.`,
+			action: tabFailures.length === 0 ? tabUnknown.length > 0 ? "Review the affected page directly if the short tab labels or values are important to the document." : "Keep every panel serialized in document order even when only one tab is visible by default." : "Serialize all tab panels into the Markdown document with headings instead of exporting only the initially active panel.",
+			evidence: {
+				tabbedPages: tabbedPages.length,
+				failedPages: tabFailures.length,
+				unknownPages: tabUnknown.length
+			},
+			urls: [...tabFailures, ...tabUnknown].map((page) => page.htmlUrl).slice(0, 25)
+		}),
+		check$2("representations", {
 			id: "markdown-negotiation",
 			status: markdown.eligibleHtmlPages === 0 ? "unknown" : negotiationComplete && discovery.contentNegotiation.qZeroHonoured ? "pass" : "fail",
 			title: negotiationComplete && discovery.contentNegotiation.qZeroHonoured ? "Markdown content negotiation works across the site" : "Markdown content negotiation needs attention",
@@ -7758,16 +7885,16 @@ function markdownChecks(discovery) {
 			},
 			urls: failedUrls.slice(0, 25)
 		}),
-		check$1("representations", {
+		check$2("representations", {
 			id: "markdown-determinism",
-			status: markdown.eligibleHtmlPages === 0 ? "unknown" : stable ? "pass" : "fail",
+			status: markdown.evaluatedPages === 0 ? "unknown" : stable ? "pass" : "fail",
 			title: stable ? "Repeated Markdown responses are stable" : "Repeated Markdown responses changed during the audit",
-			plainEnglish: `${markdown.stableResponses} of ${markdown.eligibleHtmlPages} repeated Markdown responses kept the same SHA-256 digest.`,
+			plainEnglish: `${markdown.stableResponses} of ${markdown.evaluatedPages} repeated Markdown responses kept the same SHA-256 digest.`,
 			action: "Remove timestamps, random output, or other runtime rewriting that changes the same Markdown response between requests.",
 			evidence: { stableResponses: markdown.stableResponses },
 			urls: failedUrls.slice(0, 25)
 		}),
-		check$1("representations", {
+		check$2("representations", {
 			id: "markdown-quality",
 			status: markdown.evaluatedPages === 0 ? "unknown" : qualityUrls.length === 0 ? "pass" : "warning",
 			title: qualityUrls.length === 0 ? "Markdown keeps the useful document structure cleanly" : "Some Markdown alternatives need an extraction review",
@@ -7777,6 +7904,50 @@ function markdownChecks(discovery) {
 		})
 	];
 }
+//#endregion
+//#region packages/core/dist/analyze/crawler/agent-readiness.js
+function check$1(section, input) {
+	return {
+		section,
+		...input
+	};
+}
+function section$2(id, title, checks) {
+	return {
+		id,
+		title,
+		checks
+	};
+}
+function profileChecks(discovery) {
+	return [
+		"api",
+		"application",
+		"commerce"
+	].map((profile) => check$1("profile", {
+		id: `profile-${profile}`,
+		status: "notApplicable",
+		title: `${profile[0]?.toUpperCase()}${profile.slice(1)} checks are not applicable`,
+		plainEnglish: discovery.profileApplicability[profile].reason,
+		action: "Choose this profile only when the site exposes that capability publicly.",
+		evidence: {
+			profile,
+			selectedProfile: discovery.profile
+		}
+	}));
+}
+function summariseChecks(checks) {
+	const count = (status) => checks.filter((item) => item.status === status).length;
+	return {
+		checks: checks.length,
+		passed: count("pass"),
+		warnings: count("warning"),
+		failed: count("fail"),
+		unknown: count("unknown"),
+		information: count("info"),
+		notApplicable: count("notApplicable")
+	};
+}
 function contentSignalsCheck(discovery, robotsContentSignals) {
 	const signals = discovery.contentSignals;
 	const robotsDeclared = robotsContentSignals ?? [];
@@ -7877,8 +8048,8 @@ function discoveryChecks(discovery, robotsContentSignals) {
 		check$1("discovery", {
 			id: "route-manifest",
 			status: !discovery.routeManifest.valid ? "info" : discovery.routeManifest.missingHtmlRoutes.length === 0 && discovery.routeManifest.missingMarkdownRoutes.length === 0 && discovery.routeManifest.orphanMarkdownRoutes.length === 0 ? "pass" : "warning",
-			title: discovery.routeManifest.valid ? "The public route manifest agrees with the crawl" : "No public route manifest was available",
-			plainEnglish: discovery.routeManifest.valid ? `The manifest declared ${discovery.routeManifest.declaredHtmlRoutes.length} HTML routes and ${discovery.routeManifest.declaredMarkdownRoutes.length} Markdown routes. Missing or orphan routes are listed in the evidence.` : "A public route manifest is optional. Without one, this crawl cannot prove that no orphan Markdown files were deployed.",
+			title: discovery.routeManifest.valid ? "The public route manifest is valid" : "No public route manifest was available",
+			plainEnglish: discovery.routeManifest.valid ? `The manifest declared ${discovery.routeManifest.declaredHtmlRoutes.length} HTML routes and ${discovery.routeManifest.declaredMarkdownRoutes.length} Markdown routes. This bounded crawl did not treat unvisited routes as missing.` : "A public route manifest is optional. Without one, this crawl cannot prove that no orphan Markdown files were deployed.",
 			action: "Generate one deterministic route inventory from the build when exact HTML and Markdown parity matters.",
 			evidence: discovery.routeManifest
 		})
@@ -8009,25 +8180,42 @@ function accessChecks(report, discovery) {
 	const blocked = bots.filter((bot) => bot.allowed === false);
 	const robotsKnown = report.ai?.robotsTxt?.availability === "available" || report.ai?.robotsTxt?.availability === "absent";
 	const protocol = discovery.protocolVariants;
-	return [check$1("access", {
-		id: "crawler-access",
-		status: !robotsKnown ? "unknown" : blocked.length > 0 ? "warning" : "pass",
-		title: blocked.length ? "robots.txt blocks selected crawler tokens" : "No selected crawler token is blocked at the start URL",
-		plainEnglish: robotsKnown ? `${blocked.length} of ${bots.length} selected crawler tokens were blocked by the start URL robots.txt policy.` : "The robots.txt response was not stable enough to make a crawler-access claim.",
-		action: "Keep blocks intentional. A crawler token being allowed here does not prove that the service will crawl, index, or cite the site.",
-		evidence: {
-			availability: report.ai?.robotsTxt?.availability,
-			blocked,
-			botAccess: bots
-		}
-	}), check$1("access", {
-		id: "protocol-canonicalization",
-		status: protocol.http.permanentRedirectToHttps === true && protocol.hstsOnStartPage === true ? "pass" : protocol.http.permanentRedirectToHttps === null ? "unknown" : "warning",
-		title: protocol.http.permanentRedirectToHttps === true && protocol.hstsOnStartPage === true ? "HTTP redirects permanently to HTTPS and HTTPS sends HSTS" : "Protocol canonicalization needs attention or could not be proven",
-		plainEnglish: `The HTTP variant ${protocol.http.permanentRedirectToHttps === true ? "redirected permanently to HTTPS" : "did not produce a confirmed permanent HTTPS redirect"}. The HTTPS start page ${protocol.hstsOnStartPage ? "sent HSTS" : "did not provide confirmed HSTS evidence"}.`,
-		action: "Use one permanent HTTP-to-HTTPS redirect and send HSTS only after HTTPS is stable across the site.",
-		evidence: protocol
-	})];
+	const authenticationGates = report.issues.filter((issue) => issue.ruleId === "soft_authentication_gate");
+	const clientRenderedPages = report.issues.filter((issue) => issue.ruleId === "client_rendered_content");
+	return [
+		check$1("access", {
+			id: "crawler-access",
+			status: !robotsKnown ? "unknown" : blocked.length > 0 ? "warning" : "pass",
+			title: blocked.length ? "robots.txt blocks selected crawler tokens" : "No selected crawler token is blocked at the start URL",
+			plainEnglish: robotsKnown ? `${blocked.length} of ${bots.length} selected crawler tokens were blocked by the start URL robots.txt policy.` : "The robots.txt response was not stable enough to make a crawler-access claim.",
+			action: "Keep blocks intentional. A crawler token being allowed here does not prove that the service will crawl, index, or cite the site.",
+			evidence: {
+				availability: report.ai?.robotsTxt?.availability,
+				blocked,
+				botAccess: bots
+			}
+		}),
+		check$1("access", {
+			id: "public-content-access",
+			status: authenticationGates.length > 0 || clientRenderedPages.length > 0 ? "warning" : "pass",
+			title: authenticationGates.length > 0 || clientRenderedPages.length > 0 ? "Some public content may be difficult for constrained clients to reach" : "No login gate or empty initial document was detected",
+			plainEnglish: `${authenticationGates.length} crawled pages looked like login gates and ${clientRenderedPages.length} relied on JavaScript to replace an empty or near-empty initial document. These are general site-health observations reused here because they affect agents that do not maintain sessions or run JavaScript.`,
+			action: authenticationGates.length > 0 || clientRenderedPages.length > 0 ? "Make intended public content available without a session and include its important document content in the initial HTML or a complete server-generated representation." : "Keep important public content available without a session or client-side rendering requirement.",
+			evidence: {
+				authenticationGates: authenticationGates.length,
+				clientRenderedPages: clientRenderedPages.length
+			},
+			urls: [...authenticationGates, ...clientRenderedPages].map((issue) => issue.url).slice(0, 25)
+		}),
+		check$1("access", {
+			id: "protocol-canonicalization",
+			status: protocol.http.permanentRedirectToHttps === true && protocol.hstsOnStartPage === true ? "pass" : protocol.http.permanentRedirectToHttps === null ? "unknown" : "warning",
+			title: protocol.http.permanentRedirectToHttps === true && protocol.hstsOnStartPage === true ? "HTTP redirects permanently to HTTPS and HTTPS sends HSTS" : "Protocol canonicalization needs attention or could not be proven",
+			plainEnglish: `The HTTP variant ${protocol.http.permanentRedirectToHttps === true ? "redirected permanently to HTTPS" : "did not produce a confirmed permanent HTTPS redirect"}. The HTTPS start page ${protocol.hstsOnStartPage ? "sent HSTS" : "did not provide confirmed HSTS evidence"}.`,
+			action: "Use one permanent HTTP-to-HTTPS redirect and send HSTS only after HTTPS is stable across the site.",
+			evidence: protocol
+		})
+	];
 }
 function identityChecks(report) {
 	const types = new Set(report.pages.flatMap((page) => page.schemaTypes ?? []));
@@ -8095,19 +8283,19 @@ function agentReadiness(report) {
 			headline: "No agent-discovery evidence is stored in this crawl. Run a fresh focused check.",
 			profileApplicability: profiles,
 			summary: summariseChecks(checks),
-			sections: [section$1("collection", "Evidence collection", [missing]), section$1("profile", "Profile scope", scopeChecks)],
+			sections: [section$2("collection", "Evidence collection", [missing]), section$2("profile", "Profile scope", scopeChecks)],
 			checks,
 			topActions: [missing],
 			caveats: ["Not evaluated does not mean absent or broken.", "This report does not measure rankings, AI mentions, citations, or selection."]
 		};
 	}
 	const sections = [
-		section$1("profile", "Profile scope", profileChecks(discovery)),
-		section$1("access", "Crawler and protocol access", accessChecks(report, discovery)),
-		section$1("representations", "HTML and Markdown representations", markdownChecks(discovery)),
-		section$1("discovery", "Agent discovery files", discoveryChecks(discovery, report.ai?.robotsTxt?.contentSignals)),
-		section$1("endpoints", "Agent endpoints and auth discovery", endpointChecks(discovery)),
-		section$1("identity", "Identity evidence", identityChecks(report))
+		section$2("profile", "Profile scope", profileChecks(discovery)),
+		section$2("access", "Crawler and protocol access", accessChecks(report, discovery)),
+		section$2("representations", "HTML and Markdown representations", markdownChecks(discovery)),
+		section$2("discovery", "Agent discovery files", discoveryChecks(discovery, report.ai?.robotsTxt?.contentSignals)),
+		section$2("endpoints", "Agent endpoints and auth discovery", endpointChecks(discovery)),
+		section$2("identity", "Identity evidence", identityChecks(report))
 	];
 	const checks = sections.flatMap((item) => item.checks);
 	const actionable = checks.filter((item) => [
@@ -8294,7 +8482,7 @@ function status(score, maxScore) {
 	if (ratio >= .5) return "warning";
 	return "fail";
 }
-function section(id, title, checks) {
+function section$1(id, title, checks) {
 	return {
 		id,
 		title,
@@ -8352,7 +8540,7 @@ function aiReadiness(report) {
 	const blockedSnippets = restrictedSnippets.filter(({ control }) => control.status === "blocked");
 	const limitedSnippets = restrictedSnippets.filter(({ control }) => control.status === "limited");
 	const sections = [
-		section("agent-access", "Agent access", [
+		section$1("agent-access", "Agent access", [
 			check({
 				id: "robots-ai-bots",
 				section: "agent-access",
@@ -8395,7 +8583,7 @@ function aiReadiness(report) {
 				evidence: { resources: report.ai?.agentResources ?? [] }
 			})
 		]),
-		section("machine-readable", "Machine-readable signals", [check({
+		section$1("machine-readable", "Machine-readable signals", [check({
 			id: "llms-txt",
 			section: "machine-readable",
 			maxScore: 0,
@@ -8420,7 +8608,7 @@ function aiReadiness(report) {
 			action: invalidJsonLdPages.length ? "Fix invalid JSON-LD before relying on its structured-data claims." : "Use structured data only where it accurately represents the visible page and a supported use case.",
 			urls: invalidJsonLdPages.slice(0, 10).map((page) => page.finalUrl)
 		})]),
-		section("content-clarity", "Content clarity", [
+		section$1("content-clarity", "Content clarity", [
 			check({
 				id: "answerable-content",
 				section: "content-clarity",
@@ -8470,7 +8658,7 @@ function aiReadiness(report) {
 				action: "Set the html lang attribute so crawlers and assistive tech understand the page language."
 			})
 		]),
-		section("entity-signals", "Entity signals", [check({
+		section$1("entity-signals", "Entity signals", [check({
 			id: "entity-schema",
 			section: "entity-signals",
 			maxScore: 0,
@@ -8489,7 +8677,7 @@ function aiReadiness(report) {
 			plainEnglish: "Author and date signals help agents judge freshness and accountability.",
 			action: "Add visible authors, reviewed dates, and updated dates to content where trust and freshness matter."
 		})]),
-		section("technical-ux", "Technical UX", [
+		section$1("technical-ux", "Technical UX", [
 			check({
 				id: "snippet-controls",
 				section: "technical-ux",
@@ -8527,7 +8715,7 @@ function aiReadiness(report) {
 				action: "Fix 4xx/5xx pages, accidental noindex, and blocked internal URLs before expanding AI discovery work."
 			})
 		]),
-		section("agent-content", "Agent content observations", [
+		section$1("agent-content", "Agent content observations", [
 			check({
 				id: "markdown-alternates",
 				section: "agent-content",
@@ -8567,7 +8755,7 @@ function aiReadiness(report) {
 				evidence: agentDiscovery?.profileApplicability
 			})
 		]),
-		section("crawl-completeness", "Crawl completeness", [check({
+		section$1("crawl-completeness", "Crawl completeness", [check({
 			id: "crawl-depth",
 			section: "crawl-completeness",
 			maxScore: 8,
@@ -9556,6 +9744,48 @@ const RULE_DEFINITIONS = [
 			suggestedCommands: ["seo crawl --sitemap-url <url> --health --json"]
 		}
 	},
+	{
+		id: "soft_authentication_gate",
+		title: "Page appears to be an authentication gate",
+		category: "response",
+		defaultSeverity: "medium",
+		whyItMatters: "The URL returned a successful HTML response, but the visible document looks like a login gate rather than the intended public page. Users and crawlers may receive a 200 response without the content they expected.",
+		howToFix: "Confirm whether authentication is intentional. Public URLs should return their public content without a login form. Protected URLs should use a clear 401 or 403 response where appropriate and should not appear in public sitemaps or internal crawl paths.",
+		impactIfIgnored: "A login page can be mistaken for the intended content, producing misleading crawl results and weak search or agent access.",
+		howToVerify: "Fetch the affected URL without a session and confirm it returns the intended public page, or a deliberate authentication status for protected content.",
+		agentHints: {
+			evidenceFields: ["page.softAuthenticationGate", "page.finalUrl"],
+			suggestedCommands: ["seo crawl <url> --max-pages 1 --json"]
+		}
+	},
+	{
+		id: "client_rendered_content",
+		title: "Important content requires JavaScript rendering",
+		category: "response",
+		defaultSeverity: "medium",
+		whyItMatters: "The raw HTML contained very little content and the useful document appeared only after JavaScript rendering. Some crawlers, agents, previews, and constrained clients do not run the page JavaScript.",
+		howToFix: "Render the important page content into the initial HTML, or publish a complete server-generated representation such as negotiated Markdown. Keep navigation, headings, canonicals, and indexability signals available without client execution.",
+		impactIfIgnored: "Clients that do not execute JavaScript may see an empty shell or miss important content and links.",
+		howToVerify: "Re-run the crawl and confirm the raw and rendered content observations contain the same important document content.",
+		agentHints: {
+			evidenceFields: ["page.fetchDiagnostics.rendering.documentDifference", "page.usedJs"],
+			suggestedCommands: ["seo crawl <url> --json"]
+		}
+	},
+	{
+		id: "soft_404",
+		title: "Unknown URLs return a successful response",
+		category: "response",
+		defaultSeverity: "high",
+		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.",
+		agentHints: {
+			evidenceFields: ["report.siteChecks.soft404"],
+			suggestedCommands: ["seo crawl <url> --json"]
+		}
+	},
 	{
 		id: "client_error",
 		title: "Client error",
@@ -10045,6 +10275,8 @@ const RULE_RECOMMENDATIONS = {
 	x_robots_noindex: "review",
 	robots_blocked: "review",
 	crawler_access_blocked: "review",
+	soft_authentication_gate: "review",
+	client_rendered_content: "review",
 	orphan_page: "review",
 	redirected_url: "review",
 	slow_response: "review",
@@ -10135,6 +10367,28 @@ const WEAK_VALUABLE_INLINKS = 1;
 const QUERY_COVERAGE_MIN_IMPRESSIONS = 50;
 const QUERY_COVERAGE_MIN = .6;
 const OVERSIZED_IMAGE_CANDIDATE_LIMIT = 2e3;
+const EMPTY_INITIAL_HTML_CHARACTERS = 200;
+const SUBSTANTIVE_RENDERED_CHARACTERS = 500;
+function clientRenderedContentEvidence(page) {
+	const rendering = page.fetchDiagnostics?.rendering;
+	const difference = rendering?.documentDifference;
+	if (rendering?.status !== "rendered" || !difference?.changed.includes("content")) return;
+	const rawCharacters = difference.raw.content.characters;
+	const renderedCharacters = difference.rendered.content.characters;
+	if (rawCharacters >= EMPTY_INITIAL_HTML_CHARACTERS || renderedCharacters < SUBSTANTIVE_RENDERED_CHARACTERS || renderedCharacters < rawCharacters * 3) return;
+	return {
+		rawCharacters,
+		rawWords: difference.raw.content.wordCount,
+		renderedCharacters,
+		renderedWords: difference.rendered.content.wordCount,
+		changed: difference.changed,
+		thresholds: {
+			emptyInitialHtmlCharacters: EMPTY_INITIAL_HTML_CHARACTERS,
+			substantiveRenderedCharacters: SUBSTANTIVE_RENDERED_CHARACTERS,
+			minimumGrowthRatio: 3
+		}
+	};
+}
 function issue(ruleId, page, detail, evidence) {
 	const rule = explainRule(ruleId);
 	if (!rule) throw new Error(`Missing rule guidance for ${ruleId}`);
@@ -10349,6 +10603,9 @@ function auditCrawlPages(pages, opts = {}) {
 		}));
 		if (page.auditScope === "status") continue;
 		if (redirected) continue;
+		if (page.softAuthenticationGate) issues.push(issue("soft_authentication_gate", page, "A password form and login-specific page signals were observed.", page.softAuthenticationGate));
+		const renderedContent = clientRenderedContentEvidence(page);
+		if (renderedContent) issues.push(issue("client_rendered_content", page, "The raw response was an empty or near-empty shell.", renderedContent));
 		if (isHtmlPage(page) && (page.sizeBytes ?? 0) > LARGE_HTML_BYTES) issues.push(issue("large_html", page, `${Math.round((page.sizeBytes ?? 0) / 1024)} KB`, {
 			sizeBytes: page.sizeBytes,
 			thresholdBytes: LARGE_HTML_BYTES
@@ -10953,7 +11210,7 @@ function createCrawlReport(input) {
 	const requests = sortRequests(sanitizeTenantValue(input.requests ?? []));
 	const requestEvidenceStatus = input.requestEvidenceStatus ?? (input.requests ? "available" : "unavailable");
 	if (requestEvidenceStatus === "unavailable" && requests.length > 0) throw new Error("Unavailable request evidence cannot include request observations.");
-	const safeIssues = sanitizeIssues(input.issues ?? [...auditCrawlRequests(requests), ...auditCrawlPages(safePagesWithLinks, { startUrl: config.url })]);
+	const safeIssues = sanitizeIssues([...input.issues ?? [...auditCrawlRequests(requests), ...auditCrawlPages(safePagesWithLinks, { startUrl: config.url })], ...input.additionalIssues ?? []]);
 	const pages = safePagesWithLinks;
 	return {
 		id: input.id ?? crawlRunId(),
@@ -10982,6 +11239,7 @@ function createCrawlReport(input) {
 		...input.ai ? { ai: sanitizeTenantValue(input.ai) } : {},
 		...input.sitemapDiscovery ? { sitemapDiscovery: sanitizeTenantValue(input.sitemapDiscovery) } : {},
 		...input.externalLinkVerification ? { externalLinkVerification: sanitizeTenantValue(input.externalLinkVerification) } : {},
+		...input.siteChecks ? { siteChecks: sanitizeTenantValue(input.siteChecks) } : {},
 		...input.agentDiscovery ? { agentDiscovery: sanitizeTenantValue(input.agentDiscovery) } : {},
 		warnings: sanitizeMessages(input.warnings).sort(compareText$13),
 		caveats: sanitizeMessages(input.caveats).sort(compareText$13)
@@ -11542,6 +11800,75 @@ function observationFromPage(requestedUrl, page) {
 	};
 }
 //#endregion
+//#region packages/core/dist/analyze/crawler/site-checks.js
+const PROBE_COUNT = 2;
+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());
+}
+function probeObservation(url, result) {
+	const request = result.request;
+	if (!request) return {
+		url,
+		error: result.warning ?? "No response evidence."
+	};
+	if (request.outcome === "response") return {
+		url,
+		status: request.status,
+		finalUrl: request.finalUrl,
+		redirected: request.finalUrl !== url,
+		accessBlocked: Boolean(request.accessBlock)
+	};
+	return {
+		url,
+		error: request.outcome === "failure" ? request.error : `Probe skipped: ${request.reason}`
+	};
+}
+async function collectCrawlSiteChecks(input) {
+	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));
+	}
+	const conclusive = probes.filter((probe) => probe.status !== void 0 && !probe.accessBlocked);
+	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 checks = { soft404: {
+		status,
+		probes,
+		probeLimit: PROBE_COUNT,
+		complete: probes.length === PROBE_COUNT
+	} };
+	if (status !== "warning") return {
+		checks,
+		issues: []
+	};
+	const rule = explainRule("soft_404");
+	if (!rule) throw new Error("Missing rule guidance for soft_404");
+	return {
+		checks,
+		issues: [{
+			ruleId: "soft_404",
+			title: rule.title,
+			category: rule.category,
+			severity: rule.defaultSeverity,
+			url: new URL("/", input.startUrl).toString(),
+			detail: `${successful.length} known-nonexistent paths returned a successful response or redirect.`,
+			evidence: checks.soft404
+		}]
+	};
+}
+//#endregion
 //#region packages/core/dist/analyze/crawler/site-crawl-ai-signals.js
 const MAX_AUXILIARY_RESPONSE_BYTES = 2 * 1024 * 1024;
 const AI_BOT_USER_AGENTS = [
@@ -12261,6 +12588,9 @@ async function crawlOne(url, opts = {}) {
 			mainContentHash: hashText(extracted.contentText),
 			textRatio: fetched.html.length ? Math.min(1, extracted.contentText.length / fetched.html.length) : void 0,
 			contentSample: truncate$1(extracted.contentText, 300),
+			contentSketch: crawlerEvidence.contentSketch,
+			softAuthenticationGate: crawlerEvidence.softAuthenticationGate,
+			tabbedContent: crawlerEvidence.tabbedContent,
 			lang: extracted.lang,
 			hasViewport: extracted.hasViewport,
 			isHttps: new URL(extracted.finalUrl).protocol === "https:",
@@ -13545,6 +13875,13 @@ async function crawlSite(input, dependencies) {
 			signal,
 			concurrency: Math.min(config.concurrency, 4)
 		}) : void 0;
+		const siteCheckResult = !healthStrategy && !cancelled && !stoppedForMemory ? await collectCrawlSiteChecks({
+			startUrl: config.url,
+			timeoutMs: config.timeoutMs,
+			fetchStatusPage: deps.fetchStatusPage,
+			respectRobots: config.respectRobots,
+			signal
+		}) : void 0;
 		for (const page of pages) {
 			if (!page.geo || !llmsTxt) continue;
 			page.geo = {
@@ -13570,6 +13907,10 @@ async function crawlSite(input, dependencies) {
 			} } : {},
 			...sitemapDiscovery ? { sitemapDiscovery } : {},
 			...externalLinkVerification ? { externalLinkVerification } : {},
+			...siteCheckResult ? {
+				siteChecks: siteCheckResult.checks,
+				additionalIssues: siteCheckResult.issues
+			} : {},
 			...agentDiscovery ? { agentDiscovery } : {},
 			status: reportStatus,
 			warnings,
@@ -14450,6 +14791,8 @@ const agentRepresentationResponseSchema = z.object({
 	status: z.number().int().optional(),
 	contentType: z.string().optional(),
 	bytes: z.number().int().nonnegative().optional(),
+	characters: z.number().int().nonnegative().optional(),
+	estimatedTokens: z.number().int().nonnegative().optional(),
 	sha256: z.string().optional(),
 	canonicalUrl: z.string().url().optional(),
 	alternateUrl: z.string().url().optional(),
@@ -14507,7 +14850,15 @@ const agentDiscoverySchema = z.object({
 				sourceWordCount: z.number().int().nonnegative(),
 				wordRetentionRatio: z.number().nonnegative().nullable(),
 				introductoryCopyRetained: z.boolean().nullable(),
-				navigationOnly: z.boolean()
+				navigationOnly: z.boolean(),
+				contentSketchCoverage: z.number().min(0).max(1).nullable().optional(),
+				tabbedContent: z.object({
+					detectedPanels: z.number().int().nonnegative(),
+					evaluatedPanels: z.number().int().nonnegative(),
+					retainedPanels: z.number().int().nonnegative(),
+					missingPanels: z.number().int().nonnegative(),
+					complete: z.boolean().nullable()
+				}).optional()
 			}).optional()
 		}))
 	}),
@@ -14526,6 +14877,11 @@ const agentDiscoverySchema = z.object({
 		missingHtmlRoutes: z.array(z.string()),
 		missingMarkdownRoutes: z.array(z.string()),
 		orphanMarkdownRoutes: z.array(z.string()),
+		comparisonStatus: z.enum([
+			"complete",
+			"partial",
+			"not-applicable"
+		]).optional(),
 		error: z.string().optional()
 	}),
 	agentSkills: z.object({
@@ -14631,6 +14987,25 @@ const agentDiscoverySchema = z.object({
 	warnings: z.array(z.string())
 });
 //#endregion
+//#region packages/core/dist/analyze/crawler/site-checks-schema.js
+const crawlSiteChecksSchema = z.object({ soft404: z.object({
+	status: z.enum([
+		"pass",
+		"warning",
+		"unknown"
+	]),
+	probes: z.array(z.object({
+		url: z.string().url(),
+		status: z.number().int().optional(),
+		finalUrl: z.string().url().optional(),
+		redirected: z.boolean().optional(),
+		accessBlocked: z.boolean().optional(),
+		error: z.string().optional()
+	})),
+	probeLimit: z.number().int().positive(),
+	complete: z.boolean()
+}) });
+//#endregion
 //#region packages/core/dist/analyze/crawler/schemas.js
 const crawlerRuleSeveritySchema = z.enum([
 	"low",
@@ -15060,6 +15435,34 @@ const crawlPageSnapshotSchema = z.object({
 	mainContentHash: z.string().optional(),
 	textRatio: z.number().min(0).max(1).optional(),
 	contentSample: z.string().optional(),
+	contentSketch: z.object({
+		version: z.literal(1),
+		wordCount: z.number().int().nonnegative(),
+		shingleSize: z.number().int().positive(),
+		sampledShingles: z.number().int().nonnegative(),
+		hashes: z.array(z.string())
+	}).optional(),
+	softAuthenticationGate: z.object({
+		kind: z.literal("login-form"),
+		indicators: z.array(z.string()),
+		formActionPath: z.string().optional()
+	}).optional(),
+	tabbedContent: z.object({
+		groups: z.number().int().positive(),
+		panels: z.number().int().positive(),
+		retainedPanels: z.number().int().nonnegative(),
+		truncated: z.boolean(),
+		panelSketches: z.array(z.object({
+			label: z.string().optional(),
+			sketch: z.object({
+				version: z.literal(1),
+				wordCount: z.number().int().nonnegative(),
+				shingleSize: z.number().int().positive(),
+				sampledShingles: z.number().int().nonnegative(),
+				hashes: z.array(z.string())
+			})
+		}))
+	}).optional(),
 	lang: z.string().optional(),
 	hasViewport: z.boolean().optional(),
 	isHttps: z.boolean().optional(),
@@ -15551,6 +15954,7 @@ const crawlReportBaseSchema = z.object({
 	ai: crawlAiSignalsSchema.optional(),
 	sitemapDiscovery: crawlSitemapDiscoverySchema.optional(),
 	externalLinkVerification: crawlExternalLinkVerificationSchema.optional(),
+	siteChecks: crawlSiteChecksSchema.optional(),
 	agentDiscovery: agentDiscoverySchema.optional(),
 	warnings: z.array(z.string()),
 	caveats: z.array(z.string())
@@ -15580,7 +15984,7 @@ function compareText$10(left, right) {
 	}
 	return leftPoints.length - rightPoints.length;
 }
-function boundedInteger$5(value, fallback, minimum, maximum) {
+function boundedInteger$6(value, fallback, minimum, maximum) {
 	if (value === void 0 || !Number.isFinite(value)) return fallback;
 	return Math.min(maximum, Math.max(minimum, Math.floor(value)));
 }
@@ -15657,8 +16061,8 @@ function initialSelection(sourceRows) {
 	};
 }
 function analyzeCtrUnderperformersFromRows(input) {
-	const minImpressions = boundedInteger$5(input.minImpressions, 200, 1, CTR_MAX_MIN_IMPRESSIONS);
-	const limit = boundedInteger$5(input.limit, 25, 1, 100);
+	const minImpressions = boundedInteger$6(input.minImpressions, 200, 1, CTR_MAX_MIN_IMPRESSIONS);
+	const limit = boundedInteger$6(input.limit, 25, 1, 100);
 	const selection = initialSelection(input.rows.length);
 	const benchmarkRows = aggregateCtrRows(input.rows, selection).filter((row) => {
 		const query = row.keys[0] ?? "";
@@ -16157,7 +16561,7 @@ function analyzeSegmentRows(input) {
 }
 //#endregion
 //#region packages/core/dist/analyze/segment-impact-input.js
-const DAY_MS$1 = 864e5;
+const DAY_MS$2 = 864e5;
 const MAX_WINDOW_DAYS = 240;
 function subtractDays$1(value, days) {
 	const date = /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`);
@@ -16165,7 +16569,7 @@ function subtractDays$1(value, days) {
 	return date.toISOString().slice(0, 10);
 }
 function segmentRangeDays(range) {
-	return Math.floor((Date.parse(`${range.endDate}T00:00:00.000Z`) - Date.parse(`${range.startDate}T00:00:00.000Z`)) / DAY_MS$1) + 1;
+	return Math.floor((Date.parse(`${range.endDate}T00:00:00.000Z`) - Date.parse(`${range.startDate}T00:00:00.000Z`)) / DAY_MS$2) + 1;
 }
 function segmentComparisonRange(after, compareDays) {
 	const endDate = subtractDays$1(after.startDate, 1);
@@ -16745,13 +17149,13 @@ const MINIMUM_PAGE_SHARE = .1;
 const MINIMUM_PAGE_IMPRESSIONS = 10;
 const MAXIMUM_DOMINANT_SHARE = .8;
 const MAX_SUPPRESSIONS = 100;
-function boundedInteger$4(value, fallback, minimum, maximum) {
+function boundedInteger$5(value, fallback, minimum, maximum) {
 	if (value === void 0 || !Number.isFinite(value)) return fallback;
 	return Math.min(maximum, Math.max(minimum, Math.floor(value)));
 }
 function analyzeCannibalRows(input) {
-	const minImpressions = boundedInteger$4(input.minImpressions, 50, 0, 1e9);
-	const limit = boundedInteger$4(input.limit, 25, 1, 100);
+	const minImpressions = boundedInteger$5(input.minImpressions, 50, 0, 1e9);
+	const limit = boundedInteger$5(input.limit, 25, 1, 100);
 	const selection = {
 		sourceRows: input.rows.length,
 		invalidRows: 0,
@@ -17531,7 +17935,7 @@ function groupQuickWins(items) {
 }
 //#endregion
 //#region packages/core/dist/analyze/site-diagnostics/quick-wins-analysis-primitives.js
-function boundedInteger$3(value, fallback, minimum, maximum) {
+function boundedInteger$4(value, fallback, minimum, maximum) {
 	if (value === void 0 || !Number.isFinite(value)) return fallback;
 	return Math.min(maximum, Math.max(minimum, Math.floor(value)));
 }
@@ -17652,12 +18056,12 @@ function roundedSum(values) {
 //#region packages/core/dist/analyze/site-diagnostics/quick-wins-analysis.js
 const DEFAULT_MIN_IMPRESSIONS$2 = 200;
 const MAX_MIN_IMPRESSIONS$2 = 1e9;
-const DEFAULT_LIMIT$2 = 25;
-const MAX_LIMIT$2 = 100;
+const DEFAULT_LIMIT$3 = 25;
+const MAX_LIMIT$3 = 100;
 const FALLBACK_SOURCE = "builtin_position_ctr_curve_v1";
 function analyzeQuickWinsFromRows(input) {
-	const minImpressions = boundedInteger$3(input.minImpressions, DEFAULT_MIN_IMPRESSIONS$2, 0, MAX_MIN_IMPRESSIONS$2);
-	const limit = boundedInteger$3(input.limit, DEFAULT_LIMIT$2, 1, MAX_LIMIT$2);
+	const minImpressions = boundedInteger$4(input.minImpressions, DEFAULT_MIN_IMPRESSIONS$2, 0, MAX_MIN_IMPRESSIONS$2);
+	const limit = boundedInteger$4(input.limit, DEFAULT_LIMIT$3, 1, MAX_LIMIT$3);
 	const selected = selectBenchmarkRows(input);
 	const benchmarkContext = createCtrBenchmarkContext(selected.rows, {
 		samplePopulation: "all_qualified_url_samples",
@@ -17998,7 +18402,7 @@ function compareText$5(left, right) {
 	}
 	return leftPoints.length - rightPoints.length;
 }
-function isHttpUrl(value) {
+function isHttpUrl$1(value) {
 	try {
 		const parsed = new URL(value);
 		return parsed.protocol === "http:" || parsed.protocol === "https:";
@@ -18007,7 +18411,7 @@ function isHttpUrl(value) {
 	}
 }
 function isValidStrikingDistanceRow(row, query, url) {
-	return Boolean(query) && isHttpUrl(url) && Number.isFinite(row.clicks) && Number.isFinite(row.impressions) && Number.isFinite(row.ctr) && Number.isFinite(row.position) && row.clicks >= 0 && row.impressions > 0 && row.clicks <= row.impressions && row.ctr >= 0 && row.ctr <= 1 && row.position > 0;
+	return Boolean(query) && isHttpUrl$1(url) && Number.isFinite(row.clicks) && Number.isFinite(row.impressions) && Number.isFinite(row.ctr) && Number.isFinite(row.position) && row.clicks >= 0 && row.impressions > 0 && row.clicks <= row.impressions && row.ctr >= 0 && row.ctr <= 1 && row.position > 0;
 }
 function isStrikingDistanceBrandRow(input) {
 	return shouldExcludeBrandQuery({
@@ -18097,8 +18501,8 @@ function groupStrikingDistanceItems(items) {
 //#region packages/core/dist/analyze/striking-distance-analysis.js
 const DEFAULT_MIN_IMPRESSIONS$1 = 100;
 const MAX_MIN_IMPRESSIONS$1 = 1e9;
-const DEFAULT_LIMIT$1 = 25;
-const MAX_LIMIT$1 = 100;
+const DEFAULT_LIMIT$2 = 25;
+const MAX_LIMIT$2 = 100;
 function integerInRange$1(value, fallback, minimum, maximum) {
 	if (value === void 0 || !Number.isFinite(value)) return fallback;
 	return Math.min(maximum, Math.max(minimum, Math.floor(value)));
@@ -18140,7 +18544,7 @@ function selectRows(input) {
 }
 function analyzeStrikingDistanceRows(input) {
 	const minImpressions = integerInRange$1(input.minImpressions, DEFAULT_MIN_IMPRESSIONS$1, 0, MAX_MIN_IMPRESSIONS$1);
-	const limit = integerInRange$1(input.limit, DEFAULT_LIMIT$1, 1, MAX_LIMIT$1);
+	const limit = integerInRange$1(input.limit, DEFAULT_LIMIT$2, 1, MAX_LIMIT$2);
 	const selected = selectRows({
 		...input,
 		minImpressions
@@ -18214,7 +18618,7 @@ const defaultDependencies$7 = {
 	verifyContent: verifyQueryContent,
 	now: () => /* @__PURE__ */ new Date()
 };
-function boundedInteger$2(value, fallback, minimum, maximum) {
+function boundedInteger$3(value, fallback, minimum, maximum) {
 	if (value === void 0 || !Number.isFinite(value)) return fallback;
 	return Math.min(maximum, Math.max(minimum, Math.floor(value)));
 }
@@ -18278,7 +18682,7 @@ async function strikingDistance(input, dependencies = defaultDependencies$7) {
 		brandTerms: input.brandTerms,
 		includeBrand: input.includeBrand
 	});
-	const verifyLimit = boundedInteger$2(input.verifyLimit, DEFAULT_VERIFY_LIMIT, 0, analysis.limit);
+	const verifyLimit = boundedInteger$3(input.verifyLimit, DEFAULT_VERIFY_LIMIT, 0, analysis.limit);
 	const verificationRequested = input.verifyContent === true || input.verifyContent !== false && input.verifyLimit !== void 0;
 	const attempted = verificationRequested ? Math.min(verifyLimit, analysis.items.length) : 0;
 	const items = await Promise.all(analysis.items.map(async (item, index) => {
@@ -18467,7 +18871,7 @@ function standardDeviation(values) {
 function toFixedNumber(value, digits = 3) {
 	return Number(value.toFixed(digits));
 }
-function percentChange(baseline, comparison) {
+function percentChange$1(baseline, comparison) {
 	if (!baseline) return comparison ? null : 0;
 	return (comparison - baseline) / baseline * 100;
 }
@@ -18653,7 +19057,7 @@ function analyzeTrafficAnomalyRows(input) {
 		const outsideFlatBaseline = zScore === null && comparisonMean !== baselineMean;
 		const significant = outsideFlatBaseline || zScore !== null && Math.abs(zScore) >= 2;
 		const direction = significant ? comparisonMean < baselineMean ? "drop" : "spike" : "normal";
-		const relativeChange = percentChange(baselineMean, comparisonMean);
+		const relativeChange = percentChange$1(baselineMean, comparisonMean);
 		return {
 			site: input.site,
 			metric,
@@ -19712,7 +20116,7 @@ function dateShift(date, days) {
 }
 //#endregion
 //#region packages/core/dist/analyze/experiments/measurement/window.js
-const DAY_MS = 864e5;
+const DAY_MS$1 = 864e5;
 function exactDate(value, label) {
 	const pattern = /^\d{4}-\d{2}-\d{2}$/;
 	const parsed = /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`);
@@ -19727,7 +20131,7 @@ function boundedDays(value, fallback, label) {
 function calendarDays(startDate, endDate) {
 	const start = (/* @__PURE__ */ new Date(`${startDate}T00:00:00.000Z`)).getTime();
 	const end = (/* @__PURE__ */ new Date(`${endDate}T00:00:00.000Z`)).getTime();
-	return Math.floor((end - start) / DAY_MS) + 1;
+	return Math.floor((end - start) / DAY_MS$1) + 1;
 }
 function subtractCalendarMonths(value, months) {
 	const source = /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`);
@@ -20273,7 +20677,7 @@ function internalLinksVerdict(input) {
 function uniqueInternalLinksWarnings(warnings) {
 	return [...new Map(warnings.map((warning) => [`${warning.stage}\u0000${warning.url}\u0000${warning.code}\u0000${warning.message}`, warning])).values()];
 }
-function errorMessage(error) {
+function errorMessage$1(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 function acceptedAlias(site, value) {
@@ -20323,7 +20727,7 @@ async function verifyInternalLinkTarget(input) {
 				stage: "target-fetch",
 				url: input.targetUrl,
 				code: "fetch-failed",
-				message: errorMessage(error)
+				message: errorMessage$1(error)
 			}]
 		};
 	}
@@ -20344,7 +20748,7 @@ async function verifyInternalLinkTarget(input) {
 				stage: "target-extract",
 				url: input.targetUrl,
 				code: "extract-failed",
-				message: errorMessage(error)
+				message: errorMessage$1(error)
 			}]
 		};
 	}
@@ -20407,7 +20811,7 @@ async function verifyInternalLinkCandidate(input) {
 				stage: "source-fetch",
 				url: input.candidate.sourceUrl,
 				code: "fetch-failed",
-				message: errorMessage(error)
+				message: errorMessage$1(error)
 			}]
 		};
 	}
@@ -20425,7 +20829,7 @@ async function verifyInternalLinkCandidate(input) {
 				stage: "source-fetch",
 				url: input.candidate.sourceUrl,
 				code: "fetch-failed",
-				message: errorMessage(error)
+				message: errorMessage$1(error)
 			}]
 		};
 	}
@@ -20439,7 +20843,7 @@ async function verifyInternalLinkCandidate(input) {
 				stage: "source-extract",
 				url: input.candidate.sourceUrl,
 				code: "extract-failed",
-				message: errorMessage(error)
+				message: errorMessage$1(error)
 			}]
 		};
 	}
@@ -21247,7 +21651,7 @@ function compareText$3(left, right) {
 	}
 	return leftPoints.length - rightPoints.length;
 }
-function boundedInteger$1(value, fallback, maximum) {
+function boundedInteger$2(value, fallback, maximum) {
 	if (value === void 0 || !Number.isFinite(value)) return fallback;
 	return Math.min(maximum, Math.max(1, Math.trunc(value)));
 }
@@ -21440,10 +21844,10 @@ function caveats(input) {
 	return items;
 }
 function analyzeIndexCoverageSignals(input) {
-	const itemLimit = boundedInteger$1(input.limits?.itemsPerSection, DEFAULT_ITEMS_PER_SECTION, MAX_ITEMS_PER_SECTION);
-	const clusterLimit = boundedInteger$1(input.limits?.templateClusters, DEFAULT_TEMPLATE_LIMIT, MAX_TEMPLATE_LIMIT);
-	const clusterSamples = boundedInteger$1(input.limits?.templateSamples, DEFAULT_TEMPLATE_SAMPLES, MAX_TEMPLATE_SAMPLES);
-	const minUrls = boundedInteger$1(input.templateThresholds?.minUrls, DEFAULT_TEMPLATE_MIN_URLS, Number.MAX_SAFE_INTEGER);
+	const itemLimit = boundedInteger$2(input.limits?.itemsPerSection, DEFAULT_ITEMS_PER_SECTION, MAX_ITEMS_PER_SECTION);
+	const clusterLimit = boundedInteger$2(input.limits?.templateClusters, DEFAULT_TEMPLATE_LIMIT, MAX_TEMPLATE_LIMIT);
+	const clusterSamples = boundedInteger$2(input.limits?.templateSamples, DEFAULT_TEMPLATE_SAMPLES, MAX_TEMPLATE_SAMPLES);
+	const minUrls = boundedInteger$2(input.templateThresholds?.minUrls, DEFAULT_TEMPLATE_MIN_URLS, Number.MAX_SAFE_INTEGER);
 	const requestedMinShare = input.templateThresholds?.minShare;
 	const minShare = Number.isFinite(requestedMinShare) ? Math.min(1, Math.max(0, requestedMinShare ?? DEFAULT_TEMPLATE_MIN_SHARE)) : DEFAULT_TEMPLATE_MIN_SHARE;
 	const crawl = crawlInput(input.crawl);
@@ -25130,16 +25534,16 @@ function benchmarkDetails(benchmark) {
 		positiveUrlSamples: benchmark.positiveUrlSamples
 	};
 }
-function boundedInteger(input) {
+function boundedInteger$1(input) {
 	const value = Number.isFinite(input.value) ? input.value ?? 0 : input.fallback;
 	return Math.min(input.maximum ?? Number.POSITIVE_INFINITY, Math.max(1, Math.floor(value)));
 }
 function analyzeQueryClustersFromRows(input) {
-	const minImpressions = boundedInteger({
+	const minImpressions = boundedInteger$1({
 		value: input.minImpressions,
 		fallback: 25
 	});
-	const limit = boundedInteger({
+	const limit = boundedInteger$1({
 		value: input.limit,
 		fallback: 25,
 		maximum: 100
@@ -25781,8 +26185,8 @@ function reportPresentation(report) {
 //#region packages/core/dist/analyze/second-page-analysis.js
 const DEFAULT_MIN_IMPRESSIONS = 50;
 const MAX_MIN_IMPRESSIONS = 1e9;
-const DEFAULT_LIMIT = 10;
-const MAX_LIMIT = 100;
+const DEFAULT_LIMIT$1 = 10;
+const MAX_LIMIT$1 = 100;
 function integerInRange(value, fallback, minimum, maximum) {
 	if (value === void 0 || !Number.isFinite(value)) return fallback;
 	return Math.min(maximum, Math.max(minimum, Math.floor(value)));
@@ -25869,7 +26273,7 @@ function compareItems(left, right) {
 }
 function analyzeSecondPageRows(input) {
 	const minImpressions = integerInRange(input.minImpressions, DEFAULT_MIN_IMPRESSIONS, 0, MAX_MIN_IMPRESSIONS);
-	const limit = integerInRange(input.limit, DEFAULT_LIMIT, 1, MAX_LIMIT);
+	const limit = integerInRange(input.limit, DEFAULT_LIMIT$1, 1, MAX_LIMIT$1);
 	const selection = {
 		sourceRows: input.rows.length,
 		invalidRows: 0,
@@ -27267,28 +27671,884 @@ async function updatePostmortemWorkflow(input, dependencies = {}) {
 	});
 }
 //#endregion
-//#region packages/core/dist/doctor.js
-const REQUIRED_SCOPES = ["https://www.googleapis.com/auth/webmasters.readonly", "https://www.googleapis.com/auth/analytics.readonly"];
-async function runDoctor(dependencies = {}) {
-	const paths = getSeoCliPaths();
-	const config = readConfig();
-	const authMode = getAuthModeStatus();
-	const serviceAccount = getServiceAccountStatus();
-	const tokens = await readTokens();
-	const oauthClient = readOauthClient();
-	const tokenClientConfigured = tokens ? Boolean(getClientConfig(tokens.client_source)) : void 0;
-	const checks = [];
-	try {
-		const database = (dependencies.checkDatabase ?? checkDatabaseReadiness)();
-		checks.push({
-			id: "local-database",
-			label: "Local database",
-			status: "pass",
-			detail: database.dbPath
-		});
-	} catch (error) {
-		checks.push({
-			id: "local-database",
+//#region packages/core/dist/bing/analysis.js
+const DAY_MS = 864e5;
+const DEFAULT_COMPARISON_DAYS = 28;
+const WEEKLY_PERIODS = 4;
+const OPPORTUNITY_MIN_IMPRESSIONS = 20;
+const OPPORTUNITY_MIN_POSITION = 4;
+const OPPORTUNITY_MAX_POSITION = 20;
+const RESULT_LIMIT = 10;
+function dateOffset(date, days) {
+	return new Date(Date.parse(`${date}T00:00:00Z`) + days * DAY_MS).toISOString().slice(0, 10);
+}
+function percentChange(previous, current) {
+	if (previous === 0) return null;
+	return round((current - previous) / previous * 100);
+}
+function round(value, digits = 3) {
+	const factor = 10 ** digits;
+	return Math.round(value * factor) / factor;
+}
+function trafficPeriod(byDate, startDate, endDate, expectedDays) {
+	let clicks = 0;
+	let impressions = 0;
+	let observedDays = 0;
+	for (const [date, row] of byDate) {
+		if (date < startDate || date > endDate) continue;
+		observedDays += 1;
+		clicks += row.clicks;
+		impressions += row.impressions;
+	}
+	return {
+		startDate,
+		endDate,
+		expectedDays,
+		observedDays,
+		missingDays: Math.max(0, expectedDays - observedDays),
+		clicks,
+		impressions,
+		ctr: impressions ? round(clicks / impressions * 100) : null
+	};
+}
+function analyzeBingTraffic(rows, comparisonDays = DEFAULT_COMPARISON_DAYS) {
+	if (!rows.length) return void 0;
+	const byDate = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const existing = byDate.get(row.date) ?? {
+			clicks: 0,
+			impressions: 0
+		};
+		existing.clicks += row.clicks;
+		existing.impressions += row.impressions;
+		byDate.set(row.date, existing);
+	}
+	const latestDate = [...byDate.keys()].sort().at(-1);
+	if (!latestDate) return void 0;
+	const currentStart = dateOffset(latestDate, -(comparisonDays - 1));
+	const previousEnd = dateOffset(currentStart, -1);
+	const previousStart = dateOffset(previousEnd, -(comparisonDays - 1));
+	const current = trafficPeriod(byDate, currentStart, latestDate, comparisonDays);
+	const previous = trafficPeriod(byDate, previousStart, previousEnd, comparisonDays);
+	return {
+		comparisonDays,
+		current,
+		previous,
+		changes: {
+			clicks: current.clicks - previous.clicks,
+			clicksPercent: percentChange(previous.clicks, current.clicks),
+			impressions: current.impressions - previous.impressions,
+			impressionsPercent: percentChange(previous.impressions, current.impressions),
+			ctrPercentagePoints: current.ctr === null || previous.ctr === null ? null : round(current.ctr - previous.ctr)
+		}
+	};
+}
+const CRAWL_FIELDS = [
+	"crawledPages",
+	"inIndex",
+	"inLinks",
+	"crawlErrors",
+	"code4xx",
+	"code5xx",
+	"blockedByRobotsTxt",
+	"connectionTimeout",
+	"dnsFailures",
+	"containsMalware"
+];
+function analyzeBingCrawl(rows, comparisonDays = DEFAULT_COMPARISON_DAYS) {
+	const ordered = [...rows].sort((a, b) => a.date.localeCompare(b.date, "en"));
+	const current = ordered.at(-1);
+	if (!current) return void 0;
+	const targetDate = dateOffset(current.date, -comparisonDays);
+	const previous = ordered.filter((row) => row.date <= targetDate).at(-1);
+	const changes = {};
+	if (!previous) return {
+		comparisonDays,
+		targetDate,
+		current,
+		previous: void 0,
+		changes
+	};
+	for (const field of CRAWL_FIELDS) {
+		const currentValue = current[field];
+		const previousValue = previous[field];
+		if (typeof currentValue !== "number" || typeof previousValue !== "number") continue;
+		changes[field] = {
+			previous: previousValue,
+			current: currentValue,
+			absolute: currentValue - previousValue,
+			percent: percentChange(previousValue, currentValue)
+		};
+	}
+	return {
+		comparisonDays,
+		targetDate,
+		current,
+		previous,
+		changes
+	};
+}
+function aggregateDimensions(rows, dates) {
+	const values = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		if (!dates.has(row.date)) continue;
+		const item = values.get(row.value) ?? {
+			clicks: 0,
+			impressions: 0,
+			clickPositionTotal: 0,
+			clickPositionWeight: 0,
+			impressionPositionTotal: 0,
+			impressionPositionWeight: 0,
+			observedDates: /* @__PURE__ */ new Set()
+		};
+		item.clicks += row.clicks;
+		item.impressions += row.impressions;
+		item.observedDates.add(row.date);
+		if (row.avgClickPosition !== void 0 && row.clicks > 0) {
+			const weight = row.clicks;
+			item.clickPositionTotal += row.avgClickPosition * weight;
+			item.clickPositionWeight += weight;
+		}
+		if (row.avgImpressionPosition !== void 0 && row.impressions > 0) {
+			const weight = row.impressions;
+			item.impressionPositionTotal += row.avgImpressionPosition * weight;
+			item.impressionPositionWeight += weight;
+		}
+		values.set(row.value, item);
+	}
+	return new Map([...values].map(([value, item]) => [value, {
+		value,
+		observedWeeks: item.observedDates.size,
+		clicks: item.clicks,
+		impressions: item.impressions,
+		avgClickPosition: item.clickPositionWeight ? round(item.clickPositionTotal / item.clickPositionWeight) : null,
+		avgImpressionPosition: item.impressionPositionWeight ? round(item.impressionPositionTotal / item.impressionPositionWeight) : null
+	}]));
+}
+function compareValue(a, b) {
+	return a.value.localeCompare(b.value, "en");
+}
+function analyzeBingDimensions(rows, kind) {
+	const dates = [...new Set(rows.map((row) => row.date))].sort().reverse();
+	const currentDates = dates.slice(0, WEEKLY_PERIODS);
+	const previousDates = dates.slice(WEEKLY_PERIODS, WEEKLY_PERIODS * 2);
+	const current = aggregateDimensions(rows, new Set(currentDates));
+	const previous = aggregateDimensions(rows, new Set(previousDates));
+	const matchedValues = [...current.keys()].filter((value) => previous.has(value));
+	const comparableValues = currentDates.length === WEEKLY_PERIODS && previousDates.length === WEEKLY_PERIODS ? matchedValues.filter((value) => {
+		const currentValue = current.get(value);
+		const previousValue = previous.get(value);
+		return currentValue?.observedWeeks === WEEKLY_PERIODS && previousValue?.observedWeeks === WEEKLY_PERIODS;
+	}) : [];
+	const movements = comparableValues.map((value) => {
+		const currentValue = current.get(value);
+		const previousValue = previous.get(value);
+		return {
+			value,
+			current: currentValue,
+			previous: previousValue,
+			changes: {
+				clicks: currentValue.clicks - previousValue.clicks,
+				clicksPercent: percentChange(previousValue.clicks, currentValue.clicks),
+				impressions: currentValue.impressions - previousValue.impressions,
+				impressionsPercent: percentChange(previousValue.impressions, currentValue.impressions)
+			}
+		};
+	}).sort((a, b) => Math.abs(b.changes.clicks) - Math.abs(a.changes.clicks) || Math.abs(b.changes.impressions) - Math.abs(a.changes.impressions) || compareValue(a, b)).slice(0, RESULT_LIMIT);
+	const opportunities = [...current.values()].filter((row) => row.impressions >= OPPORTUNITY_MIN_IMPRESSIONS && row.avgImpressionPosition !== null && row.avgImpressionPosition >= OPPORTUNITY_MIN_POSITION && row.avgImpressionPosition <= OPPORTUNITY_MAX_POSITION).sort((a, b) => b.impressions - a.impressions || b.clicks - a.clicks || compareValue(a, b)).slice(0, RESULT_LIMIT);
+	return {
+		kind,
+		sourceSemantics: "Bing weekly top-list evidence. Missing dimensions are unknown, not zero. Movements require observation in every week of both periods.",
+		periods: {
+			weeksPerPeriod: WEEKLY_PERIODS,
+			currentDates,
+			previousDates
+		},
+		coverage: {
+			sourceRows: rows.length,
+			currentDimensions: current.size,
+			previousDimensions: previous.size,
+			matchedDimensions: matchedValues.length,
+			comparableDimensions: comparableValues.length,
+			incompleteMatchedDimensions: matchedValues.length - comparableValues.length,
+			currentOnlyDimensions: [...current.keys()].filter((value) => !previous.has(value)).length,
+			previousOnlyDimensions: [...previous.keys()].filter((value) => !current.has(value)).length
+		},
+		thresholds: {
+			heuristic: true,
+			opportunityMinImpressions: OPPORTUNITY_MIN_IMPRESSIONS,
+			opportunityPositionRange: [OPPORTUNITY_MIN_POSITION, OPPORTUNITY_MAX_POSITION],
+			resultLimit: RESULT_LIMIT
+		},
+		movements,
+		opportunities
+	};
+}
+//#endregion
+//#region packages/core/dist/bing/client.js
+const DEFAULT_BASE_URL = "https://ssl.bing.com/webmaster/api.svc/json";
+const MAX_RESPONSE_BYTES$1 = 2e6;
+const MAX_STAT_ROWS = 400;
+const MAX_DIMENSION_ROWS = 8e3;
+const MAX_LINK_ROWS = 200;
+function bingDate(value) {
+	if (typeof value !== "string") return void 0;
+	const legacy = /^\/Date\((-?\d+)(?:[+-]\d{4})?\)\/$/.exec(value);
+	const date = legacy ? new Date(Number(legacy[1])) : new Date(value);
+	return Number.isNaN(date.getTime()) ? void 0 : date.toISOString().slice(0, 10);
+}
+function nonnegativeNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function positionNumber(value) {
+	if (value === void 0 || value === null || value === -1) return { valid: true };
+	const number = nonnegativeNumber(value);
+	return number === void 0 ? { valid: false } : {
+		valid: true,
+		value: number
+	};
+}
+function isHttpUrl(value) {
+	if (typeof value !== "string" || value.length > 2e3) return false;
+	try {
+		const url = new URL(value);
+		return url.protocol === "http:" || url.protocol === "https:";
+	} catch {
+		return false;
+	}
+}
+function boundedRows(rows, invalidRows, limit = MAX_STAT_ROWS) {
+	const capped = rows.length > limit;
+	return {
+		rows: capped ? rows.slice(-limit) : rows,
+		invalidRows,
+		capped,
+		returnedRows: rows.length
+	};
+}
+function dimensionValue(value, kind) {
+	if (typeof value !== "string") return void 0;
+	const normalized = value.trim();
+	if (!normalized || normalized.length > 2e3) return void 0;
+	if (kind === "page" && !isHttpUrl(normalized)) return void 0;
+	return normalized;
+}
+function errorMessage(body) {
+	try {
+		const parsed = JSON.parse(body);
+		return typeof parsed.Message === "string" ? parsed.Message : void 0;
+	} catch {
+		return;
+	}
+}
+var BingWebmasterClient = class {
+	credentials;
+	authentication;
+	baseUrl;
+	fetchImpl;
+	timeoutMs;
+	constructor(credentials, options = {}) {
+		this.credentials = credentials;
+		if (!(credentials.apiKey?.trim() || credentials.accessToken?.trim())) throw new SeoError("AUTH_REQUIRED", "Bing Webmaster credentials are empty.");
+		this.authentication = credentials.apiKey ? "api-key" : "oauth";
+		this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+		this.fetchImpl = options.fetchImpl ?? publicHttpFetch;
+		this.timeoutMs = options.timeoutMs ?? 3e4;
+	}
+	async request(method, params = {}) {
+		const url = new URL(`${this.baseUrl}/${method}`);
+		for (const [key, value] of Object.entries(params)) url.searchParams.set(key, value);
+		if (this.credentials.apiKey) url.searchParams.set("apikey", this.credentials.apiKey);
+		let response;
+		try {
+			response = await this.fetchImpl(url.toString(), {
+				headers: {
+					accept: "application/json",
+					...this.credentials.accessToken ? { authorization: `Bearer ${this.credentials.accessToken}` } : {}
+				},
+				signal: AbortSignal.timeout(this.timeoutMs)
+			});
+		} catch (error) {
+			if (error instanceof SeoError) throw error;
+			throw new SeoError("PROVIDER_UNAVAILABLE", `Bing Webmaster did not respond: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		const body = await readBoundedResponseText(response, MAX_RESPONSE_BYTES$1, "Bing Webmaster response");
+		if (!response.ok) {
+			const message = errorMessage(body);
+			if (response.status === 401 || /invalidapikey|unauthorized/i.test(message ?? "")) throw new SeoError("AUTH_REQUIRED", "Bing Webmaster rejected the saved credential. Run `seo providers bing connect` again.");
+			if (response.status === 403) throw new SeoError("ACCESS_DENIED", "Bing Webmaster denied access to this site. Check that it is verified for the connected account.");
+			if (response.status === 429) throw new SeoError("RATE_LIMITED", "Bing Webmaster rate limited this request. Try again later.");
+			throw new SeoError("PROVIDER_UNAVAILABLE", `Bing Webmaster request failed with HTTP ${response.status}${message ? ` (${message})` : ""}.`);
+		}
+		try {
+			return JSON.parse(body).d;
+		} catch {
+			throw new SeoError("PROVIDER_UNAVAILABLE", "Bing Webmaster returned invalid JSON.");
+		}
+	}
+	async listSites() {
+		const data = await this.request("GetUserSites");
+		if (!Array.isArray(data)) throw new SeoError("PROVIDER_UNAVAILABLE", "Bing Webmaster returned an invalid site list.");
+		const sites = [];
+		let invalidRows = 0;
+		for (const item of data) {
+			if (!item || typeof item !== "object") {
+				invalidRows += 1;
+				continue;
+			}
+			const row = item;
+			if (typeof row.Url !== "string" || typeof row.IsVerified !== "boolean") {
+				invalidRows += 1;
+				continue;
+			}
+			sites.push({
+				url: row.Url,
+				isVerified: row.IsVerified
+			});
+		}
+		sites.sort((a, b) => a.url.localeCompare(b.url, "en"));
+		return {
+			sites,
+			invalidRows
+		};
+	}
+	async getTraffic(siteUrl) {
+		const data = await this.request("GetRankAndTrafficStats", { siteUrl });
+		if (!Array.isArray(data)) throw new SeoError("PROVIDER_UNAVAILABLE", "Bing Webmaster returned invalid traffic statistics.");
+		const rows = [];
+		let invalidRows = 0;
+		for (const item of data) {
+			if (!item || typeof item !== "object") {
+				invalidRows += 1;
+				continue;
+			}
+			const row = item;
+			const date = bingDate(row.Date);
+			const clicks = nonnegativeNumber(row.Clicks);
+			const impressions = nonnegativeNumber(row.Impressions);
+			if (!date || clicks === void 0 || impressions === void 0) {
+				invalidRows += 1;
+				continue;
+			}
+			rows.push({
+				date,
+				clicks,
+				impressions
+			});
+		}
+		rows.sort((a, b) => a.date.localeCompare(b.date, "en") || a.clicks - b.clicks || a.impressions - b.impressions);
+		return boundedRows(rows, invalidRows);
+	}
+	async getCrawlStats(siteUrl) {
+		const data = await this.request("GetCrawlStats", { siteUrl });
+		if (!Array.isArray(data)) throw new SeoError("PROVIDER_UNAVAILABLE", "Bing Webmaster returned invalid crawl statistics.");
+		const fieldMap = {
+			AllOtherCodes: "allOtherCodes",
+			BlockedByRobotsTxt: "blockedByRobotsTxt",
+			Code2xx: "code2xx",
+			Code301: "code301",
+			Code302: "code302",
+			Code4xx: "code4xx",
+			Code5xx: "code5xx",
+			ConnectionTimeout: "connectionTimeout",
+			ContainsMalware: "containsMalware",
+			CrawledPages: "crawledPages",
+			CrawlErrors: "crawlErrors",
+			DnsFailures: "dnsFailures",
+			InIndex: "inIndex",
+			InLinks: "inLinks"
+		};
+		const rows = [];
+		let invalidRows = 0;
+		for (const item of data) {
+			if (!item || typeof item !== "object") {
+				invalidRows += 1;
+				continue;
+			}
+			const source = item;
+			const date = bingDate(source.Date);
+			if (!date) {
+				invalidRows += 1;
+				continue;
+			}
+			const row = { date };
+			let invalid = false;
+			for (const [providerField, field] of Object.entries(fieldMap)) {
+				const value = source[providerField];
+				if (value === void 0 || value === null) continue;
+				const number = nonnegativeNumber(value);
+				if (number === void 0) {
+					invalid = true;
+					break;
+				}
+				row[field] = number;
+			}
+			if (invalid) {
+				invalidRows += 1;
+				continue;
+			}
+			rows.push(row);
+		}
+		rows.sort((a, b) => a.date.localeCompare(b.date, "en"));
+		return boundedRows(rows, invalidRows);
+	}
+	async getQueryStats(siteUrl) {
+		return this.getDimensionStats("GetQueryStats", siteUrl, "query");
+	}
+	async getPageStats(siteUrl) {
+		return this.getDimensionStats("GetPageStats", siteUrl, "page");
+	}
+	async getDimensionStats(method, siteUrl, kind) {
+		const data = await this.request(method, { siteUrl });
+		if (!Array.isArray(data)) throw new SeoError("PROVIDER_UNAVAILABLE", `Bing Webmaster returned invalid ${kind} statistics.`);
+		const rows = [];
+		let invalidRows = 0;
+		for (const item of data) {
+			if (!item || typeof item !== "object") {
+				invalidRows += 1;
+				continue;
+			}
+			const source = item;
+			const date = bingDate(source.Date);
+			const value = dimensionValue(source.Query, kind);
+			const clicks = nonnegativeNumber(source.Clicks);
+			const impressions = nonnegativeNumber(source.Impressions);
+			const clickPosition = positionNumber(source.AvgClickPosition);
+			const impressionPosition = positionNumber(source.AvgImpressionPosition);
+			if (!date || !value || clicks === void 0 || impressions === void 0 || !clickPosition.valid || !impressionPosition.valid) {
+				invalidRows += 1;
+				continue;
+			}
+			rows.push({
+				date,
+				value,
+				clicks,
+				impressions,
+				avgClickPosition: clickPosition.value,
+				avgImpressionPosition: impressionPosition.value
+			});
+		}
+		rows.sort((a, b) => a.date.localeCompare(b.date, "en") || a.value.localeCompare(b.value, "en"));
+		return boundedRows(rows, invalidRows, MAX_DIMENSION_ROWS);
+	}
+	async getLinkCounts(siteUrl, page) {
+		const data = await this.request("GetLinkCounts", {
+			siteUrl,
+			page: String(page)
+		});
+		if (!data || typeof data !== "object") throw new SeoError("PROVIDER_UNAVAILABLE", "Bing Webmaster returned invalid link counts.");
+		const response = data;
+		if (!Array.isArray(response.Links)) throw new SeoError("PROVIDER_UNAVAILABLE", "Bing Webmaster returned invalid link counts.");
+		const rows = [];
+		let invalidRows = 0;
+		for (const item of response.Links) {
+			if (!item || typeof item !== "object") {
+				invalidRows += 1;
+				continue;
+			}
+			const row = item;
+			const count = nonnegativeNumber(row.Count);
+			if (!isHttpUrl(row.Url) || count === void 0) {
+				invalidRows += 1;
+				continue;
+			}
+			rows.push({
+				url: row.Url,
+				count
+			});
+		}
+		rows.sort((a, b) => b.count - a.count || a.url.localeCompare(b.url, "en"));
+		return linkPage(rows, response.TotalPages, invalidRows);
+	}
+	async getUrlLinks(siteUrl, link, page) {
+		const data = await this.request("GetUrlLinks", {
+			siteUrl,
+			link,
+			page: String(page)
+		});
+		if (!data || typeof data !== "object") throw new SeoError("PROVIDER_UNAVAILABLE", "Bing Webmaster returned invalid referring links.");
+		const response = data;
+		if (!Array.isArray(response.Details)) throw new SeoError("PROVIDER_UNAVAILABLE", "Bing Webmaster returned invalid referring links.");
+		const rows = [];
+		let invalidRows = 0;
+		for (const item of response.Details) {
+			if (!item || typeof item !== "object") {
+				invalidRows += 1;
+				continue;
+			}
+			const row = item;
+			if (!isHttpUrl(row.Url)) {
+				invalidRows += 1;
+				continue;
+			}
+			rows.push({
+				url: row.Url,
+				anchorText: typeof row.AnchorText === "string" && row.AnchorText.trim() ? row.AnchorText.trim() : void 0
+			});
+		}
+		rows.sort((a, b) => a.url.localeCompare(b.url, "en") || (a.anchorText ?? "").localeCompare(b.anchorText ?? "", "en"));
+		return linkPage(rows, response.TotalPages, invalidRows);
+	}
+};
+function linkPage(rows, totalPagesValue, invalidRows) {
+	const totalPages = nonnegativeNumber(totalPagesValue);
+	if (totalPages === void 0 || !Number.isInteger(totalPages)) throw new SeoError("PROVIDER_UNAVAILABLE", "Bing Webmaster returned invalid link pagination.");
+	const capped = rows.length > MAX_LINK_ROWS;
+	return {
+		rows: capped ? rows.slice(0, MAX_LINK_ROWS) : rows,
+		totalPages,
+		invalidRows,
+		capped,
+		returnedRows: rows.length
+	};
+}
+//#endregion
+//#region packages/core/dist/storage/provider-secrets.js
+const KEYRING_SERVICE = "seo";
+function account(name) {
+	return `provider:${name}`;
+}
+function readFile$1() {
+	return readJsonFile(getSeoCliPaths().providerSecretsFile) ?? {
+		version: 1,
+		secrets: {}
+	};
+}
+async function readProviderSecret(input) {
+	const environment = input.env ?? process.env;
+	const environmentValue = input.envVar ? environment[input.envVar]?.trim() : void 0;
+	if (environmentValue) return {
+		value: environmentValue,
+		source: "environment"
+	};
+	if (readConfig().security.useKeychain) try {
+		const value = await getKeyringPassword(KEYRING_SERVICE, account(input.name));
+		if (value) return {
+			value,
+			source: "keychain"
+		};
+	} catch {}
+	const value = readFile$1().secrets[input.name];
+	return value ? {
+		value,
+		source: "file"
+	} : void 0;
+}
+//#endregion
+//#region packages/core/dist/bing/credentials.js
+const BING_API_KEY_SECRET = "bing-api-key";
+const BING_API_KEY_ENV = "SEO_BING_API_KEY";
+async function createBingWebmasterClient(input = {}) {
+	const secret = await readProviderSecret({
+		name: BING_API_KEY_SECRET,
+		envVar: BING_API_KEY_ENV,
+		env: input.env
+	});
+	if (!secret) throw new SeoError("AUTH_REQUIRED", "Bing Webmaster is not connected. Run `seo providers bing connect`, or set SEO_BING_API_KEY for this process.");
+	return {
+		client: new BingWebmasterClient({ apiKey: secret.value }),
+		credentialSource: secret.source
+	};
+}
+//#endregion
+//#region packages/core/dist/bing/overview.js
+const DAILY_OUTPUT_ROWS = 14;
+function message(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function range(rows) {
+	return rows.length ? {
+		startDate: rows[0]?.date ?? "",
+		endDate: rows.at(-1)?.date ?? ""
+	} : void 0;
+}
+function dailyOutput(data) {
+	const rows = data.rows.slice(-14);
+	return {
+		...data,
+		rows,
+		retainedRows: data.rows.length,
+		outputSelection: {
+			strategy: "most-recent",
+			availableRows: data.rows.length,
+			returnedRows: rows.length,
+			omittedRows: Math.max(0, data.rows.length - rows.length)
+		}
+	};
+}
+async function section(work, options) {
+	try {
+		const data = await work();
+		const reasons = [
+			...data.invalidRows ? [`${data.invalidRows} invalid provider rows were excluded.`] : [],
+			...data.capped ? [`The provider response exceeded the ${options.rowLimit}-row limit.`] : [],
+			...options.sourceWarning ? [options.sourceWarning] : []
+		];
+		return reasons.length ? {
+			status: "partial",
+			data,
+			warning: reasons.join(" ")
+		} : {
+			status: "complete",
+			data
+		};
+	} catch (error) {
+		if (error instanceof SeoError && (error.code === "AUTH_REQUIRED" || error.code === "ACCESS_DENIED")) throw error;
+		return {
+			status: "unavailable",
+			warning: message(error)
+		};
+	}
+}
+function changeFinding(input) {
+	return {
+		code: input.code,
+		severity: "warning",
+		title: input.title,
+		evidence: {
+			current: input.current,
+			previous: input.previous,
+			absoluteChange: input.absolute,
+			percentChange: input.percent,
+			currentDate: input.dates.current,
+			previousDate: input.dates.previous
+		},
+		interpretation: input.interpretation,
+		verification: input.verification
+	};
+}
+function buildFindings(input) {
+	const findings = [];
+	const traffic = input.traffic;
+	if (traffic && traffic.current.observedDays === traffic.current.expectedDays && traffic.previous.observedDays === traffic.previous.expectedDays && (traffic.changes.clicksPercent !== null && Math.abs(traffic.changes.clicksPercent) >= 10 || traffic.changes.impressionsPercent !== null && Math.abs(traffic.changes.impressionsPercent) >= 10)) {
+		const metric = traffic.changes.clicksPercent !== null && Math.abs(traffic.changes.clicksPercent) >= 10 ? "clicks" : "impressions";
+		const declined = traffic.changes[metric] < 0;
+		findings.push({
+			code: `bing_${metric}_${declined ? "declined" : "increased"}`,
+			severity: declined ? "warning" : "info",
+			title: `Bing ${metric} ${declined ? "declined" : "increased"} in the latest complete period`,
+			evidence: {
+				currentClicks: traffic.current.clicks,
+				previousClicks: traffic.previous.clicks,
+				clicksChange: traffic.changes.clicks,
+				clicksPercentChange: traffic.changes.clicksPercent,
+				currentImpressions: traffic.current.impressions,
+				previousImpressions: traffic.previous.impressions,
+				impressionsChange: traffic.changes.impressions,
+				impressionsPercentChange: traffic.changes.impressionsPercent,
+				ctrPercentagePointChange: traffic.changes.ctrPercentagePoints,
+				currentRange: {
+					startDate: traffic.current.startDate,
+					endDate: traffic.current.endDate
+				},
+				previousRange: {
+					startDate: traffic.previous.startDate,
+					endDate: traffic.previous.endDate
+				}
+			},
+			interpretation: "This is a Bing-observed traffic change. It does not establish the cause or describe Google traffic.",
+			verification: "Review the query and page evidence for the same dates, then compare current pages and crawl health before changing content."
+		});
+	}
+	const crawl = input.crawl;
+	if (crawl?.previous) {
+		const dates = {
+			current: crawl.current.date,
+			previous: crawl.previous.date
+		};
+		const errors = crawl.changes.crawlErrors;
+		if (errors && errors.absolute >= Math.max(10, Math.ceil(errors.previous * .5))) findings.push(changeFinding({
+			code: "bing_crawl_errors_increased",
+			title: "Bing crawl errors increased",
+			...errors,
+			dates,
+			interpretation: "Bing reported more crawl errors in its latest daily snapshot. The count may include URLs outside the current sitemap.",
+			verification: "Run the fast sitemap health check, inspect Bing crawl issue samples, then audit any affected URLs directly."
+		}));
+		const code4xx = crawl.changes.code4xx;
+		if (code4xx && code4xx.absolute >= Math.max(10, Math.ceil(code4xx.previous * .5))) findings.push(changeFinding({
+			code: "bing_4xx_increased",
+			title: "Bing-observed 4xx responses increased",
+			...code4xx,
+			dates,
+			interpretation: "Bing encountered more 4xx responses. Intentional removals and obsolete discovered URLs can contribute to this count.",
+			verification: "Inspect Bing crawl issue URLs and recover or redirect only URLs that should still exist or retain search value."
+		}));
+		const code5xx = crawl.changes.code5xx;
+		if (code5xx && code5xx.current > 0 && code5xx.absolute > 0) findings.push(changeFinding({
+			code: "bing_5xx_increased",
+			title: "Bing-observed server errors increased",
+			...code5xx,
+			dates,
+			interpretation: "Bing encountered more server errors in the latest snapshot. Even a small increase deserves a live check.",
+			verification: "Check current server logs and run targeted URL audits before treating the provider count as an active outage."
+		}));
+	}
+	for (const [kind, analysis] of [["query", input.queries], ["page", input.pages]]) {
+		if (!analysis?.opportunities.length) continue;
+		findings.push({
+			code: `bing_${kind}_opportunities`,
+			severity: "review",
+			title: `${analysis.opportunities.length} Bing ${kind} opportunities need review`,
+			evidence: {
+				retainedOpportunities: analysis.opportunities.length,
+				currentDimensions: analysis.coverage.currentDimensions,
+				matchedDimensions: analysis.coverage.matchedDimensions,
+				comparableDimensions: analysis.coverage.comparableDimensions,
+				thresholds: analysis.thresholds
+			},
+			interpretation: "These are high-impression top-list entries currently observed around positions 4 to 20. The threshold is a prioritization heuristic, not a search-engine rule.",
+			verification: kind === "query" ? "Check intent and the ranking page before changing copy or creating content." : "Audit the selected page and its matching queries before changing internal links, titles, or content."
+		});
+	}
+	return findings;
+}
+async function bingWebmasterOverview(input) {
+	if (!input.site.trim()) throw new SeoError("INVALID_INPUT", "Pass a Bing Webmaster site URL.");
+	const resolved = input.client ? {
+		client: input.client,
+		credentialSource: input.credentialSource ?? "environment"
+	} : await createBingWebmasterClient();
+	const observedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const topListWarning = "Bing returns weekly top-list rows, so dimensions missing from a period remain unknown.";
+	const [traffic, crawl, queries, pages] = await Promise.all([
+		section(() => resolved.client.getTraffic(input.site), { rowLimit: 400 }),
+		section(() => resolved.client.getCrawlStats(input.site), { rowLimit: 400 }),
+		section(() => resolved.client.getQueryStats(input.site), {
+			rowLimit: 8e3,
+			sourceWarning: topListWarning
+		}),
+		section(() => resolved.client.getPageStats(input.site), {
+			rowLimit: 8e3,
+			sourceWarning: topListWarning
+		})
+	]);
+	const statuses = [
+		traffic.status,
+		crawl.status,
+		queries.status,
+		pages.status
+	];
+	const dataStatus = statuses.every((status) => status === "complete") ? "complete" : statuses.every((status) => status === "unavailable") ? "unavailable" : "partial";
+	const trafficAnalysis = traffic.status === "unavailable" ? void 0 : analyzeBingTraffic(traffic.data.rows);
+	const crawlAnalysis = crawl.status === "unavailable" ? void 0 : analyzeBingCrawl(crawl.data.rows);
+	const queryAnalysis = queries.status === "unavailable" ? void 0 : analyzeBingDimensions(queries.data.rows, "query");
+	const pageAnalysis = pages.status === "unavailable" ? void 0 : analyzeBingDimensions(pages.data.rows, "page");
+	const findings = buildFindings({
+		traffic: trafficAnalysis,
+		crawl: crawlAnalysis,
+		queries: queryAnalysis,
+		pages: pageAnalysis
+	});
+	return {
+		schemaVersion: 2,
+		site: input.site,
+		generatedAt: observedAt,
+		dataStatus,
+		summary: {
+			findings: findings.length,
+			warnings: findings.filter((finding) => finding.severity === "warning").length,
+			reviewItems: findings.filter((finding) => finding.severity === "review").length
+		},
+		findings,
+		outputBudget: {
+			maxFindings: 6,
+			maxDailyRowsPerSection: DAILY_OUTPUT_ROWS,
+			maxDailyRowsTotal: DAILY_OUTPUT_ROWS * 2,
+			maxDimensionItemsPerList: 10,
+			maxDimensionItemsTotal: 40
+		},
+		provenance: {
+			provider: "bing-webmaster",
+			authentication: resolved.client.authentication,
+			credentialSource: resolved.credentialSource,
+			observedAt,
+			cached: false,
+			rowLimits: {
+				traffic: 400,
+				crawl: 400,
+				queries: 8e3,
+				pages: 8e3
+			},
+			methods: [
+				"GetRankAndTrafficStats",
+				"GetCrawlStats",
+				"GetQueryStats",
+				"GetPageStats"
+			]
+		},
+		traffic: traffic.status === "unavailable" ? traffic : {
+			...traffic,
+			data: {
+				...dailyOutput(traffic.data),
+				range: range(traffic.data.rows),
+				clicks: traffic.data.rows.reduce((total, row) => total + row.clicks, 0),
+				impressions: traffic.data.rows.reduce((total, row) => total + row.impressions, 0),
+				analysis: trafficAnalysis
+			}
+		},
+		crawl: crawl.status === "unavailable" ? crawl : {
+			...crawl,
+			data: {
+				...dailyOutput(crawl.data),
+				range: range(crawl.data.rows),
+				latest: crawl.data.rows.at(-1),
+				analysis: crawlAnalysis
+			}
+		},
+		queries: queries.status === "unavailable" ? queries : {
+			...queries,
+			data: {
+				returnedRows: queries.data.returnedRows,
+				retainedRows: queries.data.rows.length,
+				invalidRows: queries.data.invalidRows,
+				capped: queries.data.capped,
+				range: range(queries.data.rows),
+				analysis: queryAnalysis
+			}
+		},
+		pages: pages.status === "unavailable" ? pages : {
+			...pages,
+			data: {
+				returnedRows: pages.data.returnedRows,
+				retainedRows: pages.data.rows.length,
+				invalidRows: pages.data.invalidRows,
+				capped: pages.data.capped,
+				range: range(pages.data.rows),
+				analysis: pageAnalysis
+			}
+		},
+		caveats: [
+			"Bing reports its own observed search and crawl evidence. It is not a complete view of every search engine.",
+			"The inIndex field is provider-reported crawl statistics, not independent proof that a URL is indexed.",
+			"Query and page movements include only dimensions observed in every weekly top list in both periods. Missing entries are not treated as zero.",
+			"Opportunity thresholds prioritize review. They are heuristics, not search-engine requirements."
+		]
+	};
+}
+//#endregion
+//#region packages/core/dist/doctor.js
+const REQUIRED_SCOPES = ["https://www.googleapis.com/auth/webmasters.readonly", "https://www.googleapis.com/auth/analytics.readonly"];
+async function runDoctor(dependencies = {}) {
+	const paths = getSeoCliPaths();
+	const config = readConfig();
+	const authMode = getAuthModeStatus();
+	const serviceAccount = getServiceAccountStatus();
+	const tokens = await readTokens();
+	const oauthClient = readOauthClient();
+	const tokenClientConfigured = tokens ? Boolean(getClientConfig(tokens.client_source)) : void 0;
+	const checks = [];
+	try {
+		const database = (dependencies.checkDatabase ?? checkDatabaseReadiness)();
+		checks.push({
+			id: "local-database",
+			label: "Local database",
+			status: "pass",
+			detail: database.dbPath
+		});
+	} catch (error) {
+		checks.push({
+			id: "local-database",
 			label: "Local database",
 			status: "fail",
 			detail: error instanceof Error ? error.message : "The local database could not be opened.",
@@ -27343,9 +28603,504 @@ async function runDoctor(dependencies = {}) {
 		detail: config.analytics.google.defaultPropertyId ?? "No saved default. Human CLI commands will prompt; agents can pass --property."
 	});
 	return {
-		ok: checks.every((check) => check.status !== "fail"),
+		ok: checks.every((check) => check.status !== "fail"),
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		checks
+	};
+}
+//#endregion
+//#region packages/core/dist/links/normalize.js
+const FIELD_ALIASES = {
+	sourceUrl: [
+		"sourceurl",
+		"source",
+		"referringurl",
+		"referringpage",
+		"fromurl"
+	],
+	targetUrl: [
+		"targeturl",
+		"target",
+		"destinationurl",
+		"destination",
+		"tourl"
+	],
+	anchorText: ["anchortext", "anchor"],
+	firstSeenAt: ["firstseenat", "firstseen"],
+	lastSeenAt: ["lastseenat", "lastseen"],
+	nofollow: ["nofollow", "isnofollow"]
+};
+function key(value) {
+	return value.toLowerCase().replaceAll(/[^a-z0-9]/g, "");
+}
+function valueFor(row, field) {
+	const aliases = new Set(FIELD_ALIASES[field]);
+	for (const [name, value] of Object.entries(row)) if (aliases.has(key(name))) return value;
+}
+function httpUrl(value) {
+	if (typeof value !== "string" || !value.trim() || value.trim().length > 2e3) return;
+	try {
+		const url = new URL(value.trim());
+		return url.protocol === "http:" || url.protocol === "https:" ? url : void 0;
+	} catch {
+		return;
+	}
+}
+function optionalString(value) {
+	return typeof value === "string" && value.trim() ? value.trim().slice(0, 1e3) : void 0;
+}
+function optionalBoolean(value) {
+	if (typeof value === "boolean") return value;
+	if (typeof value !== "string") return void 0;
+	if (/^(true|yes|1)$/i.test(value.trim())) return true;
+	if (/^(false|no|0)$/i.test(value.trim())) return false;
+}
+function normalizeLinkEvidenceRow(raw) {
+	const source = httpUrl(valueFor(raw, "sourceUrl"));
+	const target = httpUrl(valueFor(raw, "targetUrl"));
+	if (!source || !target) return void 0;
+	return {
+		sourceUrl: source.toString(),
+		sourceDomain: source.hostname.toLowerCase(),
+		targetUrl: target.toString(),
+		anchorText: optionalString(valueFor(raw, "anchorText")),
+		firstSeenAt: optionalString(valueFor(raw, "firstSeenAt")),
+		lastSeenAt: optionalString(valueFor(raw, "lastSeenAt")),
+		nofollow: optionalBoolean(valueFor(raw, "nofollow"))
+	};
+}
+function linkEvidenceKey(row) {
+	return `${row.sourceUrl}\u0000${row.targetUrl}\u0000${row.anchorText ?? ""}`;
+}
+function compareLinkEvidence(a, b) {
+	return a.targetUrl.localeCompare(b.targetUrl, "en") || a.sourceUrl.localeCompare(b.sourceUrl, "en") || (a.anchorText ?? "").localeCompare(b.anchorText ?? "", "en");
+}
+//#endregion
+//#region packages/core/dist/links/bing.js
+const MAX_COUNT_PAGES = 5;
+const DEFAULT_TARGET_LIMIT = 20;
+const MAX_TARGET_LIMIT = 50;
+const DEFAULT_DETAIL_PAGES = 1;
+const MAX_DETAIL_PAGES = 3;
+const DEFAULT_ROW_LIMIT$2 = 500;
+const MAX_ROW_LIMIT$2 = 1e3;
+const MAX_CONCURRENCY = 3;
+function integer(value, fallback, max, name) {
+	const resolved = value ?? fallback;
+	if (!Number.isInteger(resolved) || resolved < 1 || resolved > max) throw new SeoError("INVALID_INPUT", `${name} must be between 1 and ${max}.`);
+	return resolved;
+}
+async function mapConcurrent(values, concurrency, work) {
+	const output = new Array(values.length);
+	let next = 0;
+	async function worker() {
+		while (next < values.length) {
+			const index = next;
+			next += 1;
+			const value = values[index];
+			if (value !== void 0) output[index] = await work(value);
+		}
+	}
+	await Promise.all(Array.from({ length: Math.min(concurrency, values.length) }, () => worker()));
+	return output;
+}
+async function targetDetails(input) {
+	const rows = [];
+	let requestedPages = 0;
+	let invalidRows = 0;
+	let returnedRows = 0;
+	let partial = false;
+	let totalPages = 0;
+	for (let page = 0; page < input.pages; page += 1) {
+		requestedPages += 1;
+		let response;
+		try {
+			response = await input.client.getUrlLinks(input.site, input.target.url, page);
+		} catch (error) {
+			if (error instanceof SeoError && (error.code === "AUTH_REQUIRED" || error.code === "ACCESS_DENIED")) throw error;
+			return {
+				rows,
+				requestedPages,
+				invalidRows,
+				returnedRows,
+				partial: true,
+				failed: true
+			};
+		}
+		invalidRows += response.invalidRows;
+		returnedRows += response.returnedRows;
+		rows.push(...response.rows);
+		totalPages = response.totalPages;
+		partial ||= response.capped;
+		if (page + 1 >= response.totalPages || response.rows.length === 0) break;
+	}
+	partial ||= requestedPages < totalPages;
+	return {
+		rows,
+		requestedPages,
+		invalidRows,
+		returnedRows,
+		partial,
+		failed: false
+	};
+}
+async function collectBingLinkEvidence(input) {
+	if (!input.site.trim()) throw new SeoError("INVALID_INPUT", "Pass a Bing Webmaster site URL.");
+	const targetLimit = integer(input.targetLimit, DEFAULT_TARGET_LIMIT, MAX_TARGET_LIMIT, "Bing link target limit");
+	const detailPages = integer(input.detailPagesPerTarget, DEFAULT_DETAIL_PAGES, MAX_DETAIL_PAGES, "Bing detail page limit");
+	const rowLimit = integer(input.rowLimit, DEFAULT_ROW_LIMIT$2, MAX_ROW_LIMIT$2, "Bing link row limit");
+	const client = input.client ?? (await createBingWebmasterClient()).client;
+	const countRows = [];
+	let countPagesRequested = 0;
+	let invalidRows = 0;
+	let countInvalidRows = 0;
+	let countRowsReturned = 0;
+	let partial = false;
+	let totalCountPages = 0;
+	for (let page = 0; page < MAX_COUNT_PAGES; page += 1) {
+		const response = await client.getLinkCounts(input.site, page);
+		countPagesRequested += 1;
+		invalidRows += response.invalidRows;
+		countInvalidRows += response.invalidRows;
+		countRowsReturned += response.returnedRows;
+		countRows.push(...response.rows);
+		totalCountPages = response.totalPages;
+		partial ||= response.capped;
+		if (countRows.length >= targetLimit || page + 1 >= response.totalPages || response.rows.length === 0) break;
+	}
+	partial ||= countPagesRequested < totalCountPages;
+	const countsByUrl = /* @__PURE__ */ new Map();
+	for (const row of countRows) countsByUrl.set(row.url, Math.max(row.count, countsByUrl.get(row.url) ?? 0));
+	const counts = [...countsByUrl].map(([url, count]) => ({
+		url,
+		count
+	}));
+	counts.sort((a, b) => b.count - a.count || a.url.localeCompare(b.url, "en"));
+	const selectedTargets = counts.slice(0, targetLimit);
+	partial ||= counts.length > targetLimit;
+	const details = await mapConcurrent(selectedTargets, MAX_CONCURRENCY, async (target) => targetDetails({
+		client,
+		site: input.site,
+		target,
+		pages: detailPages
+	}));
+	const rows = [];
+	const keys = /* @__PURE__ */ new Set();
+	let duplicateRows = 0;
+	let detailPagesRequested = 0;
+	let detailInvalidRows = 0;
+	let detailRowsReturned = 0;
+	let failedTargets = 0;
+	for (const [index, detail] of details.entries()) {
+		const target = selectedTargets[index];
+		if (!target) continue;
+		detailPagesRequested += detail.requestedPages;
+		if (detail.failed) failedTargets += 1;
+		invalidRows += detail.invalidRows;
+		detailInvalidRows += detail.invalidRows;
+		detailRowsReturned += detail.returnedRows;
+		partial ||= detail.partial;
+		for (const source of detail.rows) {
+			if (rows.length >= rowLimit) {
+				partial = true;
+				break;
+			}
+			const row = normalizeLinkEvidenceRow({
+				sourceUrl: source.url,
+				targetUrl: target.url,
+				anchorText: source.anchorText
+			});
+			if (!row) {
+				invalidRows += 1;
+				continue;
+			}
+			const key = linkEvidenceKey(row);
+			if (keys.has(key)) {
+				duplicateRows += 1;
+				continue;
+			}
+			keys.add(key);
+			rows.push(row);
+		}
+	}
+	rows.sort(compareLinkEvidence);
+	return {
+		rows,
+		targetCounts: selectedTargets.map((target) => ({
+			targetUrl: target.url,
+			providerReportedLinks: target.count,
+			observedLinks: rows.filter((row) => row.targetUrl === target.url).length
+		})),
+		provenance: {
+			provider: "bing-webmaster",
+			observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			cached: false,
+			suppliedRows: detailRowsReturned + detailInvalidRows,
+			validRows: rows.length,
+			invalidRows,
+			duplicateRows,
+			capped: partial,
+			rowLimit,
+			completeness: partial ? "partial" : "unknown",
+			providerRequests: {
+				methods: ["GetLinkCounts", "GetUrlLinks"],
+				targetPagesRequested: countPagesRequested,
+				detailPagesRequested,
+				maxConcurrentRequests: MAX_CONCURRENCY
+			},
+			providerCoverage: {
+				targetCountRows: {
+					returnedRows: countRowsReturned,
+					retainedRows: counts.length,
+					invalidRows: countInvalidRows
+				},
+				detailRows: {
+					returnedRows: detailRowsReturned,
+					retainedRows: rows.length,
+					invalidRows: detailInvalidRows
+				}
+			}
+		},
+		warnings: [
+			...countRowsReturned === 0 ? ["Bing returned no target-link rows. This does not prove that the site has no links."] : [],
+			...partial ? ["Bing link evidence was bounded by provider pagination, failed requests, or report limits."] : [],
+			...failedTargets ? [`${failedTargets} target detail request${failedTargets === 1 ? "" : "s"} failed while other evidence was retained.`] : []
+		]
+	};
+}
+//#endregion
+//#region packages/core/dist/links/import.js
+const DEFAULT_ROW_LIMIT$1 = 1e4;
+const MAX_ROW_LIMIT$1 = 1e5;
+const MAX_STREAM_BYTES = 5e7;
+const MAX_JSON_BYTES = 1e7;
+const MAX_CELL_BYTES = 1e6;
+function formatFor$1(path, explicit) {
+	if (explicit) return explicit;
+	const extension = extname(path).toLowerCase();
+	if (extension === ".csv") return "csv";
+	if (extension === ".jsonl" || extension === ".ndjson") return "jsonl";
+	if (extension === ".json") return "json";
+	throw new SeoError("INVALID_INPUT", "Link imports must be CSV, JSON, JSONL, or NDJSON.");
+}
+function boundedRowLimit(value) {
+	const limit = value ?? DEFAULT_ROW_LIMIT$1;
+	if (!Number.isInteger(limit) || limit < 1 || limit > MAX_ROW_LIMIT$1) throw new SeoError("INVALID_INPUT", `Link import row limit must be between 1 and ${MAX_ROW_LIMIT$1}.`);
+	return limit;
+}
+async function* csvRecords(path, byteLimit, progress) {
+	const stream = createReadStream(path, { encoding: "utf8" });
+	let record = [];
+	let field = "";
+	let quoted = false;
+	let pendingQuote = false;
+	for await (const chunk of stream) {
+		progress.bytesRead += Buffer.byteLength(chunk);
+		if (progress.bytesRead > byteLimit) {
+			stream.destroy();
+			throw new SeoError("INVALID_INPUT", `Link import exceeds the ${byteLimit}-byte streaming limit.`);
+		}
+		for (const character of chunk) {
+			if (pendingQuote) {
+				if (character === "\"") {
+					field += "\"";
+					pendingQuote = false;
+					continue;
+				}
+				quoted = false;
+				pendingQuote = false;
+			}
+			if (quoted) if (character === "\"") pendingQuote = true;
+			else field += character;
+			else if (character === "\"" && field.length === 0) quoted = true;
+			else if (character === ",") {
+				record.push(field);
+				field = "";
+			} else if (character === "\n") {
+				record.push(field.replace(/\r$/, ""));
+				field = "";
+				if (record.some((value) => value.length > 0)) yield record;
+				record = [];
+			} else field += character;
+			if (Buffer.byteLength(field) > MAX_CELL_BYTES) {
+				stream.destroy();
+				throw new SeoError("INVALID_INPUT", `Link import contains a cell larger than ${MAX_CELL_BYTES} bytes.`);
+			}
+		}
+	}
+	if (quoted && !pendingQuote) throw new SeoError("INVALID_INPUT", "Link CSV contains an unclosed quote.");
+	if (field || record.length) {
+		record.push(field.replace(/\r$/, ""));
+		if (record.some((value) => value.length > 0)) yield record;
+	}
+}
+async function* jsonlRecords(path, byteLimit, progress) {
+	const stream = createReadStream(path, { encoding: "utf8" });
+	let remainder = "";
+	for await (const chunk of stream) {
+		progress.bytesRead += Buffer.byteLength(chunk);
+		if (progress.bytesRead > byteLimit) {
+			stream.destroy();
+			throw new SeoError("INVALID_INPUT", `Link import exceeds the ${byteLimit}-byte streaming limit.`);
+		}
+		remainder += chunk;
+		let newline = remainder.indexOf("\n");
+		while (newline >= 0) {
+			const line = remainder.slice(0, newline).trim();
+			remainder = remainder.slice(newline + 1);
+			if (line) yield parseObject(line);
+			newline = remainder.indexOf("\n");
+		}
+		if (Buffer.byteLength(remainder) > MAX_CELL_BYTES) {
+			stream.destroy();
+			throw new SeoError("INVALID_INPUT", `Link import contains a line larger than ${MAX_CELL_BYTES} bytes.`);
+		}
+	}
+	if (remainder.trim()) yield parseObject(remainder);
+}
+function parseObject(value) {
+	try {
+		const parsed = JSON.parse(value);
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("not an object");
+		return parsed;
+	} catch {
+		throw new SeoError("INVALID_INPUT", "Link JSONL must contain one JSON object per line.");
+	}
+}
+function rowFromCsv(headers, values) {
+	return Object.fromEntries(headers.map((header, index) => [header, values[index]]));
+}
+async function importLinkEvidence(input) {
+	const path = resolve(input.file);
+	const file = await stat(path).catch(() => void 0);
+	if (!file?.isFile()) throw new SeoError("INVALID_INPUT", `Link import file was not found: ${path}`);
+	const format = formatFor$1(path, input.format);
+	const rowLimit = boundedRowLimit(input.rowLimit);
+	if (format === "json" && file.size > MAX_JSON_BYTES) throw new SeoError("INVALID_INPUT", `JSON link imports are limited to ${MAX_JSON_BYTES} bytes. Use CSV or JSONL for larger files.`);
+	const progress = { bytesRead: 0 };
+	let records;
+	if (format === "csv") {
+		const csv = csvRecords(path, MAX_STREAM_BYTES, progress);
+		const first = await csv.next();
+		const headers = (Array.isArray(first.value) ? first.value : []).map((value, index) => index === 0 ? value.replace(/^\uFEFF/, "") : value);
+		if (!headers.length) throw new SeoError("INVALID_INPUT", "Link CSV has no header row.");
+		records = (async function* () {
+			for await (const values of csv) yield rowFromCsv(headers, values);
+		})();
+	} else if (format === "jsonl") records = jsonlRecords(path, MAX_STREAM_BYTES, progress);
+	else {
+		const body = await readFile(path, "utf8");
+		progress.bytesRead = Buffer.byteLength(body);
+		let parsed;
+		try {
+			parsed = JSON.parse(body);
+		} catch {
+			throw new SeoError("INVALID_INPUT", "Link JSON is not valid JSON.");
+		}
+		if (!Array.isArray(parsed)) throw new SeoError("INVALID_INPUT", "Link JSON must be an array of objects.");
+		records = (async function* () {
+			for (const row of parsed) yield row && typeof row === "object" && !Array.isArray(row) ? row : {};
+		})();
+	}
+	const rows = [];
+	const keys = /* @__PURE__ */ new Set();
+	let suppliedRows = 0;
+	let invalidRows = 0;
+	let duplicateRows = 0;
+	let capped = false;
+	for await (const raw of records) {
+		if (suppliedRows >= rowLimit) {
+			capped = true;
+			break;
+		}
+		suppliedRows += 1;
+		const row = normalizeLinkEvidenceRow(raw);
+		if (!row) {
+			invalidRows += 1;
+			continue;
+		}
+		const key = linkEvidenceKey(row);
+		if (keys.has(key)) {
+			duplicateRows += 1;
+			continue;
+		}
+		keys.add(key);
+		rows.push(row);
+	}
+	rows.sort(compareLinkEvidence);
+	const observedAt = (/* @__PURE__ */ new Date()).toISOString();
+	return {
+		rows,
+		targetCounts: [],
+		provenance: {
+			provider: `${format}-import`,
+			observedAt,
+			cached: false,
+			suppliedRows,
+			validRows: rows.length,
+			invalidRows,
+			duplicateRows,
+			capped,
+			rowLimit,
+			completeness: capped ? "partial" : "unknown",
+			file: {
+				path,
+				format,
+				bytesRead: progress.bytesRead,
+				fileBytes: file.size
+			}
+		},
+		warnings: capped ? [`Import stopped after ${rowLimit} rows. The file contains more data.`] : []
+	};
+}
+//#endregion
+//#region packages/core/dist/links/report.js
+const DEFAULT_OUTPUT_LIMIT = 100;
+const MAX_OUTPUT_LIMIT = 500;
+function boundedLimit(value) {
+	const limit = value ?? DEFAULT_OUTPUT_LIMIT;
+	if (!Number.isInteger(limit) || limit < 1 || limit > MAX_OUTPUT_LIMIT) throw new SeoError("INVALID_INPUT", `Link report limit must be between 1 and ${MAX_OUTPUT_LIMIT}.`);
+	return limit;
+}
+function targetCounts(rows) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const row of rows) counts.set(row.targetUrl, (counts.get(row.targetUrl) ?? 0) + 1);
+	return [...counts].map(([targetUrl, observedLinks]) => ({
+		targetUrl,
+		observedLinks
+	})).sort((a, b) => b.observedLinks - a.observedLinks || a.targetUrl.localeCompare(b.targetUrl, "en"));
+}
+function linkEvidenceReport(input) {
+	const limit = boundedLimit(input.limit);
+	const rows = input.evidence.rows.slice(0, limit);
+	const domains = new Set(input.evidence.rows.map((row) => row.sourceDomain));
+	const observedTargets = targetCounts(input.evidence.rows);
+	const counts = input.evidence.targetCounts.length ? input.evidence.targetCounts : observedTargets;
+	return {
+		schemaVersion: 1,
 		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-		checks
+		dataStatus: input.evidence.provenance.completeness === "complete" ? "complete" : "partial",
+		summary: {
+			observedLinks: input.evidence.rows.length,
+			referringDomains: domains.size,
+			targetPages: new Set(input.evidence.rows.map((row) => row.targetUrl)).size,
+			providerTargetPages: counts.length
+		},
+		provenance: input.evidence.provenance,
+		selection: {
+			availableRows: input.evidence.rows.length,
+			returnedRows: rows.length,
+			omittedRows: Math.max(0, input.evidence.rows.length - rows.length),
+			limit
+		},
+		targetCounts: counts.slice(0, 100),
+		links: rows,
+		warnings: input.evidence.warnings,
+		caveats: [
+			"This is bounded provider or imported evidence, not a complete backlink index.",
+			"A missing link is not proof that no link exists, and an observed link is not a quality or ranking verdict.",
+			"Referring-domain counts describe the retained rows only."
+		]
 	};
 }
 //#endregion
@@ -27603,6 +29358,472 @@ var LocalCredentialsProvider = class {
 	}
 };
 new LocalCredentialsProvider();
+//#endregion
+//#region packages/core/dist/server-logs/parse.js
+const MONTHS = {
+	Jan: 0,
+	Feb: 1,
+	Mar: 2,
+	Apr: 3,
+	May: 4,
+	Jun: 5,
+	Jul: 6,
+	Aug: 7,
+	Sep: 8,
+	Oct: 9,
+	Nov: 10,
+	Dec: 11
+};
+const CRAWLERS = [
+	{
+		family: "Googlebot",
+		category: "search",
+		patterns: ["googlebot", "google-inspectiontool"]
+	},
+	{
+		family: "Bingbot",
+		category: "search",
+		patterns: ["bingbot", "bingpreview"]
+	},
+	{
+		family: "Applebot",
+		category: "search",
+		patterns: ["applebot"]
+	},
+	{
+		family: "DuckDuckBot",
+		category: "search",
+		patterns: ["duckduckbot"]
+	},
+	{
+		family: "YandexBot",
+		category: "search",
+		patterns: ["yandexbot"]
+	},
+	{
+		family: "Baiduspider",
+		category: "search",
+		patterns: ["baiduspider"]
+	},
+	{
+		family: "PetalBot",
+		category: "search",
+		patterns: ["petalbot"]
+	},
+	{
+		family: "OpenAI",
+		category: "ai",
+		patterns: [
+			"gptbot",
+			"chatgpt-user",
+			"oai-searchbot"
+		]
+	},
+	{
+		family: "Anthropic",
+		category: "ai",
+		patterns: [
+			"claudebot",
+			"claude-searchbot",
+			"claude-user"
+		]
+	},
+	{
+		family: "Perplexity",
+		category: "ai",
+		patterns: ["perplexitybot", "perplexity-user"]
+	},
+	{
+		family: "Amazonbot",
+		category: "ai",
+		patterns: ["amazonbot"]
+	},
+	{
+		family: "Bytespider",
+		category: "ai",
+		patterns: ["bytespider"]
+	},
+	{
+		family: "CCBot",
+		category: "ai",
+		patterns: ["ccbot"]
+	},
+	{
+		family: "Cohere",
+		category: "ai",
+		patterns: ["cohere-ai"]
+	}
+];
+const COMBINED_LOG = /^\S+\s+\S+\s+\S+\s+\[([^\]]+)]\s+"([^"\s]+)\s+([^"\s]+)(?:\s+[^"\s]+)?"\s+(\d{3})\s+(\d+|-)\s*(?:"[^"]*"\s+"([^"]*)")?\s*$/;
+function classifyCrawler(userAgent) {
+	if (!userAgent) return void 0;
+	const value = userAgent.toLowerCase();
+	const match = CRAWLERS.find((crawler) => crawler.patterns.some((pattern) => value.includes(pattern)));
+	return match ? {
+		family: match.family,
+		category: match.category
+	} : void 0;
+}
+function logTimestamp(value) {
+	const match = /^(\d{2})\/([A-Z][a-z]{2})\/(\d{4}):(\d{2}):(\d{2}):(\d{2}) ([+-])(\d{2})(\d{2})$/.exec(value);
+	if (!match) return void 0;
+	const month = MONTHS[match[2] ?? ""];
+	if (month === void 0) return void 0;
+	const utc = Date.UTC(Number(match[3]), month, Number(match[1]), Number(match[4]), Number(match[5]), Number(match[6]));
+	const offsetMinutes = Number(match[8]) * 60 + Number(match[9]);
+	const adjusted = utc + (match[7] === "+" ? -1 : 1) * offsetMinutes * 6e4;
+	const date = new Date(adjusted);
+	return Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
+}
+function normalizedPath(value) {
+	if (typeof value !== "string" || value.length < 1 || value.length > 2e3) return;
+	try {
+		if (value.startsWith("/")) return new URL(value, "https://server-log.invalid").pathname;
+		const url = new URL(value);
+		return ["http:", "https:"].includes(url.protocol) ? url.pathname : void 0;
+	} catch {
+		return;
+	}
+}
+function normalizedMethod(value) {
+	if (typeof value !== "string" || !/^[A-Za-z]{1,16}$/.test(value)) return;
+	return value.toUpperCase();
+}
+function normalizedStatus(value) {
+	const status = typeof value === "number" ? value : Number(value);
+	return Number.isInteger(status) && status >= 100 && status <= 599 ? status : void 0;
+}
+function normalizedBytes(value) {
+	if (value === void 0 || value === null || value === "" || value === "-") return;
+	const bytes = typeof value === "number" ? value : Number(value);
+	return Number.isSafeInteger(bytes) && bytes >= 0 ? bytes : void 0;
+}
+function record(input) {
+	let timestamp;
+	if (typeof input.timestamp === "string") {
+		const date = new Date(input.timestamp);
+		if (!Number.isNaN(date.getTime())) timestamp = date.toISOString();
+	}
+	const method = normalizedMethod(input.method);
+	const path = normalizedPath(input.path);
+	const status = normalizedStatus(input.status);
+	if (!timestamp || !method || !path || status === void 0) return void 0;
+	const userAgent = typeof input.userAgent === "string" && input.userAgent.length <= 2e3 ? input.userAgent : void 0;
+	return {
+		timestamp,
+		method,
+		path,
+		status,
+		bytes: normalizedBytes(input.bytes),
+		userAgent,
+		crawler: classifyCrawler(userAgent)
+	};
+}
+function parseCombinedLogLine(line) {
+	const match = COMBINED_LOG.exec(line);
+	if (!match) return void 0;
+	const timestamp = logTimestamp(match[1] ?? "");
+	if (!timestamp) return void 0;
+	return record({
+		timestamp,
+		method: match[2],
+		path: match[3],
+		status: match[4],
+		bytes: match[5],
+		userAgent: match[6]
+	});
+}
+function firstValue(value, names) {
+	for (const name of names) if (value[name] !== void 0) return value[name];
+}
+function parseJsonLogLine(line) {
+	let value;
+	try {
+		value = JSON.parse(line);
+	} catch {
+		return;
+	}
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	const row = value;
+	return record({
+		timestamp: firstValue(row, [
+			"timestamp",
+			"time",
+			"datetime",
+			"@timestamp"
+		]),
+		method: firstValue(row, [
+			"method",
+			"requestMethod",
+			"http_method"
+		]),
+		path: firstValue(row, [
+			"path",
+			"url",
+			"requestUri",
+			"request_uri"
+		]),
+		status: firstValue(row, [
+			"status",
+			"statusCode",
+			"status_code"
+		]),
+		bytes: firstValue(row, [
+			"bytes",
+			"bodyBytesSent",
+			"body_bytes_sent"
+		]),
+		userAgent: firstValue(row, [
+			"userAgent",
+			"user_agent",
+			"httpUserAgent",
+			"http_user_agent"
+		])
+	});
+}
+function emptyStatusBreakdown() {
+	return {
+		success: 0,
+		redirect: 0,
+		clientError: 0,
+		serverError: 0,
+		other: 0
+	};
+}
+function addStatus(breakdown, status) {
+	if (status >= 200 && status < 300) breakdown.success += 1;
+	else if (status >= 300 && status < 400) breakdown.redirect += 1;
+	else if (status >= 400 && status < 500) breakdown.clientError += 1;
+	else if (status >= 500) breakdown.serverError += 1;
+	else breakdown.other += 1;
+}
+//#endregion
+//#region packages/core/dist/server-logs/import.js
+const DEFAULT_ROW_LIMIT = 1e6;
+const MAX_ROW_LIMIT = 1e7;
+const DEFAULT_PATH_LIMIT = 25e3;
+const MAX_PATH_LIMIT = 1e5;
+const BYTE_LIMIT = 1e9;
+const MAX_LINE_BYTES = 65536;
+function boundedInteger(value, fallback, maximum, label) {
+	const result = value ?? fallback;
+	if (!Number.isInteger(result) || result < 1 || result > maximum) throw new SeoError("INVALID_INPUT", `${label} must be between 1 and ${maximum}.`);
+	return result;
+}
+function formatFor(path, explicit) {
+	if (explicit) return explicit;
+	const extension = extname(path).toLowerCase();
+	return [".jsonl", ".ndjson"].includes(extension) ? "jsonl" : "combined";
+}
+async function* lines(path, progress) {
+	const stream = createReadStream(path, {
+		encoding: "utf8",
+		highWaterMark: 64 * 1024
+	});
+	let remainder = "";
+	let discarding = false;
+	for await (const chunk of stream) {
+		const remainingBytes = BYTE_LIMIT - progress.bytesRead;
+		if (remainingBytes <= 0) {
+			progress.bytesCapped = true;
+			break;
+		}
+		const chunkBytes = Buffer.byteLength(chunk);
+		const accepted = chunkBytes > remainingBytes ? Buffer.from(chunk).subarray(0, remainingBytes).toString("utf8") : chunk;
+		progress.bytesRead += Buffer.byteLength(accepted);
+		if (chunkBytes > remainingBytes) progress.bytesCapped = true;
+		remainder += accepted;
+		let newline = remainder.indexOf("\n");
+		while (newline >= 0) {
+			const line = remainder.slice(0, newline).replace(/\r$/, "");
+			remainder = remainder.slice(newline + 1);
+			if (discarding || Buffer.byteLength(line) > MAX_LINE_BYTES) {
+				yield { tooLong: true };
+				discarding = false;
+			} else if (line.trim()) yield { line };
+			newline = remainder.indexOf("\n");
+		}
+		if (Buffer.byteLength(remainder) > MAX_LINE_BYTES) {
+			remainder = "";
+			discarding = true;
+		}
+		if (progress.bytesCapped) break;
+	}
+	if (discarding || Buffer.byteLength(remainder) > MAX_LINE_BYTES) yield { tooLong: true };
+	else if (remainder.trim()) yield { line: remainder.replace(/\r$/, "") };
+}
+function compareCrawler(a, b) {
+	return b.requests - a.requests || a.family.localeCompare(b.family, "en");
+}
+function compareCrawlerPath(a, b) {
+	return b.requests - a.requests || a.family.localeCompare(b.family, "en") || a.path.localeCompare(b.path, "en");
+}
+function updatePeriod(timestamp, period) {
+	if (!period.firstSeenAt || timestamp < period.firstSeenAt) period.firstSeenAt = timestamp;
+	if (!period.lastSeenAt || timestamp > period.lastSeenAt) period.lastSeenAt = timestamp;
+}
+function newCrawler(record) {
+	const crawler = record.crawler;
+	if (!crawler) throw new Error("Crawler evidence is required.");
+	return {
+		family: crawler.family,
+		category: crawler.category,
+		requests: 0,
+		lastSeenAt: record.timestamp,
+		...emptyStatusBreakdown()
+	};
+}
+function newCrawlerPath(record) {
+	return {
+		...newCrawler(record),
+		path: record.path
+	};
+}
+async function importServerLog(input) {
+	const path = resolve(input.file);
+	const file = await stat(path).catch(() => void 0);
+	if (!file?.isFile()) throw new SeoError("INVALID_INPUT", `Server log was not found: ${path}`);
+	const format = formatFor(path, input.format);
+	const rowLimit = boundedInteger(input.rowLimit, DEFAULT_ROW_LIMIT, MAX_ROW_LIMIT, "Server log row limit");
+	const pathLimit = boundedInteger(input.pathLimit, DEFAULT_PATH_LIMIT, MAX_PATH_LIMIT, "Server log path limit");
+	const parse = format === "jsonl" ? parseJsonLogLine : parseCombinedLogLine;
+	const progress = {
+		bytesRead: 0,
+		bytesCapped: false
+	};
+	const period = {};
+	const statusCodes = /* @__PURE__ */ new Map();
+	const crawlers = /* @__PURE__ */ new Map();
+	const crawlerPaths = /* @__PURE__ */ new Map();
+	let suppliedRows = 0;
+	let parsedRows = 0;
+	let invalidRows = 0;
+	let crawlerRows = 0;
+	let responseBytes = 0;
+	let rowsCapped = false;
+	let pathsCapped = false;
+	let untrackedCrawlerPathRows = 0;
+	for await (const item of lines(path, progress)) {
+		if (suppliedRows >= rowLimit) {
+			rowsCapped = true;
+			break;
+		}
+		suppliedRows += 1;
+		const parsed = item.line ? parse(item.line) : void 0;
+		if (!parsed) {
+			invalidRows += 1;
+			continue;
+		}
+		parsedRows += 1;
+		responseBytes += parsed.bytes ?? 0;
+		updatePeriod(parsed.timestamp, period);
+		statusCodes.set(parsed.status, (statusCodes.get(parsed.status) ?? 0) + 1);
+		if (!parsed.crawler) continue;
+		crawlerRows += 1;
+		const crawler = crawlers.get(parsed.crawler.family) ?? newCrawler(parsed);
+		crawler.requests += 1;
+		if (parsed.timestamp > crawler.lastSeenAt) crawler.lastSeenAt = parsed.timestamp;
+		addStatus(crawler, parsed.status);
+		crawlers.set(parsed.crawler.family, crawler);
+		const key = `${parsed.crawler.family}\u0000${parsed.path}`;
+		let crawlerPath = crawlerPaths.get(key);
+		if (!crawlerPath && crawlerPaths.size >= pathLimit) {
+			pathsCapped = true;
+			untrackedCrawlerPathRows += 1;
+			continue;
+		}
+		crawlerPath ??= newCrawlerPath(parsed);
+		crawlerPath.requests += 1;
+		if (parsed.timestamp > crawlerPath.lastSeenAt) crawlerPath.lastSeenAt = parsed.timestamp;
+		addStatus(crawlerPath, parsed.status);
+		crawlerPaths.set(key, crawlerPath);
+	}
+	const fileReadCompletely = !rowsCapped && !progress.bytesCapped && progress.bytesRead >= file.size;
+	const completeness = fileReadCompletely && invalidRows === 0 && !pathsCapped ? "complete" : "partial";
+	const warnings = [];
+	if (rowsCapped) warnings.push(`Analysis stopped after ${rowLimit} rows.`);
+	if (progress.bytesCapped) warnings.push(`Analysis stopped after ${BYTE_LIMIT} input bytes.`);
+	if (invalidRows) warnings.push(`${invalidRows} malformed or unsupported rows were skipped.`);
+	if (pathsCapped) warnings.push(`Crawler path tracking stopped at ${pathLimit} unique crawler and path pairs. Overall crawler and status totals still include later valid rows.`);
+	return {
+		summary: {
+			suppliedRows,
+			parsedRows,
+			invalidRows,
+			crawlerRows,
+			nonCrawlerRows: parsedRows - crawlerRows,
+			responseBytes,
+			...period
+		},
+		statusCodes: [...statusCodes].map(([status, requests]) => ({
+			status,
+			requests
+		})).sort((a, b) => a.status - b.status),
+		crawlers: [...crawlers.values()].sort(compareCrawler),
+		crawlerPaths: [...crawlerPaths.values()].sort(compareCrawlerPath),
+		provenance: {
+			source: "local-server-log",
+			observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			cached: false,
+			file: {
+				path,
+				format,
+				bytesRead: progress.bytesRead,
+				fileBytes: file.size
+			},
+			limits: {
+				rowLimit,
+				pathLimit,
+				byteLimit: BYTE_LIMIT,
+				maxLineBytes: MAX_LINE_BYTES
+			},
+			coverage: {
+				fileReadCompletely,
+				rowsCapped,
+				bytesCapped: progress.bytesCapped,
+				pathsCapped,
+				untrackedCrawlerPathRows
+			},
+			completeness
+		},
+		warnings
+	};
+}
+//#endregion
+//#region packages/core/dist/server-logs/report.js
+const DEFAULT_LIMIT = 100;
+const MAX_LIMIT = 500;
+function outputLimit(value) {
+	const limit = value ?? DEFAULT_LIMIT;
+	if (!Number.isInteger(limit) || limit < 1 || limit > MAX_LIMIT) throw new SeoError("INVALID_INPUT", `Server log output limit must be between 1 and ${MAX_LIMIT}.`);
+	return limit;
+}
+function serverLogReport(input) {
+	const limit = outputLimit(input.limit);
+	const crawlerPaths = input.evidence.crawlerPaths.slice(0, limit);
+	return {
+		schemaVersion: 1,
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		dataStatus: input.evidence.provenance.completeness,
+		summary: input.evidence.summary,
+		statusCodes: input.evidence.statusCodes,
+		crawlers: input.evidence.crawlers,
+		crawlerPaths,
+		selection: {
+			availableCrawlerPaths: input.evidence.crawlerPaths.length,
+			returnedCrawlerPaths: crawlerPaths.length,
+			omittedCrawlerPaths: Math.max(0, input.evidence.crawlerPaths.length - crawlerPaths.length),
+			limit
+		},
+		provenance: input.evidence.provenance,
+		warnings: input.evidence.warnings,
+		caveats: [
+			"Crawler families are identified from user-agent strings, which can be missing or spoofed.",
+			"This report describes only the supplied log file and cannot prove that every server or time period is represented.",
+			"Crawler path rankings describe retained path aggregates when the path limit is reached."
+		]
+	};
+}
 const TELEMETRY_TIMEOUT_MS = 2e3;
 const TELEMETRY_REPORTS = [
 	"affected-urls",
@@ -27612,6 +29833,7 @@ const TELEMETRY_REPORTS = [
 	"ai-search-scorecard",
 	"audit-page",
 	"audit-urls",
+	"bing-webmaster-overview",
 	"cannibalisation",
 	"community-intent",
 	"compare-crawls",
@@ -27630,6 +29852,8 @@ const TELEMETRY_REPORTS = [
 	"index-monitor",
 	"index-watch",
 	"internal-links",
+	"link-evidence",
+	"server-log-analysis",
 	"link-recovery",
 	"crawl-history",
 	"crawler-rules",
@@ -29602,6 +31826,87 @@ function registerOpportunityTools(server, dependencies = {}) {
 	});
 }
 //#endregion
+//#region packages/mcp/src/provider-tools.ts
+const MAX_AGENT_ROWS_PER_SECTION = 14;
+function compactRows(data) {
+	if (data.rows.length <= MAX_AGENT_ROWS_PER_SECTION && data.outputSelection) return data;
+	const rows = data.rows.slice(-14);
+	return {
+		...data,
+		rows,
+		outputSelection: {
+			strategy: "most-recent",
+			availableRows: data.rows.length,
+			returnedRows: rows.length,
+			omittedRows: Math.max(0, data.rows.length - rows.length)
+		}
+	};
+}
+function compactBingWebmasterOverview(result) {
+	return {
+		...result,
+		traffic: result.traffic.status === "unavailable" ? result.traffic : {
+			...result.traffic,
+			data: compactRows(result.traffic.data)
+		},
+		crawl: result.crawl.status === "unavailable" ? result.crawl : {
+			...result.crawl,
+			data: compactRows(result.crawl.data)
+		},
+		outputBudget: result.outputBudget
+	};
+}
+function registerProviderTools(server) {
+	server.registerTool("seo_bing_webmaster_overview", {
+		description: "Find bounded Bing traffic, crawl, query, and page insights for one verified site",
+		inputSchema: { site: z$1.string().url().max(2e3) }
+	}, async ({ site }) => {
+		try {
+			const result = await bingWebmasterOverview({ site });
+			const firstFinding = result.findings[0]?.title;
+			return toolSuccess(`Bing evidence is ${result.dataStatus} with ${result.summary.findings} findings.${firstFinding ? ` Review first: ${firstFinding}.` : ""}`, compactBingWebmasterOverview(result));
+		} catch (error) {
+			return toolError(error);
+		}
+	});
+	server.registerTool("seo_link_evidence", {
+		description: "Review bounded referring-link evidence from Bing Webmaster or a local export",
+		inputSchema: {
+			site: z$1.string().url().max(2e3).optional(),
+			file: z$1.string().min(1).max(4096).optional(),
+			format: z$1.enum([
+				"csv",
+				"json",
+				"jsonl"
+			]).optional(),
+			rowLimit: z$1.number().int().min(1).max(1e5).optional(),
+			targetLimit: z$1.number().int().min(1).max(50).optional(),
+			detailPagesPerTarget: z$1.number().int().min(1).max(3).optional(),
+			limit: z$1.number().int().min(1).max(500).optional()
+		}
+	}, async ({ site, file, format, rowLimit, targetLimit, detailPagesPerTarget, limit }) => {
+		try {
+			if (Boolean(site) === Boolean(file)) throw new SeoError("INVALID_INPUT", "Pass exactly one of site for Bing or file for a local import.");
+			const report = linkEvidenceReport({
+				evidence: file ? await importLinkEvidence({
+					file,
+					format,
+					rowLimit
+				}) : await collectBingLinkEvidence({
+					site: site ?? "",
+					rowLimit,
+					targetLimit,
+					detailPagesPerTarget
+				}),
+				limit
+			});
+			return toolSuccess(`${report.summary.observedLinks} referring links were retained from ${report.provenance.provider}.`, report);
+		} catch (error) {
+			return toolError(error);
+		}
+	});
+}
+//#endregion
 //#region packages/mcp/src/pseo-tools.ts
 function compactPseoReport(result) {
 	return {
@@ -29894,6 +32199,91 @@ const REPORT_DEPTH = {
 			}
 		]
 	},
+	"bing-webmaster-overview": {
+		readOrder: [
+			"dataStatus and provenance",
+			"summary and findings, including verification steps",
+			"traffic analysis current and previous periods, then changes",
+			"crawl analysis current and previous snapshots, then changes",
+			"query and page coverage before movements or opportunities",
+			"outputBudget, per-section outputSelection, and caveats"
+		],
+		doNotClaim: [
+			"Bing evidence does not describe Google or the whole search market, and inIndex is not URL-level proof of indexing.",
+			"A missing weekly top-list entry is not zero traffic, and movements require observation in every week of both periods.",
+			"Opportunity thresholds prioritize review and are not Bing requirements.",
+			"Partial, capped, invalid, or unavailable rows cannot support an all-clear."
+		],
+		verify: "Check the same verified site in Bing Webmaster Tools and investigate the exact dates behind any crawl or traffic change.",
+		related: [
+			{
+				id: "search-performance-overview",
+				reason: "Adds Search Console evidence."
+			},
+			{
+				id: "site-crawl",
+				reason: "Checks the current site directly."
+			},
+			{
+				id: "link-recovery",
+				reason: "Finds broken search-value URLs."
+			}
+		]
+	},
+	"link-evidence": {
+		readOrder: [
+			"dataStatus, provenance, warnings, and caveats",
+			"selection and summary coverage counts",
+			"targetCounts, then the bounded links list"
+		],
+		doNotClaim: [
+			"The retained rows are not a complete backlink index.",
+			"Missing rows do not prove a link does not exist.",
+			"Observed links do not establish quality, authority, value, or ranking impact."
+		],
+		verify: "Open a selected referring URL and confirm the link is still present before acting on it.",
+		related: [
+			{
+				id: "link-recovery",
+				reason: "Finds broken search-value URLs."
+			},
+			{
+				id: "redirect-trace",
+				reason: "Checks a target redirect chain."
+			},
+			{
+				id: "site-crawl",
+				reason: "Checks internal links and live pages."
+			}
+		]
+	},
+	"server-log-analysis": {
+		readOrder: [
+			"dataStatus, provenance coverage, warnings, and caveats",
+			"summary and statusCodes",
+			"crawlers, then the bounded crawlerPaths list and selection"
+		],
+		doNotClaim: [
+			"A user-agent match does not verify the crawler identity or source IP.",
+			"The supplied file does not prove that every server or time period is represented.",
+			"Path rankings are partial when path tracking reached its limit."
+		],
+		verify: "Check important crawler errors against the original log line and deployment or server configuration before changing the site.",
+		related: [
+			{
+				id: "site-crawl",
+				reason: "Checks the current site directly."
+			},
+			{
+				id: "crawler-rules",
+				reason: "Explains current crawl checks."
+			},
+			{
+				id: "redirect-trace",
+				reason: "Traces one failing or redirecting path."
+			}
+		]
+	},
 	cannibalisation: {
 		readOrder: [
 			"dataStatus and both source.pageExposure and source.propertyDemand with validation counts and completeness",
@@ -31177,6 +33567,27 @@ const REPORT_GUIDANCE = {
 		avoidWhen: ["You need the crawler to discover pages for you.", "You only need a deep review of one page."],
 		outcome: "Consistent technical checks for each supplied URL."
 	},
+	"bing-webmaster-overview": {
+		name: "Bing Webmaster overview",
+		description: "Review bounded Bing traffic trends, crawl changes, and query and page opportunities for one verified site.",
+		useWhen: ["You want processed search and crawl insights observed by Bing.", "You need a second search-engine view beside Search Console."],
+		avoidWhen: ["Bing Webmaster is not connected for this installation.", "You need URL-level backlink rows or proof that a page is indexed."],
+		outcome: "Prioritized Bing findings with traffic comparisons, crawl changes, query and page opportunities, provider coverage, and caveats."
+	},
+	"link-evidence": {
+		name: "Referring link evidence",
+		description: "Review a bounded set of pages that link to the site from Bing Webmaster or a local export.",
+		useWhen: ["You want concrete referring URLs and anchor text where available.", "You need one normalized view of Bing or an exported CSV, JSON, or JSONL file."],
+		avoidWhen: ["You need a complete backlink index or a domain authority score.", "You want to find broken internal links during a crawl."],
+		outcome: "A bounded, deduplicated link list with target-page counts and explicit source coverage."
+	},
+	"server-log-analysis": {
+		name: "Server log crawler analysis",
+		description: "Stream a local access log to see observed search and AI crawler requests, statuses, and paths.",
+		useWhen: ["You need evidence of crawler requests that reached the web server.", "You want to find crawler-facing 4xx or 5xx responses in a local access log."],
+		avoidWhen: ["You do not have a combined or JSONL access log.", "You need to prove crawler identity from a user-agent string alone."],
+		outcome: "Bounded crawler, status, and path aggregates with file coverage and parser limits kept visible."
+	},
 	cannibalisation: {
 		name: "Query and URL overlap",
 		description: "Find search queries that appear across several URLs and decide whether the overlap needs attention.",
@@ -31683,6 +34094,35 @@ function registerReportTools(server) {
 	registerSecondPageTool(server);
 }
 //#endregion
+//#region packages/mcp/src/server-log-tools.ts
+function registerServerLogTools(server) {
+	server.registerTool("seo_server_log_analysis", {
+		description: "Stream a local access log into bounded search and AI crawler evidence",
+		inputSchema: {
+			file: z$1.string().min(1).max(4096),
+			format: z$1.enum(["combined", "jsonl"]).optional(),
+			rowLimit: z$1.number().int().min(1).max(1e7).optional(),
+			pathLimit: z$1.number().int().min(1).max(1e5).optional(),
+			limit: z$1.number().int().min(1).max(500).optional()
+		}
+	}, async ({ file, format, rowLimit, pathLimit, limit }) => {
+		try {
+			const report = serverLogReport({
+				evidence: await importServerLog({
+					file,
+					format,
+					rowLimit,
+					pathLimit
+				}),
+				limit
+			});
+			return toolSuccess(`${report.summary.crawlerRows} crawler requests were observed in ${report.summary.parsedRows} parsed log rows.`, report);
+		} catch (error) {
+			return toolError(error);
+		}
+	});
+}
+//#endregion
 //#region packages/mcp/src/agent-output-budget.ts
 const AGENT_STRUCTURED_OUTPUT_MAX_BYTES = 96 * 1024;
 function jsonBytes(value) {
@@ -32079,6 +34519,16 @@ const reportGroups = [
 			"seo_redirect_trace"
 		]
 	},
+	{
+		category: "monitoring",
+		register: registerProviderTools,
+		names: ["seo_bing_webmaster_overview", "seo_link_evidence"]
+	},
+	{
+		category: "monitoring",
+		register: registerServerLogTools,
+		names: ["seo_server_log_analysis"]
+	},
 	{
 		category: "reporting",
 		register: registerReportTools,