seo 0.1.0 → 0.2.1

package/dist/index.js

@@ -1,5 +1,5 @@
 import { createRequire as __seoCreateRequire } from 'node:module'; const require = __seoCreateRequire(import.meta.url);
-import { n as load, t as version } from "./package-uzXzqDW6.js";
+import { n as load, t as version } from "./package-BTOI9tde.js";
 import { Headers, fetch as fetch$1 } from "undici";
 import { chmodSync, createWriteStream, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
@@ -888,7 +888,7 @@ function oauthCallbackPage() {
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <meta name="color-scheme" content="light dark">
     <meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src 'unsafe-inline'">
-    <title>SEO Skills is connected</title>
+    <title>seo is connected</title>
     <style>
       :root {
         color-scheme: light dark;
@@ -1027,7 +1027,7 @@ function oauthCallbackPage() {
           <svg viewBox="0 0 24 24" aria-hidden="true">
             <path fill="currentColor" d="M12,8c-2.2,0-4,1.8-4,4s1.8,4,4,4s4-1.8,4-4C16,9.8,14.2,8,12,8z M3,9L3,9c0.6,0,1-0.4,1-1V5c0-0.6,0.4-1,1-1h3 c0.6,0,1-0.4,1-1S8.6,2,8,2H5C3.3,2,2,3.3,2,5v3C2,8.6,2.4,9,3,9z M8,20H5c-0.6,0-1-0.4-1-1v-3c0-0.6-0.4-1-1-1s-1,0.4-1,1v3 c0,1.7,1.3,3,3,3h3c0.6,0,1-0.4,1-1S8.6,20,8,20z M21,15L21,15c-0.6,0-1,0.4-1,1v3c0,0.6-0.4,1-1,1h-3c-0.6,0-1,0.4-1,1s0.4,1,1,1h3 c1.7,0,3-1.3,3-3v-3C22,15.4,21.6,15,21,15z M19,2h-3c-0.6,0-1,0.4-1,1s0.4,1,1,1h3c0.6,0,1,0.4,1,1v3c0,0.6,0.4,1,1,1s1-0.4,1-1V5 C22,3.3,20.7,2,19,2z" />
           </svg>
-          SEO Skills
+          seo
         </span>
       </div>
     </header>
@@ -1036,7 +1036,7 @@ function oauthCallbackPage() {
         <div class="frame content">
           <p class="status"><span class="status-mark" aria-hidden="true"></span>Google account connected</p>
           <h1>You can start your first SEO report.</h1>
-          <p class="lead">Go back to your terminal to continue. SEO Skills will help you choose a site and save a project profile before future reports.</p>
+          <p class="lead">Go back to your terminal to continue, and the CLI will help you choose a site and save a project profile before future reports.</p>
         </div>
       </section>
       <div class="frame details">
@@ -1046,7 +1046,7 @@ function oauthCallbackPage() {
         </section>
         <section class="detail">
           <h2>Read-only access</h2>
-          <p>SEO Skills can read the Google data you choose. It cannot change your site or Google account.</p>
+          <p>The seo CLI can read the Google data you choose. It cannot change your site or Google account.</p>
         </section>
       </div>
     </main>
@@ -6644,7 +6644,7 @@ function matchesFilters(issue, filters) {
 }
 //#endregion
 //#region packages/core/src/analyze/crawler/ai-readiness.ts
-function pct$2(part, total) {
+function pct$3(part, total) {
 	if (total <= 0) return 0;
 	return Math.round(part / total * 100);
 }
@@ -6674,14 +6674,14 @@ function check(input) {
 		status: evaluated ? status(score, maxScore) : "unknown"
 	};
 }
-function indexablePages(report) {
+function indexablePages$1(report) {
 	return report.pages.filter((page) => page.indexable && page.status < 400);
 }
-function sampleUrls(pages, predicate) {
+function sampleUrls$1(pages, predicate) {
 	return pages.filter(predicate).slice(0, 10).map((page) => page.finalUrl);
 }
 function aiReadiness(report) {
-	const pages = indexablePages(report);
+	const pages = indexablePages$1(report);
 	const pageCount = pages.length;
 	const hasIndexablePages = pageCount > 0;
 	const pageLimitReached = report.summary.pageLimitReached;
@@ -6721,7 +6721,7 @@ function aiReadiness(report) {
 				section: "agent-access",
 				maxScore: 20,
 				evaluated: botAccessEvaluated,
-				score: robotsUnavailable ? 0 : botAccess.length ? blockedBots.length ? scoreFromPercent(pct$2(botAccess.length - blockedBots.length, botAccess.length), 20) : 20 : 8,
+				score: robotsUnavailable ? 0 : botAccess.length ? blockedBots.length ? scoreFromPercent(pct$3(botAccess.length - blockedBots.length, botAccess.length), 20) : 20 : 8,
 				title: robotsUnavailable ? "robots.txt crawler-policy evidence is unavailable" : !hasBotAccessEvidence ? "robots.txt crawler-policy evidence was not collected" : blockedBots.length ? "robots.txt blocks selected crawler tokens at the start URL" : "robots.txt allows selected crawler tokens at the start URL",
 				plainEnglish: robotsUnavailable ? "The robots.txt request failed, so this report cannot say whether selected crawler tokens are allowed at the start URL." : !hasBotAccessEvidence ? "This crawl does not include per-bot robots.txt policy data for the start URL." : blockedBots.length ? `robots.txt policy blocks ${blockedBots.length} selected crawler ${blockedBots.length === 1 ? "token" : "tokens"} at the start URL.` : "robots.txt policy does not block the selected crawler tokens at the start URL. This does not verify actual or site-wide fetchability.",
 				action: robotsUnavailable ? "Restore a stable robots.txt response, then rerun this report before making crawler-policy claims." : !hasBotAccessEvidence ? "Rerun the crawl with top-level per-bot robots.txt evidence before making crawler-policy claims." : blockedBots.length ? "Only block AI crawlers intentionally. If discovery matters, remove accidental Disallow rules for the blocked user agents." : "Keep robots.txt explicit and intentional so humans and agents can see what is allowed.",
@@ -6790,9 +6790,9 @@ function aiReadiness(report) {
 				evaluated: hasIndexablePages,
 				score: 0,
 				title: "Short opening paragraphs are an unscored observation",
-				plainEnglish: hasIndexablePages ? `${pct$2(answerablePages.length, pageCount)}% of indexable pages have at least one 25-word paragraph near the start. This does not establish content quality, citation likelihood, or Google AI eligibility.` : "No indexable 2xx pages were available, so opening-paragraph coverage was not evaluated.",
+				plainEnglish: hasIndexablePages ? `${pct$3(answerablePages.length, pageCount)}% of indexable pages have at least one 25-word paragraph near the start. This does not establish content quality, citation likelihood, or Google AI eligibility.` : "No indexable 2xx pages were available, so opening-paragraph coverage was not evaluated.",
 				action: "Write for the reader and the page intent. Do not create artificial answer blocks or chunk content solely for AI Search.",
-				urls: sampleUrls(pages, (page) => !page.geo?.answerable),
+				urls: sampleUrls$1(pages, (page) => !page.geo?.answerable),
 				evidence: {
 					observedPages: answerablePages.length,
 					evaluatedPages: pageCount,
@@ -6808,7 +6808,7 @@ function aiReadiness(report) {
 				evaluated: hasIndexablePages,
 				score: 0,
 				title: "Semantic HTML coverage observed",
-				plainEnglish: hasIndexablePages ? `${pct$2(semanticPages.length, pageCount)}% of indexable pages use semantic structure.` : "No indexable 2xx pages were available, so semantic HTML coverage was not evaluated.",
+				plainEnglish: hasIndexablePages ? `${pct$3(semanticPages.length, pageCount)}% of indexable pages use semantic structure.` : "No indexable 2xx pages were available, so semantic HTML coverage was not evaluated.",
 				action: "Use real headings, lists, tables, nav, main, article, and section elements instead of layout-only divs."
 			}),
 			check({
@@ -6818,7 +6818,7 @@ function aiReadiness(report) {
 				evaluated: hasIndexablePages,
 				score: 0,
 				title: "Title, H1, and description coverage observed",
-				plainEnglish: hasIndexablePages ? `${pct$2(titlePages.length, pageCount)}% of indexable pages have title/H1 coverage and ${pct$2(metaPages.length, pageCount)}% have meta descriptions.` : "No indexable 2xx pages were available, so title, H1, and description coverage was not evaluated.",
+				plainEnglish: hasIndexablePages ? `${pct$3(titlePages.length, pageCount)}% of indexable pages have title/H1 coverage and ${pct$3(metaPages.length, pageCount)}% have meta descriptions.` : "No indexable 2xx pages were available, so title, H1, and description coverage was not evaluated.",
 				action: "Write a unique title and descriptive H1. Add a useful meta description when a summary would help searchers understand the page."
 			}),
 			check({
@@ -6828,7 +6828,7 @@ function aiReadiness(report) {
 				evaluated: hasIndexablePages,
 				score: 0,
 				title: "HTML language declaration coverage observed",
-				plainEnglish: hasIndexablePages ? `${pct$2(langPages.length, pageCount)}% of indexable pages declare a language.` : "No indexable 2xx pages were available, so language declaration coverage was not evaluated.",
+				plainEnglish: hasIndexablePages ? `${pct$3(langPages.length, pageCount)}% of indexable pages declare a language.` : "No indexable 2xx pages were available, so language declaration coverage was not evaluated.",
 				action: "Set the html lang attribute so crawlers and assistive tech understand the page language."
 			})
 		]),
@@ -6839,9 +6839,9 @@ function aiReadiness(report) {
 			evaluated: hasIndexablePages,
 			score: 0,
 			title: "Entity-signal coverage observed",
-			plainEnglish: hasIndexablePages ? `${pct$2(entityPages.length, pageCount)}% of indexable pages include entity signals such as Organization, Person, Product, sameAs, or social profile links.` : "No indexable 2xx pages were available, so entity-signal coverage was not evaluated.",
+			plainEnglish: hasIndexablePages ? `${pct$3(entityPages.length, pageCount)}% of indexable pages include entity signals such as Organization, Person, Product, sameAs, or social profile links.` : "No indexable 2xx pages were available, so entity-signal coverage was not evaluated.",
 			action: "Make the homepage and key pages explicit about the brand, product, people, and official profiles using accurate schema and links.",
-			urls: sampleUrls(pages, (page) => !entityPages.includes(page))
+			urls: sampleUrls$1(pages, (page) => !entityPages.includes(page))
 		}), check({
 			id: "authors-dates",
 			section: "entity-signals",
@@ -6883,9 +6883,9 @@ function aiReadiness(report) {
 				section: "technical-ux",
 				maxScore: 12,
 				evaluated: report.pages.length > 0,
-				score: scoreFromPercent(pct$2(pages.length, report.pages.length || 1), 12),
+				score: scoreFromPercent(pct$3(pages.length, report.pages.length || 1), 12),
 				title: report.pages.length ? "Crawled-page indexability observed" : "Crawled-page indexability was not evaluated",
-				plainEnglish: report.pages.length ? `${pct$2(pages.length, report.pages.length)}% of crawled pages are indexable 2xx pages.` : "No crawled pages were available, so status and indexability were not evaluated.",
+				plainEnglish: report.pages.length ? `${pct$3(pages.length, report.pages.length)}% of crawled pages are indexable 2xx pages.` : "No crawled pages were available, so status and indexability were not evaluated.",
 				action: "Fix 4xx/5xx pages, accidental noindex, and blocked internal URLs before expanding AI discovery work."
 			})
 		]),
@@ -6907,35 +6907,815 @@ function aiReadiness(report) {
 			action: "Link important pages from navigational, hub, or contextual links so crawlers can find them naturally."
 		})])
 	];
-	const checks = sections.flatMap((item) => item.checks);
-	const dataStatus = report.status === "completed" && !robotsEvidenceIncomplete ? "complete" : "partial";
-	const topActions = checks.filter((item) => item.evaluated && (item.status === "warning" || item.status === "fail") && [
-		"robots-ai-bots",
-		"valid-json-ld",
-		"status-indexability",
-		"crawl-depth"
-	].includes(item.id)).sort((a, b) => Number(b.status === "fail") - Number(a.status === "fail") || a.id.localeCompare(b.id)).slice(0, 8);
+	const checks = sections.flatMap((item) => item.checks);
+	const dataStatus = report.status === "completed" && !robotsEvidenceIncomplete ? "complete" : "partial";
+	const topActions = checks.filter((item) => item.evaluated && (item.status === "warning" || item.status === "fail") && [
+		"robots-ai-bots",
+		"valid-json-ld",
+		"status-indexability",
+		"crawl-depth"
+	].includes(item.id)).sort((a, b) => Number(b.status === "fail") - Number(a.status === "fail") || a.id.localeCompare(b.id)).slice(0, 8);
+	return {
+		reportId: report.id,
+		url: report.config.url,
+		generatedAt: report.generatedAt,
+		dataStatus,
+		assessment: "evidence-only",
+		headline: dataStatus === "partial" ? "AI-search evidence is incomplete. Fix the collection gaps before drawing site-wide conclusions." : topActions.length ? `${topActions.length} evidence-backed technical ${topActions.length === 1 ? "action remains" : "actions remain"}. Optional observations are not treated as ranking or citation factors.` : "No evidence-backed technical action was found in this crawl. This is not a visibility or citation verdict.",
+		sections,
+		checks,
+		topActions,
+		botAccess,
+		agentResources: report.ai?.agentResources ?? [],
+		caveats: [
+			...report.caveats,
+			"This report deliberately has no aggregate readiness score. Google documents no separate technical requirements for its generative AI Search features.",
+			"llms.txt is treated as optional agent-discovery metadata, not a Google Search ranking or visibility factor.",
+			"Paragraph length and placement are observations only. Google does not require content chunking or special answer blocks for generative AI features.",
+			"Snippet controls reflect page-level publisher directives only. No detected restriction does not guarantee selection, visibility, or a displayed snippet.",
+			...robotsTxt ? robotsUnavailable ? ["robots.txt was unavailable, so crawler access and sitemap declaration checks are inconclusive."] : !hasBotAccessEvidence ? ["robots.txt was collected without per-bot policy evidence, so the crawler-policy check is inconclusive."] : [] : ["This crawl report does not include top-level robots.txt AI bot data."],
+			"robots.txt checks describe policy for the configured start URL only. They do not verify actual crawler requests or site-wide access."
+		]
+	};
+}
+//#endregion
+//#region packages/core/src/analyze/crawler/entity-readiness.ts
+function unique$3(values) {
+	return [...new Set(values.filter((value) => Boolean(value)))];
+}
+function pct$2(part, total) {
+	return total ? Math.round(part / total * 100) : 0;
+}
+function entityReadiness(report) {
+	const pages = report.pages.filter((page) => page.indexable && page.status < 400);
+	const total = pages.length || 1;
+	const schemaTypes = {};
+	for (const page of pages) for (const type of page.schemaTypes ?? []) schemaTypes[type] = (schemaTypes[type] ?? 0) + 1;
+	const entitySchemaPages = pages.filter((page) => page.schemaTypes?.some((type) => /^(Organization|LocalBusiness|Person|Product|WebSite)$/i.test(type)));
+	const sameAsEvidence = pages.flatMap((page) => page.schemaSameAsEvidence ?? []).filter((evidence) => evidence.subjectTypes.some((type) => /^(Organization|LocalBusiness|Person)$/i.test(type)));
+	const siteSameAsEvidence = sameAsEvidence.filter((evidence) => evidence.subjectTypes.some((type) => /^(Organization|LocalBusiness)$/i.test(type)));
+	const sameAs = unique$3(sameAsEvidence.map((evidence) => evidence.url));
+	const sameAsByType = {};
+	for (const evidence of sameAsEvidence) for (const type of evidence.subjectTypes) {
+		if (!/^(Organization|LocalBusiness|Person)$/i.test(type)) continue;
+		sameAsByType[type] = unique$3([...sameAsByType[type] ?? [], evidence.url]);
+	}
+	const socialProfiles = unique$3(pages.flatMap((page) => page.socialProfileLinks ?? []));
+	const authors = unique$3(pages.map((page) => page.author));
+	const authorPages = pages.filter((page) => page.author || page.geo?.hasAuthor);
+	const datePages = pages.filter((page) => page.hasDate || page.geo?.hasDate);
+	const titlePages = pages.filter((page) => page.title && page.h1);
+	const checks = [
+		{
+			coverage: pct$2(entitySchemaPages.length, total),
+			check: {
+				id: "entity-schema",
+				title: "Entity schema is present",
+				plainEnglish: `${pct$2(entitySchemaPages.length, total)}% of evaluated indexable pages include Organization, LocalBusiness, Person, Product, or WebSite schema.`,
+				action: "Add accurate entity schema to the homepage and key product, author, organization, and local pages.",
+				evidence: { schemaTypes },
+				urls: pages.filter((page) => !entitySchemaPages.includes(page)).slice(0, 10).map((page) => page.finalUrl)
+			}
+		},
+		{
+			coverage: siteSameAsEvidence.length ? 100 : 0,
+			check: {
+				id: "same-as",
+				title: "Site entity profiles are connected",
+				plainEnglish: siteSameAsEvidence.length ? "The crawl found sameAs links attached to Organization or LocalBusiness structured data." : sameAs.length ? "The crawl found Person sameAs links, but no Organization or LocalBusiness profile evidence for the site entity." : socialProfiles.length ? "The crawl found social-domain links, but they are not enough to prove official profile ownership." : "The crawl did not find entity-scoped sameAs evidence.",
+				action: "Connect official profiles with sameAs on Organization, Person, or LocalBusiness schema. Use only profiles you control.",
+				evidence: {
+					sameAs,
+					siteSameAs: unique$3(siteSameAsEvidence.map((evidence) => evidence.url)),
+					sameAsEvidence,
+					unclassifiedSocialLinks: socialProfiles
+				}
+			}
+		},
+		{
+			coverage: Math.round((pct$2(authorPages.length, total) + pct$2(datePages.length, total)) / 2),
+			check: {
+				id: "authority-freshness",
+				title: "Author and date signals observed",
+				plainEnglish: `${pct$2(authorPages.length, total)}% of evaluated indexable pages expose an author signal and ${pct$2(datePages.length, total)}% expose a date signal.`,
+				action: "For editorial content, identify authors and show accurate published or modified dates when that information is useful to readers.",
+				evidence: {
+					authorCoverage: pct$2(authorPages.length, total),
+					dateCoverage: pct$2(datePages.length, total),
+					authors
+				}
+			}
+		},
+		{
+			coverage: pct$2(titlePages.length, total),
+			check: {
+				id: "entity-naming",
+				title: "Title and H1 coverage observed",
+				plainEnglish: `${pct$2(titlePages.length, total)}% of evaluated indexable pages have both a title and H1.`,
+				action: "Review pages missing either signal. Keep brand, product, and person names accurate wherever they appear."
+			}
+		}
+	].map(({ coverage, check }) => ({
+		...check,
+		status: "info",
+		evidence: {
+			...check.evidence,
+			observedCoveragePercent: coverage
+		}
+	}));
+	const dataStatus = report.status === "completed" && pages.length > 0 ? "complete" : "partial";
+	return {
+		reportId: report.id,
+		url: report.config.url,
+		generatedAt: report.generatedAt,
+		dataStatus,
+		evaluatedPages: pages.length,
+		crawlPages: report.pages.length,
+		assessment: "evidence-only",
+		headline: dataStatus === "partial" ? "Entity evidence is incomplete; treat these findings as scoped to the evaluated pages, not the whole site." : "Entity signals are reported as observations, not a ranking, visibility, or machine-understanding score.",
+		caveats: [
+			...report.caveats,
+			"This report deliberately has no aggregate entity score. Add schema, authors, dates, and sameAs only where they accurately fit the page and a documented use case.",
+			...dataStatus === "partial" ? [`Entity coverage is based on ${pages.length} evaluated indexable page${pages.length === 1 ? "" : "s"} from a ${report.status} crawl.`] : [],
+			...socialProfiles.length && !sameAs.length ? ["Social-domain links are unclassified navigation evidence, not proof that the linked profiles are official."] : []
+		],
+		checks,
+		entities: {
+			schemaTypes,
+			sameAs,
+			sameAsByType,
+			socialProfiles,
+			authors
+		}
+	};
+}
+//#endregion
+//#region packages/core/src/analyze/crawler/geo-gaps.ts
+const ELIGIBILITY_RULES = /* @__PURE__ */ new Set([
+	"connection_error",
+	"client_error",
+	"server_error",
+	"robots_blocked",
+	"noindex",
+	"x_robots_noindex",
+	"canonicalized_page"
+]);
+function matchingGeoGaps(report) {
+	const eligibilityIssuesByUrl = /* @__PURE__ */ new Map();
+	for (const issue of report.issues) {
+		if (!ELIGIBILITY_RULES.has(issue.ruleId)) continue;
+		const issues = eligibilityIssuesByUrl.get(issue.url) ?? [];
+		issues.push({
+			ruleId: issue.ruleId,
+			title: issue.title,
+			severity: issue.severity
+		});
+		eligibilityIssuesByUrl.set(issue.url, issues);
+	}
+	return report.pages.map((page) => {
+		const geo = page.geo ?? {
+			semanticHtml: false,
+			structuredData: false,
+			hasAuthor: false,
+			hasDate: false,
+			questionHeadings: 0,
+			structuredBlocks: 0,
+			answerable: false
+		};
+		const snippetEligibility = effectiveSnippetControl({
+			metaRobots: page.metaRobots,
+			xRobotsTag: page.xRobotsTag
+		});
+		return {
+			url: page.finalUrl,
+			issueCount: eligibilityIssuesByUrl.get(page.url)?.length ?? 0,
+			issues: eligibilityIssuesByUrl.get(page.url) ?? [],
+			searchEligibility: {
+				successfulHtmlResponse: page.status >= 200 && page.status < 300 && page.contentType?.toLowerCase().includes("text/html") === true,
+				crawlAllowed: page.robotsTxt?.allowed ?? null,
+				indexableCandidate: page.indexable,
+				declaredIndexability: page.declaredIndexability,
+				indexability: page.indexability,
+				snippetEligibility
+			},
+			observations: {
+				semanticHtml: geo.semanticHtml,
+				structuredData: geo.structuredData,
+				hasAuthor: geo.hasAuthor,
+				hasDate: geo.hasDate,
+				questionHeadings: geo.questionHeadings,
+				structuredBlocks: geo.structuredBlocks,
+				answerable: geo.answerable
+			}
+		};
+	}).filter((gap) => gap.issueCount > 0 || !gap.searchEligibility.successfulHtmlResponse || gap.searchEligibility.crawlAllowed === false || !gap.searchEligibility.indexableCandidate || gap.searchEligibility.snippetEligibility.status !== "not-restricted").sort((a, b) => b.issueCount - a.issueCount || a.url.localeCompare(b.url));
+}
+function partialReasons(report) {
+	const reasons = [];
+	if (report.pages.length === 0) reasons.push("no-pages-evaluated");
+	if (report.status !== "completed") reasons.push("crawl-not-complete");
+	if (report.requestEvidenceStatus === "partial") reasons.push("request-evidence-partial");
+	if (report.requestEvidenceStatus === "unavailable") reasons.push("request-evidence-unavailable");
+	if (report.summary.pageLimitReached) reasons.push("page-limit-reached");
+	if (report.summary.skippedUrls > 0) reasons.push("skipped-urls");
+	if (report.summary.failedRequests > 0) reasons.push("failed-requests");
+	if (report.summary.extractionFailures > 0) reasons.push("extraction-failures");
+	return reasons;
+}
+function geoGapsReport(report, filters = {}) {
+	const matches = matchingGeoGaps(report);
+	const limit = filters.limit ?? 50;
+	const eligibilityGaps = matches.slice(0, limit);
+	const reasons = partialReasons(report);
+	const truncated = eligibilityGaps.length < matches.length;
+	return {
+		schemaVersion: 1,
+		dataStatus: report.pages.length ? reasons.length ? "partial" : "complete" : "unavailable",
+		source: {
+			provider: "seo-crawl",
+			reportId: report.id,
+			definitionId: report.definitionId,
+			generatedAt: report.generatedAt,
+			startUrl: report.config.url,
+			crawlStatus: report.status,
+			requestEvidenceStatus: report.requestEvidenceStatus,
+			configuredMaxPages: report.config.maxPages,
+			pageLimitReached: report.summary.pageLimitReached,
+			discoveredUrls: report.summary.discoveredUrls,
+			queuedUrls: report.summary.queuedUrls,
+			crawledUrls: report.summary.crawledUrls,
+			skippedUrls: report.summary.skippedUrls,
+			failedRequests: report.summary.failedRequests,
+			extractionFailures: report.summary.extractionFailures,
+			partialReasons: reasons
+		},
+		selection: {
+			evaluatedPages: report.pages.length,
+			totalMatchedPages: matches.length,
+			returnedPages: eligibilityGaps.length,
+			limit,
+			truncated
+		},
+		eligibilityGaps,
+		warnings: report.warnings,
+		caveats: [
+			...report.caveats,
+			...truncated ? [`${matches.length - eligibilityGaps.length} matched pages were omitted by the output limit.`] : [],
+			"No detected restriction among evaluated pages does not prove indexing, selection, visibility, or citation."
+		]
+	};
+}
+function geoGaps(report, filters = {}) {
+	return geoGapsReport(report, filters).eligibilityGaps;
+}
+//#endregion
+//#region packages/core/src/analyze/crawler/llms.ts
+function estimatedTokens(value) {
+	return Math.ceil(value.length / 4);
+}
+function originHost(url) {
+	return new URL(url).hostname.replace(/^www\./, "");
+}
+function cleanTitle(page) {
+	return page.title ?? page.h1 ?? (new URL(page.finalUrl).pathname || page.finalUrl);
+}
+function sectionForPage(page) {
+	const path = new URL(page.finalUrl).pathname.toLowerCase();
+	if (/\/(docs|documentation|guide|guides|help|kb|learn)\b/.test(path)) return "Docs and guides";
+	if (/\/(blog|articles|news|resources)\b/.test(path)) return "Articles";
+	if (/\/(product|products|features|tools|solutions)\b/.test(path)) return "Products and tools";
+	if (/\/(pricing|plans)\b/.test(path)) return "Pricing";
+	if (/\/(about|company|team|contact)\b/.test(path)) return "Company";
+	return "Core pages";
+}
+function defaultExclude(url) {
+	return /\/(login|logout|cart|checkout|account|admin|wp-admin|search|tag|privacy|terms|cookie|legal)\b/i.test(new URL(url).pathname);
+}
+function matchesPattern$1(value, patterns = []) {
+	return patterns.some((pattern) => {
+		if (!pattern.includes("*")) return value.includes(pattern);
+		const parts = pattern.split("*");
+		let cursor = 0;
+		for (const part of parts) {
+			if (!part) continue;
+			const found = value.slice(cursor).indexOf(part);
+			if (found === -1) return false;
+			cursor += found + part.length;
+		}
+		return true;
+	});
+}
+function candidatePages(report, options = {}) {
+	return report.pages.filter((page) => page.indexable && page.status < 400).filter((page) => !defaultExclude(page.finalUrl)).filter((page) => !matchesPattern$1(page.finalUrl, options.exclude)).sort((a, b) => (b.internalLinkAuthorityScore ?? 0) - (a.internalLinkAuthorityScore ?? 0) || (b.wordCount ?? 0) - (a.wordCount ?? 0) || a.finalUrl.localeCompare(b.finalUrl));
+}
+function auditLlmsTxt(report) {
+	const llmsTxt = report.ai?.llmsTxt;
+	const pages = candidatePages(report);
+	const issues = [];
+	if (pages.length < 3) issues.push({
+		id: "thin-llms-inventory",
+		severity: "low",
+		title: "The crawl has a small llms.txt inventory",
+		plainEnglish: "There are very few indexable candidate pages to include in llms.txt.",
+		action: "If you choose to generate the optional file, run a deeper crawl or sitemap crawl first.",
+		evidence: { candidatePages: pages.length }
+	});
+	return {
+		reportId: report.id,
+		url: report.config.url,
+		exists: Boolean(llmsTxt?.exists),
+		llmsTxtUrl: llmsTxt?.url ?? new URL("/llms.txt", report.config.url).toString(),
+		status: llmsTxt?.status,
+		optional: true,
+		googleSearchImpact: "none",
+		guidanceUrl: "https://developers.google.com/search/updates#clarifying-guidance-on-llms-txt-files",
+		headline: llmsTxt?.exists ? "An optional llms.txt file is present. It has no Google Search visibility impact." : "No llms.txt file was found. This is not an SEO issue and requires no action.",
+		issues,
+		recommendedPages: pages.slice(0, 25).map((page) => ({
+			url: page.finalUrl,
+			title: page.title,
+			section: sectionForPage(page),
+			reason: (page.internalLinkAuthorityScore ?? 0) > 0 ? "High internal link authority in this crawl." : "Indexable page with useful content signals."
+		}))
+	};
+}
+function generateLlmsTxt(report, options = {}) {
+	const maxUrls = options.maxUrls ?? 250;
+	const tokenBudget = options.tokenBudget ?? 12e3;
+	const title = options.title ?? originHost(report.config.url);
+	const description = options.description ?? `Curated entry points for agents reading ${originHost(report.config.url)}.`;
+	const pages = candidatePages(report, options).slice(0, maxUrls);
+	const sections = /* @__PURE__ */ new Map();
+	for (const page of pages) {
+		const section = sectionForPage(page);
+		sections.set(section, [...sections.get(section) ?? [], page]);
+	}
+	const lines = [
+		`# ${title}`,
+		"",
+		`> ${description}`,
+		""
+	];
+	let includedUrls = 0;
+	const counts = {};
+	for (const [sectionName, sectionPages] of sections) {
+		const sectionLines = [`## ${sectionName}`, ""];
+		let sectionCount = 0;
+		for (const page of sectionPages) {
+			const title = cleanTitle(page).replace(/\]/g, "\\]");
+			const note = page.metaDescription ? ` - ${page.metaDescription.replace(/\s+/g, " ").slice(0, 160)}` : "";
+			const line = `- [${title}](${page.finalUrl})${note}`;
+			if (estimatedTokens([
+				...lines,
+				...sectionLines,
+				line,
+				""
+			].join("\n")) > tokenBudget && includedUrls > 0) break;
+			sectionLines.push(line);
+			sectionCount += 1;
+			includedUrls += 1;
+		}
+		if (!sectionCount) break;
+		sectionLines.push("");
+		lines.push(...sectionLines);
+		counts[sectionName] = sectionCount;
+		if (sectionCount < sectionPages.length) break;
+	}
+	lines.push("## Notes", "", "- Optional metadata for agents and services that explicitly support llms.txt.", "- [Google Search guidance](https://developers.google.com/search/updates#clarifying-guidance-on-llms-txt-files) says llms.txt does not affect visibility or rankings.", `- Generated from crawl report ${report.id}.`, `- Crawl generated at ${report.generatedAt}.`);
+	if (report.caveats.length) lines.push(...report.caveats.map((caveat) => `- Caveat: ${caveat}`));
+	const content = `${lines.join("\n")}\n`;
+	return {
+		content,
+		includedUrls,
+		estimatedTokens: estimatedTokens(content),
+		sections: counts
+	};
+}
+//#endregion
+//#region packages/core/src/analyze/crawler/ai-search-scorecard.ts
+const AI_SEARCH_SCORECARD_METHODOLOGY_ID = "seo-ai-search-scorecard";
+const AI_SEARCH_SCORECARD_METHODOLOGY_VERSION = 1;
+/**
+* Status credit is this tool's own heuristic weighting. It is not a Google or
+* AI-engine requirement. A `warn` earns half credit because the observed
+* evidence is mixed, not because a partial state maps to a documented rule.
+*/
+const SCORECARD_STATUS_CREDIT = {
+	pass: 1,
+	warn: .5,
+	fail: 0
+};
+/**
+* Fixed check order and per-check weights. Ordering is stable so the same crawl
+* always serializes to the same bytes. Weights sum to 100 for readability; the
+* score itself is normalized against the weight of the checks that had known
+* evidence, so unknown checks never change the denominator silently.
+*/
+const SCORECARD_CHECK_WEIGHTS = {
+	"ai-bot-access": 20,
+	https: 10,
+	"indexable-pages": 15,
+	"structured-data": 15,
+	"valid-json-ld": 10,
+	"entity-identity": 20,
+	"answerable-content": 10
+};
+const SCORECARD_CHECK_ORDER = [
+	"ai-bot-access",
+	"https",
+	"indexable-pages",
+	"structured-data",
+	"valid-json-ld",
+	"entity-identity",
+	"answerable-content"
+];
+const ENTITY_SCHEMA_PATTERN = /^(Organization|LocalBusiness|Person|Product|WebSite)$/i;
+const SITE_ENTITY_TYPE_PATTERN = /^(Organization|LocalBusiness)$/i;
+function indexablePages(report) {
+	return report.pages.filter((page) => page.indexable && page.status < 400);
+}
+function pct$1(part, total) {
+	return total > 0 ? Math.round(part / total * 100) : 0;
+}
+function sampleUrls(pages) {
+	return pages.slice(0, 10).map((page) => page.finalUrl);
+}
+function coverageStatus(covered, total, passRatio) {
+	if (total === 0) return "unknown";
+	if (covered / total >= passRatio) return "pass";
+	if (covered > 0) return "warn";
+	return "fail";
+}
+function botAccessCheck(report) {
+	const base = {
+		id: "ai-bot-access",
+		label: "AI crawler access in the start-URL robots policy",
+		weight: SCORECARD_CHECK_WEIGHTS["ai-bot-access"]
+	};
+	const robotsTxt = report.ai?.robotsTxt;
+	const startUrl = report.config.url;
+	const verification = `Fetch ${robotsTxt?.url ?? `${new URL(startUrl).origin}/robots.txt`} and confirm every Disallow rule for the listed AI crawler tokens is intentional.`;
+	if (!robotsTxt) return {
+		...base,
+		status: "unknown",
+		reason: "This crawl did not collect top-level robots.txt policy evidence for AI crawler tokens.",
+		observed: {
+			robotsEvidence: "not-collected",
+			startUrl
+		},
+		finding: "AI crawler access could not be evaluated because per-bot robots.txt evidence was not collected.",
+		verification
+	};
+	const unavailable = robotsTxt.availability === "rate-limited" || robotsTxt.availability === "unreachable" || robotsTxt.availability === "access-blocked";
+	const botAccess = robotsTxt.botAccess ?? [];
+	if (unavailable || botAccess.length === 0) return {
+		...base,
+		status: "unknown",
+		reason: unavailable ? `robots.txt was ${robotsTxt.availability}, so the AI crawler policy could not be read.` : "No AI crawler tokens were evaluated against the start-URL robots policy.",
+		observed: {
+			availability: robotsTxt.availability,
+			status: robotsTxt.status,
+			error: robotsTxt.error,
+			botAccess,
+			startUrl
+		},
+		finding: "AI crawler access is inconclusive from this crawl. Restore a readable robots.txt response and rerun before drawing a conclusion.",
+		verification
+	};
+	const blocked = botAccess.filter((bot) => bot.allowed === false);
+	const blockedUserAgents = blocked.map((bot) => bot.userAgent);
+	const status = blocked.length === 0 ? "pass" : blocked.length === botAccess.length ? "fail" : "warn";
+	const finding = status === "pass" ? "The start-URL robots policy does not block any evaluated AI crawler token. This describes policy at the entry point, not proven fetchability of every URL." : status === "fail" ? `The start-URL robots policy blocks all ${botAccess.length} evaluated AI crawler tokens. This may be intentional; confirm before treating it as a defect.` : `The start-URL robots policy blocks ${blocked.length} of ${botAccess.length} evaluated AI crawler tokens (${blockedUserAgents.join(", ")}). This may be intentional; confirm before treating it as a defect.`;
+	return {
+		...base,
+		status,
+		observed: {
+			availability: robotsTxt.availability,
+			status: robotsTxt.status,
+			evaluatedTokens: botAccess.length,
+			blockedTokens: blocked.length,
+			blockedUserAgents,
+			botAccess,
+			startUrl
+		},
+		finding,
+		verification
+	};
+}
+function httpsCheck(pages) {
+	const base = {
+		id: "https",
+		label: "Secure transport on evaluated pages",
+		weight: SCORECARD_CHECK_WEIGHTS.https
+	};
+	const verification = "Load a sample of the returned pages and confirm each is served over HTTPS with no mixed-content downgrade.";
+	if (pages.length === 0) return {
+		...base,
+		status: "unknown",
+		reason: "No indexable 2xx pages were evaluated in this crawl.",
+		observed: { evaluatedPages: 0 },
+		finding: "HTTPS coverage could not be evaluated because no indexable 2xx pages were available.",
+		verification
+	};
+	const httpsPages = pages.filter((page) => page.isHttps === true);
+	const status = coverageStatus(httpsPages.length, pages.length, 1);
+	return {
+		...base,
+		status,
+		observed: {
+			evaluatedPages: pages.length,
+			httpsPages: httpsPages.length,
+			coveragePercent: pct$1(httpsPages.length, pages.length),
+			insecureSample: sampleUrls(pages.filter((page) => page.isHttps !== true))
+		},
+		finding: status === "pass" ? "Every evaluated indexable page was served over HTTPS." : `${pct$1(httpsPages.length, pages.length)}% of evaluated indexable pages were served over HTTPS.`,
+		verification
+	};
+}
+function indexablePagesCheck(report) {
+	const base = {
+		id: "indexable-pages",
+		label: "Indexable 2xx share of crawled pages",
+		weight: SCORECARD_CHECK_WEIGHTS["indexable-pages"]
+	};
+	const verification = "Review the non-indexable crawled URLs and confirm each noindex, redirect, canonical, or error state is intended.";
+	const crawled = report.pages.length;
+	if (crawled === 0) return {
+		...base,
+		status: "unknown",
+		reason: "No pages were crawled, so indexability could not be evaluated.",
+		observed: { crawledPages: 0 },
+		finding: "Indexability could not be evaluated because no pages were crawled.",
+		verification
+	};
+	const indexable = indexablePages(report).length;
+	const status = coverageStatus(indexable, crawled, .85);
+	return {
+		...base,
+		status,
+		observed: {
+			crawledPages: crawled,
+			indexablePages: indexable,
+			coveragePercent: pct$1(indexable, crawled)
+		},
+		finding: `${pct$1(indexable, crawled)}% of crawled pages are indexable 2xx pages. Non-indexable states can be intentional; this check flags share, not intent.`,
+		verification
+	};
+}
+function structuredDataCheck(pages) {
+	const base = {
+		id: "structured-data",
+		label: "Structured-data coverage on evaluated pages",
+		weight: SCORECARD_CHECK_WEIGHTS["structured-data"]
+	};
+	const verification = "Open a sample of the pages without structured data and confirm markup exists only where it accurately represents the visible page.";
+	if (pages.length === 0) return {
+		...base,
+		status: "unknown",
+		reason: "No indexable 2xx pages were evaluated in this crawl.",
+		observed: { evaluatedPages: 0 },
+		finding: "Structured-data coverage could not be evaluated because no indexable 2xx pages were available.",
+		verification
+	};
+	const withStructuredData = pages.filter((page) => (page.structuredDataFormats?.length ?? 0) > 0 || (page.schemaTypes?.length ?? 0) > 0);
+	const status = coverageStatus(withStructuredData.length, pages.length, .5);
+	return {
+		...base,
+		status,
+		observed: {
+			evaluatedPages: pages.length,
+			pagesWithStructuredData: withStructuredData.length,
+			coveragePercent: pct$1(withStructuredData.length, pages.length),
+			missingSample: sampleUrls(pages.filter((page) => !withStructuredData.includes(page)))
+		},
+		finding: `${pct$1(withStructuredData.length, pages.length)}% of evaluated indexable pages expose structured data. Coverage is a convenience signal for agents, not a documented ranking or citation requirement.`,
+		verification
+	};
+}
+function validJsonLdCheck(report) {
+	const base = {
+		id: "valid-json-ld",
+		label: "JSON-LD parses cleanly where present",
+		weight: SCORECARD_CHECK_WEIGHTS["valid-json-ld"]
+	};
+	const verification = "Validate the flagged pages with a JSON-LD or Rich Results parser and fix any syntax errors.";
+	const jsonLdPages = report.pages.filter((page) => page.structuredDataFormats?.includes("json-ld") || (page.invalidJsonLdCount ?? 0) > 0);
+	if (jsonLdPages.length === 0) return {
+		...base,
+		status: "unknown",
+		reason: "No JSON-LD was observed, so its syntax could not be evaluated.",
+		observed: { jsonLdPages: 0 },
+		finding: "JSON-LD validity could not be evaluated because no JSON-LD was observed.",
+		verification
+	};
+	const invalidPages = jsonLdPages.filter((page) => (page.invalidJsonLdCount ?? 0) > 0);
+	const status = invalidPages.length === 0 ? "pass" : "fail";
+	return {
+		...base,
+		status,
+		observed: {
+			jsonLdPages: jsonLdPages.length,
+			invalidJsonLdPages: invalidPages.length,
+			invalidSample: sampleUrls(invalidPages)
+		},
+		finding: status === "pass" ? `JSON-LD on ${jsonLdPages.length} observed ${jsonLdPages.length === 1 ? "page" : "pages"} parsed cleanly. Clean syntax is not proof of entity recognition or rich-result eligibility.` : `${invalidPages.length} of ${jsonLdPages.length} pages with JSON-LD contain invalid JSON-LD.`,
+		verification
+	};
+}
+function entityIdentityCheck(report) {
+	const base = {
+		id: "entity-identity",
+		label: "Entity identity connected with sameAs",
+		weight: SCORECARD_CHECK_WEIGHTS["entity-identity"]
+	};
+	const verification = "Confirm the homepage and key pages carry accurate Organization, Person, or LocalBusiness schema with sameAs links to profiles you control.";
+	const entity = entityReadiness(report);
+	if (entity.evaluatedPages === 0) return {
+		...base,
+		status: "unknown",
+		reason: "No indexable 2xx pages were evaluated in this crawl.",
+		observed: { evaluatedPages: 0 },
+		finding: "Entity identity could not be evaluated because no indexable 2xx pages were available.",
+		verification
+	};
+	const hasEntitySchema = Object.keys(entity.entities.schemaTypes).some((type) => ENTITY_SCHEMA_PATTERN.test(type));
+	const siteSameAs = Object.entries(entity.entities.sameAsByType).filter(([type]) => SITE_ENTITY_TYPE_PATTERN.test(type)).flatMap(([, urls]) => urls);
+	const uniqueSiteSameAs = [...new Set(siteSameAs)].sort();
+	const status = uniqueSiteSameAs.length ? "pass" : hasEntitySchema ? "warn" : "fail";
+	return {
+		...base,
+		status,
+		observed: {
+			evaluatedPages: entity.evaluatedPages,
+			schemaTypes: entity.entities.schemaTypes,
+			siteSameAs: uniqueSiteSameAs,
+			sameAs: entity.entities.sameAs,
+			socialProfiles: entity.entities.socialProfiles
+		},
+		finding: status === "pass" ? "The crawl found sameAs links attached to Organization or LocalBusiness structured data for the site entity." : status === "warn" ? "Entity schema is present, but no Organization or LocalBusiness sameAs evidence connects the site entity to official profiles." : "No Organization, LocalBusiness, Person, Product, or WebSite schema was found on the evaluated pages.",
+		verification
+	};
+}
+function answerableContentCheck(pages) {
+	const base = {
+		id: "answerable-content",
+		label: "Substantive opening content (heuristic)",
+		weight: SCORECARD_CHECK_WEIGHTS["answerable-content"]
+	};
+	const verification = "Read a sample of the flagged pages and confirm the opening content answers the page intent for a human reader.";
+	if (pages.length === 0) return {
+		...base,
+		status: "unknown",
+		reason: "No indexable 2xx pages were evaluated in this crawl.",
+		observed: { evaluatedPages: 0 },
+		finding: "Opening-content coverage could not be evaluated because no indexable 2xx pages were available.",
+		verification
+	};
+	const answerable = pages.filter((page) => page.geo?.answerable);
+	const status = coverageStatus(answerable.length, pages.length, .5);
+	return {
+		...base,
+		status,
+		observed: {
+			evaluatedPages: pages.length,
+			answerablePages: answerable.length,
+			coveragePercent: pct$1(answerable.length, pages.length),
+			heuristic: "one-of-first-three-paragraphs-has-at-least-25-words",
+			missingSample: sampleUrls(pages.filter((page) => !page.geo?.answerable))
+		},
+		finding: `${pct$1(answerable.length, pages.length)}% of evaluated indexable pages open with at least one substantive paragraph. This is a readability heuristic, not a content-quality or citation measure.`,
+		verification
+	};
+}
+function buildObservations(report) {
+	const observations = [];
+	const llms = auditLlmsTxt(report);
+	observations.push({
+		id: "llms-txt",
+		label: "Optional llms.txt discovery file",
+		observed: {
+			exists: llms.exists,
+			url: llms.llmsTxtUrl,
+			status: llms.status,
+			googleSearchImpact: llms.googleSearchImpact
+		},
+		note: "llms.txt is optional agent-discovery metadata. Google reports no positive or negative Search impact, so presence and absence are left out of the score."
+	});
+	const agentResources = (report.ai?.agentResources ?? []).filter((resource) => resource.exists);
+	observations.push({
+		id: "agent-descriptors",
+		label: "Machine-readable agent descriptors",
+		observed: {
+			detected: agentResources.length,
+			resources: report.ai?.agentResources ?? []
+		},
+		note: "Descriptor files such as OpenAPI or agent metadata help machine discovery only when they are real. Their absence is not a search defect, so they are unscored."
+	});
+	const restricted = indexablePages(report).map((page) => ({
+		url: page.finalUrl,
+		control: effectiveSnippetControl({
+			metaRobots: page.metaRobots,
+			xRobotsTag: page.xRobotsTag
+		})
+	})).filter(({ control }) => control.status !== "not-restricted");
+	observations.push({
+		id: "snippet-controls",
+		label: "Page-level snippet directives",
+		observed: {
+			restrictedPages: restricted.length,
+			restrictions: restricted.slice(0, 10)
+		},
+		note: "Snippet directives are intentional publisher controls. They are recorded as observations, not scored, because a restriction can be deliberate."
+	});
+	return observations;
+}
+function scorecardBand(score) {
+	if (score === null) return "unscored";
+	if (score >= 80) return "strong";
+	if (score >= 50) return "moderate";
+	return "weak";
+}
+function aiSearchScorecard(report) {
+	const pages = indexablePages(report);
+	const geo = geoGapsReport(report);
+	const crawlComplete = geo.dataStatus === "complete";
+	const checksById = {
+		"ai-bot-access": botAccessCheck(report),
+		https: httpsCheck(pages),
+		"indexable-pages": indexablePagesCheck(report),
+		"structured-data": structuredDataCheck(pages),
+		"valid-json-ld": validJsonLdCheck(report),
+		"entity-identity": entityIdentityCheck(report),
+		"answerable-content": answerableContentCheck(pages)
+	};
+	const checks = SCORECARD_CHECK_ORDER.map((id) => checksById[id]);
+	const counts = {
+		pass: checks.filter((check) => check.status === "pass").length,
+		warn: checks.filter((check) => check.status === "warn").length,
+		fail: checks.filter((check) => check.status === "fail").length,
+		unknown: checks.filter((check) => check.status === "unknown").length,
+		scored: 0
+	};
+	const scoredChecks = checks.filter((check) => check.status !== "unknown");
+	counts.scored = scoredChecks.length;
+	const weightScored = scoredChecks.reduce((total, check) => total + check.weight, 0);
+	const weightTotal = checks.reduce((total, check) => total + check.weight, 0);
+	const earned = scoredChecks.reduce((total, check) => total + check.weight * SCORECARD_STATUS_CREDIT[check.status], 0);
+	let score = weightScored > 0 ? Math.round(earned / weightScored * 100) : null;
+	const partial = counts.unknown > 0 || !crawlComplete;
+	if (score === 100 && partial) score = 99;
+	const excluded = checks.filter((check) => check.status === "unknown").map((check) => ({
+		id: check.id,
+		reason: check.reason ?? "Evidence was unavailable for this check."
+	}));
+	const observations = buildObservations(report);
+	const band = scorecardBand(score);
+	const headline = score === null ? "AI search scorecard could not be scored because no check had known evidence in this crawl." : `AI search scorecard: ${score}/100, a heuristic summary of ${counts.scored} of ${checks.length} of this tool's own checks with known evidence.${partial ? ` Score is partial: ${counts.unknown} ${counts.unknown === 1 ? "check was" : "checks were"} unknown${crawlComplete ? "" : " and the crawl was incomplete"}, so a clean 100 is not possible.` : ""}`;
+	const caveats = [
+		...report.caveats,
+		"This score is a heuristic summary of this tool's own checks. It is not a Google or AI-engine requirement, an eligibility verdict, a ranking factor, or a prediction of citations, indexing, visibility, or traffic.",
+		"Only checks with known evidence are scored. Unknown checks are excluded and are never counted as failures.",
+		...crawlComplete ? [] : [`The crawl was incomplete (${geo.source.partialReasons.join(", ") || "partial evidence"}), so this score is scoped to the evaluated pages and cannot be a clean 100.`],
+		...checksById["ai-bot-access"].status === "warn" || checksById["ai-bot-access"].status === "fail" ? ["Blocking AI crawler tokens can be an intentional publisher choice. Confirm intent before treating the robots policy as a defect."] : [],
+		"llms.txt, agent descriptors, and snippet directives are recorded as observations, not scored, because their absence or presence can be intentional."
+	];
 	return {
 		reportId: report.id,
 		url: report.config.url,
 		generatedAt: report.generatedAt,
-		dataStatus,
-		assessment: "evidence-only",
-		headline: dataStatus === "partial" ? "AI-search evidence is incomplete. Fix the collection gaps before drawing site-wide conclusions." : topActions.length ? `${topActions.length} evidence-backed technical ${topActions.length === 1 ? "action remains" : "actions remain"}. Optional observations are not treated as ranking or citation factors.` : "No evidence-backed technical action was found in this crawl. This is not a visibility or citation verdict.",
-		sections,
+		methodology: {
+			id: AI_SEARCH_SCORECARD_METHODOLOGY_ID,
+			version: 1,
+			summary: "A deterministic 0-100 heuristic summary of this tool's own AI-search checks over one crawl. It is not a Google or AI-engine requirement, eligibility verdict, or ranking predictor.",
+			statusCredit: SCORECARD_STATUS_CREDIT,
+			weights: { ...SCORECARD_CHECK_WEIGHTS },
+			formula: "score = round(100 * sum(weight_i * credit(status_i)) / sum(weight_i)) over checks with a known status, where credit is pass 1, warn 0.5, fail 0. Unknown checks are excluded from both sums. A partial or incomplete crawl caps the score below 100."
+		},
+		score,
+		scoreLabel: "heuristic-check-summary",
+		maxScore: 100,
+		band,
+		partial,
+		crawlComplete,
+		counts,
+		weightScored,
+		weightTotal,
+		excluded,
 		checks,
-		topActions,
-		botAccess,
-		agentResources: report.ai?.agentResources ?? [],
-		caveats: [
-			...report.caveats,
-			"This report deliberately has no aggregate readiness score. Google documents no separate technical requirements for its generative AI Search features.",
-			"llms.txt is treated as optional agent-discovery metadata, not a Google Search ranking or visibility factor.",
-			"Paragraph length and placement are observations only. Google does not require content chunking or special answer blocks for generative AI features.",
-			"Snippet controls reflect page-level publisher directives only. No detected restriction does not guarantee selection, visibility, or a displayed snippet.",
-			...robotsTxt ? robotsUnavailable ? ["robots.txt was unavailable, so crawler access and sitemap declaration checks are inconclusive."] : !hasBotAccessEvidence ? ["robots.txt was collected without per-bot policy evidence, so the crawler-policy check is inconclusive."] : [] : ["This crawl report does not include top-level robots.txt AI bot data."],
-			"robots.txt checks describe policy for the configured start URL only. They do not verify actual crawler requests or site-wide access."
-		]
+		observations,
+		headline,
+		caveats,
+		source: {
+			provider: "seo-crawl",
+			crawlStatus: report.status,
+			requestEvidenceStatus: report.requestEvidenceStatus,
+			startUrl: report.config.url,
+			configuredMaxPages: report.config.maxPages,
+			pageLimitReached: report.summary.pageLimitReached,
+			evaluatedPages: pages.length,
+			crawledPages: report.pages.length,
+			partialReasons: geo.source.partialReasons
+		}
 	};
 }
 //#endregion
@@ -10721,133 +11501,22 @@ async function resolveTechnicalBaseline(input, dependencies = defaultDependencie
 			maxPages,
 			maxDepth
 		}));
-		if (report.status === "failed") return {
-			status: "unavailable",
-			reason: unavailableReason(report)
-		};
-		dependencies.saveCrawlReport(report);
-		return {
-			status: input.refresh ? "refreshed" : "created",
-			report,
-			...report.status === "partial" ? { reason: "The technical crawl completed with partial coverage." } : {}
-		};
-	} catch (error) {
-		return {
-			status: "unavailable",
-			reason: `The technical crawl could not run: ${error instanceof Error ? error.message : String(error)}`
-		};
-	}
-}
-//#endregion
-//#region packages/core/src/analyze/crawler/entity-readiness.ts
-function unique$3(values) {
-	return [...new Set(values.filter((value) => Boolean(value)))];
-}
-function pct$1(part, total) {
-	return total ? Math.round(part / total * 100) : 0;
-}
-function entityReadiness(report) {
-	const pages = report.pages.filter((page) => page.indexable && page.status < 400);
-	const total = pages.length || 1;
-	const schemaTypes = {};
-	for (const page of pages) for (const type of page.schemaTypes ?? []) schemaTypes[type] = (schemaTypes[type] ?? 0) + 1;
-	const entitySchemaPages = pages.filter((page) => page.schemaTypes?.some((type) => /^(Organization|LocalBusiness|Person|Product|WebSite)$/i.test(type)));
-	const sameAsEvidence = pages.flatMap((page) => page.schemaSameAsEvidence ?? []).filter((evidence) => evidence.subjectTypes.some((type) => /^(Organization|LocalBusiness|Person)$/i.test(type)));
-	const siteSameAsEvidence = sameAsEvidence.filter((evidence) => evidence.subjectTypes.some((type) => /^(Organization|LocalBusiness)$/i.test(type)));
-	const sameAs = unique$3(sameAsEvidence.map((evidence) => evidence.url));
-	const sameAsByType = {};
-	for (const evidence of sameAsEvidence) for (const type of evidence.subjectTypes) {
-		if (!/^(Organization|LocalBusiness|Person)$/i.test(type)) continue;
-		sameAsByType[type] = unique$3([...sameAsByType[type] ?? [], evidence.url]);
-	}
-	const socialProfiles = unique$3(pages.flatMap((page) => page.socialProfileLinks ?? []));
-	const authors = unique$3(pages.map((page) => page.author));
-	const authorPages = pages.filter((page) => page.author || page.geo?.hasAuthor);
-	const datePages = pages.filter((page) => page.hasDate || page.geo?.hasDate);
-	const titlePages = pages.filter((page) => page.title && page.h1);
-	const checks = [
-		{
-			coverage: pct$1(entitySchemaPages.length, total),
-			check: {
-				id: "entity-schema",
-				title: "Entity schema is present",
-				plainEnglish: `${pct$1(entitySchemaPages.length, total)}% of evaluated indexable pages include Organization, LocalBusiness, Person, Product, or WebSite schema.`,
-				action: "Add accurate entity schema to the homepage and key product, author, organization, and local pages.",
-				evidence: { schemaTypes },
-				urls: pages.filter((page) => !entitySchemaPages.includes(page)).slice(0, 10).map((page) => page.finalUrl)
-			}
-		},
-		{
-			coverage: siteSameAsEvidence.length ? 100 : 0,
-			check: {
-				id: "same-as",
-				title: "Site entity profiles are connected",
-				plainEnglish: siteSameAsEvidence.length ? "The crawl found sameAs links attached to Organization or LocalBusiness structured data." : sameAs.length ? "The crawl found Person sameAs links, but no Organization or LocalBusiness profile evidence for the site entity." : socialProfiles.length ? "The crawl found social-domain links, but they are not enough to prove official profile ownership." : "The crawl did not find entity-scoped sameAs evidence.",
-				action: "Connect official profiles with sameAs on Organization, Person, or LocalBusiness schema. Use only profiles you control.",
-				evidence: {
-					sameAs,
-					siteSameAs: unique$3(siteSameAsEvidence.map((evidence) => evidence.url)),
-					sameAsEvidence,
-					unclassifiedSocialLinks: socialProfiles
-				}
-			}
-		},
-		{
-			coverage: Math.round((pct$1(authorPages.length, total) + pct$1(datePages.length, total)) / 2),
-			check: {
-				id: "authority-freshness",
-				title: "Author and date signals observed",
-				plainEnglish: `${pct$1(authorPages.length, total)}% of evaluated indexable pages expose an author signal and ${pct$1(datePages.length, total)}% expose a date signal.`,
-				action: "For editorial content, identify authors and show accurate published or modified dates when that information is useful to readers.",
-				evidence: {
-					authorCoverage: pct$1(authorPages.length, total),
-					dateCoverage: pct$1(datePages.length, total),
-					authors
-				}
-			}
-		},
-		{
-			coverage: pct$1(titlePages.length, total),
-			check: {
-				id: "entity-naming",
-				title: "Title and H1 coverage observed",
-				plainEnglish: `${pct$1(titlePages.length, total)}% of evaluated indexable pages have both a title and H1.`,
-				action: "Review pages missing either signal. Keep brand, product, and person names accurate wherever they appear."
-			}
-		}
-	].map(({ coverage, check }) => ({
-		...check,
-		status: "info",
-		evidence: {
-			...check.evidence,
-			observedCoveragePercent: coverage
-		}
-	}));
-	const dataStatus = report.status === "completed" && pages.length > 0 ? "complete" : "partial";
-	return {
-		reportId: report.id,
-		url: report.config.url,
-		generatedAt: report.generatedAt,
-		dataStatus,
-		evaluatedPages: pages.length,
-		crawlPages: report.pages.length,
-		assessment: "evidence-only",
-		headline: dataStatus === "partial" ? "Entity evidence is incomplete; treat these findings as scoped to the evaluated pages, not the whole site." : "Entity signals are reported as observations, not a ranking, visibility, or machine-understanding score.",
-		caveats: [
-			...report.caveats,
-			"This report deliberately has no aggregate entity score. Add schema, authors, dates, and sameAs only where they accurately fit the page and a documented use case.",
-			...dataStatus === "partial" ? [`Entity coverage is based on ${pages.length} evaluated indexable page${pages.length === 1 ? "" : "s"} from a ${report.status} crawl.`] : [],
-			...socialProfiles.length && !sameAs.length ? ["Social-domain links are unclassified navigation evidence, not proof that the linked profiles are official."] : []
-		],
-		checks,
-		entities: {
-			schemaTypes,
-			sameAs,
-			sameAsByType,
-			socialProfiles,
-			authors
-		}
-	};
+		if (report.status === "failed") return {
+			status: "unavailable",
+			reason: unavailableReason(report)
+		};
+		dependencies.saveCrawlReport(report);
+		return {
+			status: input.refresh ? "refreshed" : "created",
+			report,
+			...report.status === "partial" ? { reason: "The technical crawl completed with partial coverage." } : {}
+		};
+	} catch (error) {
+		return {
+			status: "unavailable",
+			reason: `The technical crawl could not run: ${error instanceof Error ? error.message : String(error)}`
+		};
+	}
 }
 //#endregion
 //#region packages/core/src/export/diagnosis-segment-csv.ts
@@ -11881,7 +12550,7 @@ const VALUE_WEIGHT = {
 	medium: .75,
 	low: .15
 };
-function matchesPattern$1(pattern, value) {
+function matchesPattern(pattern, value) {
 	if (!pattern.includes("*")) return value.includes(pattern);
 	const parts = pattern.split("*");
 	let position = 0;
@@ -11898,7 +12567,7 @@ function filteredIssues(report, filters) {
 	return report.issues.filter((issue) => {
 		if (filters.category && issue.category !== filters.category) return false;
 		if (filters.severity && issue.severity !== filters.severity) return false;
-		if (filters.url && !matchesPattern$1(filters.url, issue.url)) return false;
+		if (filters.url && !matchesPattern(filters.url, issue.url)) return false;
 		if ((filters.recommendation ?? "fix") !== recommendationForRule(issue.ruleId)) return false;
 		return true;
 	});
@@ -12183,125 +12852,6 @@ function escapeHtml(value) {
 	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&#39;");
 }
 //#endregion
-//#region packages/core/src/analyze/crawler/geo-gaps.ts
-const ELIGIBILITY_RULES = /* @__PURE__ */ new Set([
-	"connection_error",
-	"client_error",
-	"server_error",
-	"robots_blocked",
-	"noindex",
-	"x_robots_noindex",
-	"canonicalized_page"
-]);
-function matchingGeoGaps(report) {
-	const eligibilityIssuesByUrl = /* @__PURE__ */ new Map();
-	for (const issue of report.issues) {
-		if (!ELIGIBILITY_RULES.has(issue.ruleId)) continue;
-		const issues = eligibilityIssuesByUrl.get(issue.url) ?? [];
-		issues.push({
-			ruleId: issue.ruleId,
-			title: issue.title,
-			severity: issue.severity
-		});
-		eligibilityIssuesByUrl.set(issue.url, issues);
-	}
-	return report.pages.map((page) => {
-		const geo = page.geo ?? {
-			semanticHtml: false,
-			structuredData: false,
-			hasAuthor: false,
-			hasDate: false,
-			questionHeadings: 0,
-			structuredBlocks: 0,
-			answerable: false
-		};
-		const snippetEligibility = effectiveSnippetControl({
-			metaRobots: page.metaRobots,
-			xRobotsTag: page.xRobotsTag
-		});
-		return {
-			url: page.finalUrl,
-			issueCount: eligibilityIssuesByUrl.get(page.url)?.length ?? 0,
-			issues: eligibilityIssuesByUrl.get(page.url) ?? [],
-			searchEligibility: {
-				successfulHtmlResponse: page.status >= 200 && page.status < 300 && page.contentType?.toLowerCase().includes("text/html") === true,
-				crawlAllowed: page.robotsTxt?.allowed ?? null,
-				indexableCandidate: page.indexable,
-				declaredIndexability: page.declaredIndexability,
-				indexability: page.indexability,
-				snippetEligibility
-			},
-			observations: {
-				semanticHtml: geo.semanticHtml,
-				structuredData: geo.structuredData,
-				hasAuthor: geo.hasAuthor,
-				hasDate: geo.hasDate,
-				questionHeadings: geo.questionHeadings,
-				structuredBlocks: geo.structuredBlocks,
-				answerable: geo.answerable
-			}
-		};
-	}).filter((gap) => gap.issueCount > 0 || !gap.searchEligibility.successfulHtmlResponse || gap.searchEligibility.crawlAllowed === false || !gap.searchEligibility.indexableCandidate || gap.searchEligibility.snippetEligibility.status !== "not-restricted").sort((a, b) => b.issueCount - a.issueCount || a.url.localeCompare(b.url));
-}
-function partialReasons(report) {
-	const reasons = [];
-	if (report.pages.length === 0) reasons.push("no-pages-evaluated");
-	if (report.status !== "completed") reasons.push("crawl-not-complete");
-	if (report.requestEvidenceStatus === "partial") reasons.push("request-evidence-partial");
-	if (report.requestEvidenceStatus === "unavailable") reasons.push("request-evidence-unavailable");
-	if (report.summary.pageLimitReached) reasons.push("page-limit-reached");
-	if (report.summary.skippedUrls > 0) reasons.push("skipped-urls");
-	if (report.summary.failedRequests > 0) reasons.push("failed-requests");
-	if (report.summary.extractionFailures > 0) reasons.push("extraction-failures");
-	return reasons;
-}
-function geoGapsReport(report, filters = {}) {
-	const matches = matchingGeoGaps(report);
-	const limit = filters.limit ?? 50;
-	const eligibilityGaps = matches.slice(0, limit);
-	const reasons = partialReasons(report);
-	const truncated = eligibilityGaps.length < matches.length;
-	return {
-		schemaVersion: 1,
-		dataStatus: report.pages.length ? reasons.length ? "partial" : "complete" : "unavailable",
-		source: {
-			provider: "seo-crawl",
-			reportId: report.id,
-			definitionId: report.definitionId,
-			generatedAt: report.generatedAt,
-			startUrl: report.config.url,
-			crawlStatus: report.status,
-			requestEvidenceStatus: report.requestEvidenceStatus,
-			configuredMaxPages: report.config.maxPages,
-			pageLimitReached: report.summary.pageLimitReached,
-			discoveredUrls: report.summary.discoveredUrls,
-			queuedUrls: report.summary.queuedUrls,
-			crawledUrls: report.summary.crawledUrls,
-			skippedUrls: report.summary.skippedUrls,
-			failedRequests: report.summary.failedRequests,
-			extractionFailures: report.summary.extractionFailures,
-			partialReasons: reasons
-		},
-		selection: {
-			evaluatedPages: report.pages.length,
-			totalMatchedPages: matches.length,
-			returnedPages: eligibilityGaps.length,
-			limit,
-			truncated
-		},
-		eligibilityGaps,
-		warnings: report.warnings,
-		caveats: [
-			...report.caveats,
-			...truncated ? [`${matches.length - eligibilityGaps.length} matched pages were omitted by the output limit.`] : [],
-			"No detected restriction among evaluated pages does not prove indexing, selection, visibility, or citation."
-		]
-	};
-}
-function geoGaps(report, filters = {}) {
-	return geoGapsReport(report, filters).eligibilityGaps;
-}
-//#endregion
 //#region packages/core/src/analyze/crawler/history-provenance.ts
 function snapshotCaps(report) {
 	return {
@@ -12614,129 +13164,6 @@ function compareCrawlReports(input) {
 	};
 }
 //#endregion
-//#region packages/core/src/analyze/crawler/llms.ts
-function estimatedTokens(value) {
-	return Math.ceil(value.length / 4);
-}
-function originHost(url) {
-	return new URL(url).hostname.replace(/^www\./, "");
-}
-function cleanTitle(page) {
-	return page.title ?? page.h1 ?? (new URL(page.finalUrl).pathname || page.finalUrl);
-}
-function sectionForPage(page) {
-	const path = new URL(page.finalUrl).pathname.toLowerCase();
-	if (/\/(docs|documentation|guide|guides|help|kb|learn)\b/.test(path)) return "Docs and guides";
-	if (/\/(blog|articles|news|resources)\b/.test(path)) return "Articles";
-	if (/\/(product|products|features|tools|solutions)\b/.test(path)) return "Products and tools";
-	if (/\/(pricing|plans)\b/.test(path)) return "Pricing";
-	if (/\/(about|company|team|contact)\b/.test(path)) return "Company";
-	return "Core pages";
-}
-function defaultExclude(url) {
-	return /\/(login|logout|cart|checkout|account|admin|wp-admin|search|tag|privacy|terms|cookie|legal)\b/i.test(new URL(url).pathname);
-}
-function matchesPattern(value, patterns = []) {
-	return patterns.some((pattern) => {
-		if (!pattern.includes("*")) return value.includes(pattern);
-		const parts = pattern.split("*");
-		let cursor = 0;
-		for (const part of parts) {
-			if (!part) continue;
-			const found = value.slice(cursor).indexOf(part);
-			if (found === -1) return false;
-			cursor += found + part.length;
-		}
-		return true;
-	});
-}
-function candidatePages(report, options = {}) {
-	return report.pages.filter((page) => page.indexable && page.status < 400).filter((page) => !defaultExclude(page.finalUrl)).filter((page) => !matchesPattern(page.finalUrl, options.exclude)).sort((a, b) => (b.internalLinkAuthorityScore ?? 0) - (a.internalLinkAuthorityScore ?? 0) || (b.wordCount ?? 0) - (a.wordCount ?? 0) || a.finalUrl.localeCompare(b.finalUrl));
-}
-function auditLlmsTxt(report) {
-	const llmsTxt = report.ai?.llmsTxt;
-	const pages = candidatePages(report);
-	const issues = [];
-	if (pages.length < 3) issues.push({
-		id: "thin-llms-inventory",
-		severity: "low",
-		title: "The crawl has a small llms.txt inventory",
-		plainEnglish: "There are very few indexable candidate pages to include in llms.txt.",
-		action: "If you choose to generate the optional file, run a deeper crawl or sitemap crawl first.",
-		evidence: { candidatePages: pages.length }
-	});
-	return {
-		reportId: report.id,
-		url: report.config.url,
-		exists: Boolean(llmsTxt?.exists),
-		llmsTxtUrl: llmsTxt?.url ?? new URL("/llms.txt", report.config.url).toString(),
-		status: llmsTxt?.status,
-		optional: true,
-		googleSearchImpact: "none",
-		guidanceUrl: "https://developers.google.com/search/updates#clarifying-guidance-on-llms-txt-files",
-		headline: llmsTxt?.exists ? "An optional llms.txt file is present. It has no Google Search visibility impact." : "No llms.txt file was found. This is not an SEO issue and requires no action.",
-		issues,
-		recommendedPages: pages.slice(0, 25).map((page) => ({
-			url: page.finalUrl,
-			title: page.title,
-			section: sectionForPage(page),
-			reason: (page.internalLinkAuthorityScore ?? 0) > 0 ? "High internal link authority in this crawl." : "Indexable page with useful content signals."
-		}))
-	};
-}
-function generateLlmsTxt(report, options = {}) {
-	const maxUrls = options.maxUrls ?? 250;
-	const tokenBudget = options.tokenBudget ?? 12e3;
-	const title = options.title ?? originHost(report.config.url);
-	const description = options.description ?? `Curated entry points for agents reading ${originHost(report.config.url)}.`;
-	const pages = candidatePages(report, options).slice(0, maxUrls);
-	const sections = /* @__PURE__ */ new Map();
-	for (const page of pages) {
-		const section = sectionForPage(page);
-		sections.set(section, [...sections.get(section) ?? [], page]);
-	}
-	const lines = [
-		`# ${title}`,
-		"",
-		`> ${description}`,
-		""
-	];
-	let includedUrls = 0;
-	const counts = {};
-	for (const [sectionName, sectionPages] of sections) {
-		const sectionLines = [`## ${sectionName}`, ""];
-		let sectionCount = 0;
-		for (const page of sectionPages) {
-			const title = cleanTitle(page).replace(/\]/g, "\\]");
-			const note = page.metaDescription ? ` - ${page.metaDescription.replace(/\s+/g, " ").slice(0, 160)}` : "";
-			const line = `- [${title}](${page.finalUrl})${note}`;
-			if (estimatedTokens([
-				...lines,
-				...sectionLines,
-				line,
-				""
-			].join("\n")) > tokenBudget && includedUrls > 0) break;
-			sectionLines.push(line);
-			sectionCount += 1;
-			includedUrls += 1;
-		}
-		if (!sectionCount) break;
-		sectionLines.push("");
-		lines.push(...sectionLines);
-		counts[sectionName] = sectionCount;
-		if (sectionCount < sectionPages.length) break;
-	}
-	lines.push("## Notes", "", "- Optional metadata for agents and services that explicitly support llms.txt.", "- [Google Search guidance](https://developers.google.com/search/updates#clarifying-guidance-on-llms-txt-files) says llms.txt does not affect visibility or rankings.", `- Generated from crawl report ${report.id}.`, `- Crawl generated at ${report.generatedAt}.`);
-	if (report.caveats.length) lines.push(...report.caveats.map((caveat) => `- Caveat: ${caveat}`));
-	const content = `${lines.join("\n")}\n`;
-	return {
-		content,
-		includedUrls,
-		estimatedTokens: estimatedTokens(content),
-		sections: counts
-	};
-}
-//#endregion
 //#region packages/core/src/analyze/crawler/okf.ts
 const OKF_DEFAULT_CONCEPTS = 500;
 const OKF_MAX_CONCEPTS = 5e3;
@@ -25972,6 +26399,7 @@ function deleteClient(idOrName) {
 	const client = getClient(idOrName);
 	if (!client) return false;
 	config.clients = config.clients.filter((item) => item.id !== client.id);
+	if (config.defaultSite === client.siteUrl && !config.clients.some((item) => item.siteUrl === client.siteUrl) && !config.sites.some((site) => site.siteUrl === client.siteUrl)) config.defaultSite = void 0;
 	writeConfig(config);
 	return true;
 }
@@ -26764,6 +27192,6 @@ function isoDate(daysAgo = 0) {
 //#region packages/core/src/version.ts
 const SEO_VERSION = version;
 //#endregion
-export { AI_REFERRAL_SOURCES, AI_REFERRAL_SOURCES_VERSION, AUDIT_PAGE_RULE_IDS, BROWSER_USER_AGENT, CANNIBAL_MAXIMUM_DOMINANT_SHARE, CANNIBAL_MINIMUM_PAGE_SHARE, CRAWL_REPORT_STORAGE_VERSION, CTR_DEFAULT_LIMIT, CTR_DEFAULT_MIN_IMPRESSIONS, CTR_MAX_LIMIT, CTR_MAX_MIN_IMPRESSIONS, DataForSeoProvider, GSC_FINAL_DATA_LAG_DAYS, GSC_TIME_ZONE, INTERNAL_LINK_LEXICAL_TARGET_LIMIT, INTERNAL_LINK_MATCH_EVIDENCE_LIMIT, JsonFileStorageAdapter, LocalCredentialsProvider, OKF_DEFAULT_CONCEPTS, OKF_MAX_CONCEPTS, REPORT_BASELINE_MAX_AGE_MS, REPORT_BASELINE_MAX_DEPTH, REPORT_BASELINE_MAX_PAGES, SEO_VERSION, SERP_TITLE_REFERENCE_WIDTH_PX, SERP_TITLE_WIDTH_PROFILE, SemrushProvider, SeoError, ServiceAccountAccessTokenClient, SessionLedger, affectedUrls, aiPromptsForQuery, aiReadiness, aiReferralSourceForValue, aiReferralsReport, allocateIndexUrlsToProperties, analyzeAiReferralRows, analyzeCannibalRows, analyzeCtrUnderperformersFromRows, analyzeDecay, analyzeIndexCoverageSignals, analyzeInternalLinksFromRows, analyzePageOpportunitiesFromRows, analyzeQueryClustersFromRows, analyzeQuickWinsFromRows, analyzeSecondPageRows, analyzeSegmentRows, analyzeStrikingDistanceRows, analyzeTrafficAnomalyRows, assertUrlMatchesGscProperty, attachCrawlRecommendations, auditCrawlPages, auditCrawlRequests, auditLlmsTxt, auditPage, authStatus, boundedSitemapInventory, buildOkfBundle, buildPseoAuditReportFromRows, cannibalReport, changeMeasurementCsvRows, classifyCommunityIntent, clearCache, clientProfileSchema, clusterPseoTemplates, clusterQueryRows, combineRobotsValues, communityIntentReport, compareCrawlPages, compareCrawlReports, compareSegmentRows, configSchema, contentCoverageRecommendation, contentCoverageType, contentOptimizationFromPageOpportunities, contentOptimizationReport, countLabel, crawlConfigHash, crawlConfigSchema, crawlDefinitionId, crawlDiff, crawlFixToQueueItem, crawlImplementationQueueWorkflow, crawlIssueGroupSchema, crawlIssueSchema, crawlOne, crawlPageSnapshotSchema, crawlReportSchema, crawlReportStore, crawlReportSummarySchema, crawlRequestObservationSchema, crawlRunId, crawlSite, crawlTopFixSchema, crawlerJsonSchemas, crawlerRuleCategorySchema, crawlerRuleIdSchema, crawlerRuleInfoSchema, crawlerRuleRecommendationSchema, crawlerRuleSeveritySchema, crawlerSchemas, createAuthorizedClient, createContentGroup, createCrawlReport, createCtrBenchmarkContext, createGoogleAccessTokenClient, createLogger, createPageRenderer, ctrUnderperformersReport, decayClusterDrafts, decayComparisonRange, decayingReport, deleteChange, deleteClient, deleteContentGroup, deleteCrawlReport, deleteTokens, deriveBrandTerms, detectBrandTerms, diagnoseCsvFiles, diagnoseProperty, diagnosePropertyWorkflow, effectiveRobotsDirectives, effectiveSnippetControl, ensureSeoCliDirs, entityReadiness, estimateSerpTitleWidth, expectedCtrForPosition, explainOkfValidation, explainRule, fetchCruxFieldData, fetchPage, fetchSearchStatusIncidents, fetchSitemapUrls, fileSize, finalGscDateRange, findOverlappingSearchUpdates, formatRelativeExpiry, ga4MatchReason, ga4PropertyIdFromName, ga4ReportQualityWarnings, ga4RequestCanUseCache, ga4RowsToObjects, generateLlmsTxt, geoGaps, geoGapsReport, getAuthModeStatus, getCacheStats, getChange, getClient, getClientConfig, getContentGroup, getDb, getKeywordProvider, getPreviousRun, getPrivacySnapshot, getRepeatedLinkRecoverUrls, getRunPages, getSeoCliPaths, getServiceAccountConfig, getServiceAccountStatus, getTokenStorageStatus, groupCrawlIssues, hasMetaRobotsDirective, hasRule, hasXRobotsDirective, hashKey, indexCoveragePlan, indexCoverageSignals, indexMonitor, indexWatch, inferPseoTemplate, inferTemplateMovement, insertCrawlRun, insertLinkRecoverRun, inspectUrl, internalLinksReport, interpretUpdateCorrelation, isBrandQuery, isCompatibleTechnicalBaseline, isCurrentTechnicalBaseline, isSkippableReportError, isoDate, latestCrawlReport, latestCrawlSummaries, latestFinalGscDate, latestIndexWatchSummary, latestLinkRecoverSummary, linkRecover, linkRecoverRecommendation, listChanges, listClients, listContentGroups, listCrawlReports, listGa4AccountSummaries, listGa4DataStreams, listRules, listSearchUpdates, listSites, loadCrawlReport, localCredentialsProvider, loginWithLoopback, makeRunId, matchGa4WebStreams, measureChange, measureCoverage, metaRobotsDirectives, migrateLegacyMacConfig, missingOAuthClientMessage, missingSharedClientLoginMessage, monitoringStatus, monthlyReport, monthlyReportWorkflow, narrativeCsvFiles, normalizeCrawlConfig, normalizeForCoverage, normalizeHttpUrl, normalizeJavaScriptRenderingMode, normalizeLoadedCrawlReport, okfConceptLimit, pageEvidenceRecommendation, pageOpportunitiesReport, parseOlderThan, parsePseoPath, performanceAudit, performanceReportIsCacheable, planDueIndexUrls, planIndexCoverageFromUrls, plural, propertyMatchesUrl, providerPreferenceSchema, pseoAuditOptions, pseoAuditReport, pseoCsvFiles, pseoIndexStatus, pseoPresentation, publicHttpFetch, queryClusterReport, queryClusterTokens, queryContentCoverageFromPage, queryContentFieldsFromPage, queryFieldCoverage, queryOpportunityRecommendation, queryPageMetrics, queryPageTopQuery, queryPagesMetrics, queryPagesMetricsBatch, queryPagesTopQueries, queryPagesTopQueriesBatch, querySearchAnalytics, quickWinsCsvRows, quickWinsReport, readConfig, readOauthClient, readTokens, recommendCrawlDiffItem, recommendationForRule, recordChange, redirectTrace, refreshAuthToken, refreshPrioritiesCsvFiles, refreshPrioritiesWorkflow, renderCrawlCsv, renderCrawlHtml, renderCrawlMarkdownTickets, renderCrawlPagesCsv, renderCrawlPretty, renderCsv, renderPresentationTablesMarkdown, renderPseoMarkdown, renderWorkflowMarkdown, reportNarrative, reportPresentation, requestHeaders, resolveSegmentRanges, resolveSeoCliPaths, resolveTechnicalBaseline, reviewObservations, roundedPosition, runDoctor, runGa4Report, saveClient, saveCrawlReport, secondPage, segmentComparisonRange, segmentImpact, segmentRangeDays, selectAffectedUrls, selectDueIndexUrls, seoErrorEnvelope, seoToAiQueryReport, sessionSourceInListFilter, setDefaultClient, setTokenStorageMode, shiftIsoDate, shouldExcludeBrandQuery, siteSchema, sqliteCrawlReportStore, strikingDistance, summarizeCrawlReport, pageTechnicalSignals as technicalPageSignals, technicalWatchWorkflow, templateForUrl, toSeoError, tokenSchema, topCrawlRecommendations, topFixes, trafficAnomaly, unavailableSegmentImpactReport, unicodeTokens, updateCorrelation, updatePostmortemCsvFiles, updatePostmortemWorkflow, validateOkfFiles, verifyQueryContent, workflowPresentation, writeConfig, writeOauthClient, writeTokens, xRobotsDirectives };
+export { AI_REFERRAL_SOURCES, AI_REFERRAL_SOURCES_VERSION, AI_SEARCH_SCORECARD_METHODOLOGY_ID, AI_SEARCH_SCORECARD_METHODOLOGY_VERSION, AUDIT_PAGE_RULE_IDS, BROWSER_USER_AGENT, CANNIBAL_MAXIMUM_DOMINANT_SHARE, CANNIBAL_MINIMUM_PAGE_SHARE, CRAWL_REPORT_STORAGE_VERSION, CTR_DEFAULT_LIMIT, CTR_DEFAULT_MIN_IMPRESSIONS, CTR_MAX_LIMIT, CTR_MAX_MIN_IMPRESSIONS, DataForSeoProvider, GSC_FINAL_DATA_LAG_DAYS, GSC_TIME_ZONE, INTERNAL_LINK_LEXICAL_TARGET_LIMIT, INTERNAL_LINK_MATCH_EVIDENCE_LIMIT, JsonFileStorageAdapter, LocalCredentialsProvider, OKF_DEFAULT_CONCEPTS, OKF_MAX_CONCEPTS, REPORT_BASELINE_MAX_AGE_MS, REPORT_BASELINE_MAX_DEPTH, REPORT_BASELINE_MAX_PAGES, SCORECARD_CHECK_WEIGHTS, SCORECARD_STATUS_CREDIT, SEO_VERSION, SERP_TITLE_REFERENCE_WIDTH_PX, SERP_TITLE_WIDTH_PROFILE, SemrushProvider, SeoError, ServiceAccountAccessTokenClient, SessionLedger, affectedUrls, aiPromptsForQuery, aiReadiness, aiReferralSourceForValue, aiReferralsReport, aiSearchScorecard, allocateIndexUrlsToProperties, analyzeAiReferralRows, analyzeCannibalRows, analyzeCtrUnderperformersFromRows, analyzeDecay, analyzeIndexCoverageSignals, analyzeInternalLinksFromRows, analyzePageOpportunitiesFromRows, analyzeQueryClustersFromRows, analyzeQuickWinsFromRows, analyzeSecondPageRows, analyzeSegmentRows, analyzeStrikingDistanceRows, analyzeTrafficAnomalyRows, assertUrlMatchesGscProperty, attachCrawlRecommendations, auditCrawlPages, auditCrawlRequests, auditLlmsTxt, auditPage, authStatus, boundedSitemapInventory, buildOkfBundle, buildPseoAuditReportFromRows, cannibalReport, changeMeasurementCsvRows, classifyCommunityIntent, clearCache, clientProfileSchema, clusterPseoTemplates, clusterQueryRows, combineRobotsValues, communityIntentReport, compareCrawlPages, compareCrawlReports, compareSegmentRows, configSchema, contentCoverageRecommendation, contentCoverageType, contentOptimizationFromPageOpportunities, contentOptimizationReport, countLabel, crawlConfigHash, crawlConfigSchema, crawlDefinitionId, crawlDiff, crawlFixToQueueItem, crawlImplementationQueueWorkflow, crawlIssueGroupSchema, crawlIssueSchema, crawlOne, crawlPageSnapshotSchema, crawlReportSchema, crawlReportStore, crawlReportSummarySchema, crawlRequestObservationSchema, crawlRunId, crawlSite, crawlTopFixSchema, crawlerJsonSchemas, crawlerRuleCategorySchema, crawlerRuleIdSchema, crawlerRuleInfoSchema, crawlerRuleRecommendationSchema, crawlerRuleSeveritySchema, crawlerSchemas, createAuthorizedClient, createContentGroup, createCrawlReport, createCtrBenchmarkContext, createGoogleAccessTokenClient, createLogger, createPageRenderer, ctrUnderperformersReport, decayClusterDrafts, decayComparisonRange, decayingReport, deleteChange, deleteClient, deleteContentGroup, deleteCrawlReport, deleteTokens, deriveBrandTerms, detectBrandTerms, diagnoseCsvFiles, diagnoseProperty, diagnosePropertyWorkflow, effectiveRobotsDirectives, effectiveSnippetControl, ensureSeoCliDirs, entityReadiness, estimateSerpTitleWidth, expectedCtrForPosition, explainOkfValidation, explainRule, fetchCruxFieldData, fetchPage, fetchSearchStatusIncidents, fetchSitemapUrls, fileSize, finalGscDateRange, findOverlappingSearchUpdates, formatRelativeExpiry, ga4MatchReason, ga4PropertyIdFromName, ga4ReportQualityWarnings, ga4RequestCanUseCache, ga4RowsToObjects, generateLlmsTxt, geoGaps, geoGapsReport, getAuthModeStatus, getCacheStats, getChange, getClient, getClientConfig, getContentGroup, getDb, getKeywordProvider, getPreviousRun, getPrivacySnapshot, getRepeatedLinkRecoverUrls, getRunPages, getSeoCliPaths, getServiceAccountConfig, getServiceAccountStatus, getTokenStorageStatus, groupCrawlIssues, hasMetaRobotsDirective, hasRule, hasXRobotsDirective, hashKey, indexCoveragePlan, indexCoverageSignals, indexMonitor, indexWatch, inferPseoTemplate, inferTemplateMovement, insertCrawlRun, insertLinkRecoverRun, inspectUrl, internalLinksReport, interpretUpdateCorrelation, isBrandQuery, isCompatibleTechnicalBaseline, isCurrentTechnicalBaseline, isSkippableReportError, isoDate, latestCrawlReport, latestCrawlSummaries, latestFinalGscDate, latestIndexWatchSummary, latestLinkRecoverSummary, linkRecover, linkRecoverRecommendation, listChanges, listClients, listContentGroups, listCrawlReports, listGa4AccountSummaries, listGa4DataStreams, listRules, listSearchUpdates, listSites, loadCrawlReport, localCredentialsProvider, loginWithLoopback, makeRunId, matchGa4WebStreams, measureChange, measureCoverage, metaRobotsDirectives, migrateLegacyMacConfig, missingOAuthClientMessage, missingSharedClientLoginMessage, monitoringStatus, monthlyReport, monthlyReportWorkflow, narrativeCsvFiles, normalizeCrawlConfig, normalizeForCoverage, normalizeHttpUrl, normalizeJavaScriptRenderingMode, normalizeLoadedCrawlReport, okfConceptLimit, pageEvidenceRecommendation, pageOpportunitiesReport, parseOlderThan, parsePseoPath, performanceAudit, performanceReportIsCacheable, planDueIndexUrls, planIndexCoverageFromUrls, plural, propertyMatchesUrl, providerPreferenceSchema, pseoAuditOptions, pseoAuditReport, pseoCsvFiles, pseoIndexStatus, pseoPresentation, publicHttpFetch, queryClusterReport, queryClusterTokens, queryContentCoverageFromPage, queryContentFieldsFromPage, queryFieldCoverage, queryOpportunityRecommendation, queryPageMetrics, queryPageTopQuery, queryPagesMetrics, queryPagesMetricsBatch, queryPagesTopQueries, queryPagesTopQueriesBatch, querySearchAnalytics, quickWinsCsvRows, quickWinsReport, readConfig, readOauthClient, readTokens, recommendCrawlDiffItem, recommendationForRule, recordChange, redirectTrace, refreshAuthToken, refreshPrioritiesCsvFiles, refreshPrioritiesWorkflow, renderCrawlCsv, renderCrawlHtml, renderCrawlMarkdownTickets, renderCrawlPagesCsv, renderCrawlPretty, renderCsv, renderPresentationTablesMarkdown, renderPseoMarkdown, renderWorkflowMarkdown, reportNarrative, reportPresentation, requestHeaders, resolveSegmentRanges, resolveSeoCliPaths, resolveTechnicalBaseline, reviewObservations, roundedPosition, runDoctor, runGa4Report, saveClient, saveCrawlReport, secondPage, segmentComparisonRange, segmentImpact, segmentRangeDays, selectAffectedUrls, selectDueIndexUrls, seoErrorEnvelope, seoToAiQueryReport, sessionSourceInListFilter, setDefaultClient, setTokenStorageMode, shiftIsoDate, shouldExcludeBrandQuery, siteSchema, sqliteCrawlReportStore, strikingDistance, summarizeCrawlReport, pageTechnicalSignals as technicalPageSignals, technicalWatchWorkflow, templateForUrl, toSeoError, tokenSchema, topCrawlRecommendations, topFixes, trafficAnomaly, unavailableSegmentImpactReport, unicodeTokens, updateCorrelation, updatePostmortemCsvFiles, updatePostmortemWorkflow, validateOkfFiles, verifyQueryContent, workflowPresentation, writeConfig, writeOauthClient, writeTokens, xRobotsDirectives };
 
 //# sourceMappingURL=index.js.map