@gscdump/sdk 1.0.1 → 1.0.3

package/dist/search-console-stage.mjs

@@ -0,0 +1,292 @@
+import { countSearchConsoleIssues, formatSearchConsoleCount } from "./_chunks/search-console-signals.mjs";
+import { siteTypeBaseline } from "./site-baseline.mjs";
+function totalSitemapErrors(sitemaps) {
+	return (sitemaps ?? []).reduce((sum, sitemap) => {
+		return sum + (sitemap.errors ?? 0) + (sitemap.lastError ? 1 : 0);
+	}, 0);
+}
+function signedPct1(value) {
+	return `${value >= 0 ? "+" : ""}${value.toFixed(1)}%`;
+}
+const SEARCH_CONSOLE_STAGES = {
+	not_connected: {
+		label: "Not connected",
+		severity: "neutral",
+		summary: "Search Console is not connected for this site yet.",
+		primaryAction: "Connect Google Search Console so we can read discovery, indexing, and performance data.",
+		nextStage: "waiting_for_data",
+		sprintFindingTypes: []
+	},
+	waiting_for_data: {
+		label: "Waiting for data",
+		severity: "info",
+		summary: "Search Console is connected, but there is not enough indexing data to diagnose the site yet.",
+		primaryAction: "Let the first sync finish, then make sure a sitemap is submitted.",
+		nextStage: "weak_discovery",
+		sprintFindingTypes: []
+	},
+	weak_discovery: {
+		label: "Weak discovery",
+		severity: "warning",
+		summary: "Google does not have a clean map of the pages you want indexed.",
+		primaryAction: "Submit a clean sitemap that contains only canonical, indexable 200 URLs.",
+		nextStage: "discovery_backlog",
+		sprintFindingTypes: ["search-console-stage", "sitemap-missing"]
+	},
+	discovery_backlog: {
+		label: "Discovery backlog",
+		severity: "warning",
+		summary: "Google knows these pages exist, but is not crawling them fast enough.",
+		primaryAction: "Add internal links from indexed pages and remove low-value URLs from the sitemap.",
+		nextStage: "crawl_blocked",
+		sprintFindingTypes: ["search-console-stage"]
+	},
+	crawl_blocked: {
+		label: "Crawl blocked",
+		severity: "error",
+		summary: "Google is trying to access pages, but technical access problems are blocking progress.",
+		primaryAction: "Fix robots.txt blocks, server errors, broken URLs, and access failures before content work.",
+		nextStage: "indexability_blocked",
+		sprintFindingTypes: ["search-console-stage", "noindex-block"]
+	},
+	indexability_blocked: {
+		label: "Indexability blocked",
+		severity: "error",
+		summary: "Google can reach pages, but index directives or canonical signals are preventing clean indexing.",
+		primaryAction: "Remove accidental noindex directives and make canonical signals agree.",
+		nextStage: "index_rejection",
+		sprintFindingTypes: [
+			"search-console-stage",
+			"noindex-block",
+			"canonicalisation"
+		]
+	},
+	index_rejection: {
+		label: "Index rejection",
+		severity: "warning",
+		summary: "Google is crawling pages but skipping too many of them from the index.",
+		primaryAction: "Improve or consolidate crawled-but-not-indexed pages before publishing more.",
+		nextStage: "partially_indexed",
+		sprintFindingTypes: ["search-console-stage", "pages-not-indexed"]
+	},
+	partially_indexed: {
+		label: "Partially indexed",
+		severity: "warning",
+		summary: "A meaningful share of the site is indexed, but coverage is still below a healthy level.",
+		primaryAction: "Work through the largest remaining indexing blocker first.",
+		nextStage: "indexed_invisible",
+		sprintFindingTypes: ["search-console-stage", "pages-not-indexed"]
+	},
+	indexed_invisible: {
+		label: "Indexed but invisible",
+		severity: "warning",
+		summary: "Pages are indexed, but too many are not earning impressions in Search.",
+		primaryAction: "Improve query targeting, titles, headings, internal links, and page depth.",
+		nextStage: "visible_not_clicked",
+		sprintFindingTypes: ["search-console-stage"]
+	},
+	visible_not_clicked: {
+		label: "Visible but not clicked",
+		severity: "warning",
+		summary: "Google is showing your pages, but searchers are not clicking often enough.",
+		primaryAction: "Rewrite titles and descriptions for the queries already producing impressions.",
+		nextStage: "ranking_stalled",
+		sprintFindingTypes: ["search-console-stage", "ctr-outliers"]
+	},
+	ranking_stalled: {
+		label: "Ranking but stalled",
+		severity: "info",
+		summary: "The site has search visibility, but many pages are not yet ranking in useful positions.",
+		primaryAction: "Prioritise striking-distance pages, refresh content, and add internal links.",
+		nextStage: "healthy_growth_ready",
+		sprintFindingTypes: ["striking-distance", "internal-linking"]
+	},
+	declining_visibility: {
+		label: "Declining visibility",
+		severity: "error",
+		summary: "Search visibility is dropping compared with the previous period.",
+		primaryAction: "Review affected pages, recent releases, competitors, and SERP changes before expanding.",
+		nextStage: "healthy_growth_ready",
+		sprintFindingTypes: ["search-console-stage", "negative-movers"]
+	},
+	healthy_growth_ready: {
+		label: "Healthy",
+		severity: "success",
+		summary: "Google can discover, index, and show your pages.",
+		primaryAction: "Push striking-distance pages (positions 11 to 20) and close content gaps to grow impressions.",
+		nextStage: null,
+		sprintFindingTypes: ["striking-distance", "competitor-content-gap"]
+	}
+};
+function stage(key, evidence) {
+	const definition = SEARCH_CONSOLE_STAGES[key];
+	return {
+		key,
+		evidence,
+		...definition,
+		sprintFindingTypes: [...definition.sprintFindingTypes]
+	};
+}
+const ESTABLISHED_IMPRESSIONS_28D = 2e4;
+const NASCENT_IMPRESSIONS_28D = 1e3;
+const GROWTH_CLICKS_PCT_90D = 10;
+const GROWTH_IMPRESSIONS_PCT_90D = 20;
+const DECLINE_CLICKS_PCT = -10;
+const MIN_DECLINE_PRIOR_CLICKS = 50;
+function classifySearchConsoleStage(input) {
+	const issues = input.issues ?? [];
+	const summary = input.summary ?? null;
+	const sitemaps = input.sitemaps ?? [];
+	const totalUrls = summary?.totalUrls ?? 0;
+	const indexed = summary?.indexed ?? 0;
+	const indexedPercent = summary?.indexedPercent ?? 0;
+	const notIndexed = Math.max(0, totalUrls - indexed);
+	if (!input.connected) return stage("not_connected", [{
+		label: "Connection",
+		value: "Not connected",
+		source: "connection"
+	}]);
+	if (input.indexingStatus === "pending" || !summary || totalUrls === 0) return stage("waiting_for_data", [{
+		label: "Indexing sync",
+		value: input.indexingStatus === "pending" ? "Pending" : "No URLs yet",
+		source: "indexing"
+	}]);
+	const sitemapErrors = totalSitemapErrors(sitemaps);
+	const unknown = countSearchConsoleIssues(issues, "unknown_to_google");
+	const discovered = countSearchConsoleIssues(issues, "discovered_not_indexed");
+	const crawled = countSearchConsoleIssues(issues, "crawled_not_indexed");
+	const hardBlocks = countSearchConsoleIssues(issues, "blocked_robots", "server_error", "access_denied", "forbidden") + (input.crawlAuditBlockerCount ?? 0);
+	const canonicalMismatches = Math.min(notIndexed, input.canonicalMismatchCount ?? countSearchConsoleIssues(issues, "canonical_mismatch"));
+	let visibleNoClickPages = 0;
+	let poorPositionPages = 0;
+	for (const page of input.pageInventory ?? []) {
+		if (page.impressions < 50) continue;
+		if (page.clicks === 0) visibleNoClickPages++;
+		if ((page.position ?? 0) > 20) poorPositionPages++;
+	}
+	const ctrOutlierCount = input.ctrOutlierCount ?? 0;
+	const traj = input.trajectory ?? null;
+	const impressions28d = input.impressions28d ?? null;
+	const clicks90d = traj?.clicksPct90d ?? null;
+	const imp90d = traj?.impressionsPct90d ?? null;
+	const posDelta90d = traj?.positionDelta90d ?? null;
+	const clicks28d = traj?.clicksPct28d ?? null;
+	const clicksPrior28d = traj?.clicksPrior28d ?? null;
+	const isGrowing = clicks90d != null && clicks90d > GROWTH_CLICKS_PCT_90D || imp90d != null && imp90d > GROWTH_IMPRESSIONS_PCT_90D && posDelta90d != null && posDelta90d < 0;
+	const isDeclining = clicks90d != null && clicks90d < DECLINE_CLICKS_PCT && clicks28d != null && clicks28d < DECLINE_CLICKS_PCT && clicksPrior28d != null && clicksPrior28d >= MIN_DECLINE_PRIOR_CLICKS;
+	const isNascent = impressions28d != null && impressions28d < NASCENT_IMPRESSIONS_28D;
+	const isEstablished = impressions28d != null && impressions28d >= ESTABLISHED_IMPRESSIONS_28D;
+	if (hardBlocks > Math.max(10, totalUrls * .05)) return stage("crawl_blocked", [{
+		label: "Crawl / on-page faults",
+		value: formatSearchConsoleCount(hardBlocks),
+		source: "indexing"
+	}, {
+		label: "Indexed pages",
+		value: `${formatSearchConsoleCount(indexed)} of ${formatSearchConsoleCount(totalUrls)}`,
+		source: "indexing"
+	}]);
+	if (isDeclining) return stage("declining_visibility", [{
+		label: "Clicks 90d",
+		value: `${clicks90d.toFixed(1)}%`,
+		source: "performance"
+	}, {
+		label: "Clicks 28d",
+		value: `${clicks28d.toFixed(1)}%`,
+		source: "performance"
+	}]);
+	if (isGrowing) return stage("healthy_growth_ready", [
+		...hardBlocks > 0 ? [{
+			label: "Critical blockers",
+			value: formatSearchConsoleCount(hardBlocks),
+			source: "indexing"
+		}] : [],
+		...clicks90d != null ? [{
+			label: "Clicks 90d",
+			value: signedPct1(clicks90d),
+			source: "performance"
+		}] : [],
+		...imp90d != null ? [{
+			label: "Impressions 90d",
+			value: signedPct1(imp90d),
+			source: "performance"
+		}] : [],
+		...(input.recoverableBacklinkCount ?? 0) > 0 ? [{
+			label: "Recoverable backlinks",
+			value: formatSearchConsoleCount(input.recoverableBacklinkCount),
+			source: "performance"
+		}] : [],
+		...(input.competitorGapCount ?? 0) > 0 ? [{
+			label: "Competitor content gaps",
+			value: formatSearchConsoleCount(input.competitorGapCount),
+			source: "performance"
+		}] : []
+	]);
+	if (crawled > Math.max(10, totalUrls * .3) && totalUrls > 500) return stage("index_rejection", [{
+		label: "Crawled, not indexed",
+		value: formatSearchConsoleCount(crawled),
+		source: "indexing"
+	}, {
+		label: "Not indexed",
+		value: formatSearchConsoleCount(notIndexed),
+		source: "indexing"
+	}]);
+	if (isNascent) return stage("waiting_for_data", [{
+		label: "Impressions (28d)",
+		value: formatSearchConsoleCount(impressions28d ?? 0),
+		source: "performance"
+	}, {
+		label: "Indexed pages",
+		value: `${formatSearchConsoleCount(indexed)} of ${formatSearchConsoleCount(totalUrls)}`,
+		source: "indexing"
+	}]);
+	if (!isEstablished && (sitemaps.length === 0 || sitemapErrors > 0 || unknown > Math.max(5, totalUrls * .1))) return stage("weak_discovery", [{
+		label: "Sitemaps",
+		value: sitemaps.length === 0 ? "None registered" : `${formatSearchConsoleCount(sitemapErrors)} errors`,
+		source: "sitemap"
+	}, ...unknown > 0 ? [{
+		label: "Unknown URLs",
+		value: formatSearchConsoleCount(unknown),
+		source: "indexing"
+	}] : []]);
+	if (discovered > Math.max(10, totalUrls * .15)) return stage("discovery_backlog", [{
+		label: "Discovered, not crawled",
+		value: formatSearchConsoleCount(discovered),
+		source: "indexing"
+	}, {
+		label: "Indexed pages",
+		value: `${indexedPercent.toFixed(1)}%`,
+		source: "indexing"
+	}]);
+	if (canonicalMismatches > Math.max(5, totalUrls * .05)) return stage("indexability_blocked", [{
+		label: "Canonical mismatches",
+		value: formatSearchConsoleCount(canonicalMismatches),
+		source: "canonical"
+	}]);
+	const lowCtrType = siteTypeBaseline(input.siteType).ctrExpectation === "low";
+	const noClickShare = lowCtrType ? .5 : .25;
+	const noClickTrigger = visibleNoClickPages >= Math.max(1, (input.pageInventory?.length ?? 0) * noClickShare);
+	if (ctrOutlierCount > 0 && !lowCtrType || noClickTrigger) return stage("visible_not_clicked", [...ctrOutlierCount > 0 ? [{
+		label: "CTR outliers",
+		value: formatSearchConsoleCount(ctrOutlierCount),
+		source: "performance"
+	}] : [], ...visibleNoClickPages > 0 ? [{
+		label: "Visible, no clicks",
+		value: formatSearchConsoleCount(visibleNoClickPages),
+		source: "performance"
+	}] : []]);
+	if (poorPositionPages >= Math.max(1, (input.pageInventory?.length ?? 0) * .25)) return stage("ranking_stalled", [{
+		label: "Low-ranking visible pages",
+		value: formatSearchConsoleCount(poorPositionPages),
+		source: "performance"
+	}]);
+	return stage("healthy_growth_ready", [{
+		label: "Indexed",
+		value: `${indexedPercent.toFixed(1)}%`,
+		source: "indexing"
+	}, {
+		label: "Critical blockers",
+		value: formatSearchConsoleCount(hardBlocks),
+		source: "indexing"
+	}]);
+}
+export { classifySearchConsoleStage };

package/dist/site-baseline.d.mts

@@ -0,0 +1,69 @@
+type SiteType = 'saas' | 'ecommerce' | 'docs' | 'blog' | 'agency' | 'portfolio' | 'other';
+/**
+ * Normalise the AI profile `type` to the closed enum. The categoriser mostly
+ * emits the 7 values but occasionally leaks free-text (e.g. "event") or null
+ * (~40% of live sites are unprofiled) — everything unknown collapses to `other`
+ * so downstream logic always has a defined bucket.
+ */
+declare function normalizeSiteType(raw: string | null | undefined): SiteType;
+interface SiteTypeBaseline {
+  label: string;
+  /**
+   * Whether indexed-coverage% is a meaningful health signal for this type.
+   * docs/blog/portfolio accumulate intentional low-value pages (tags, versions,
+   * pagination, archives) so coverage% is noise; ecommerce/saas/agency care.
+   */
+  coverageMatters: boolean;
+  /**
+   * Typical click-through at good positions. Informational types (docs/blog)
+   * earn structurally lower CTR (answer shown in SERP, multi-page research), so
+   * a low CTR is NOT a defect — the classifier raises the visible-not-clicked
+   * bar for these.
+   */
+  ctrExpectation: 'low' | 'medium' | 'high';
+  /** The default growth lever when the site is healthy and leading. */
+  primaryGoal: 'content' | 'authority' | 'conversion' | 'coverage';
+}
+declare const SITE_TYPE_BASELINE: Record<SiteType, SiteTypeBaseline>;
+declare function siteTypeBaseline(raw: string | null | undefined): SiteTypeBaseline;
+type PeerStanding = 'leader' | 'on_par' | 'behind' | 'unknown';
+/** How much to trust the standing: a median over 1–2 peers is noisy. */
+type PeerConfidence = 'high' | 'low' | 'none';
+/**
+ * Peer metrics from tracked competitors (`siteCompetitors`). Domain rank is the
+ * DataForSEO-derived 0–100 score (`min(100, log10(keywordCount)*20)`), NOT a
+ * true authority metric — good enough for relative standing within a peer set.
+ * The site's OWN metrics are not stored alongside competitors, so callers must
+ * supply them (one cheap cached `estimateDomainTraffic` call).
+ */
+interface PeerBaselineInput {
+  siteDomainRank?: number | null;
+  siteOrganicTraffic?: number | null;
+  competitorDomainRanks?: number[] | null;
+  competitorOrganicTraffic?: number[] | null;
+}
+interface SiteBaseline {
+  siteType: SiteType;
+  baseline: SiteTypeBaseline;
+  peerStanding: PeerStanding;
+  peerConfidence: PeerConfidence;
+  peerMedianDomainRank: number | null;
+  peerMedianOrganicTraffic: number | null;
+  /** Human-facing goal headline combining type + standing. */
+  recommendedGoal: string;
+  goalKind: SiteTypeBaseline['primaryGoal'];
+}
+/** Standing is decided on domain rank first; organic traffic breaks the tie. */
+declare function derivePeerStanding(input: PeerBaselineInput): {
+  standing: PeerStanding;
+  confidence: PeerConfidence;
+  peerMedianDomainRank: number | null;
+  peerMedianOrganicTraffic: number | null;
+};
+/**
+ * Combine the site type with its peer standing into a relative goal. A leader
+ * defends and expands on its type's lever; a site that's behind closes the gap
+ * on the same lever; unknown standing falls back to the type default.
+ */
+declare function deriveSiteBaseline(rawType: string | null | undefined, peer?: PeerBaselineInput): SiteBaseline;
+export { PeerBaselineInput, PeerConfidence, PeerStanding, SITE_TYPE_BASELINE, SiteBaseline, SiteType, SiteTypeBaseline, derivePeerStanding, deriveSiteBaseline, normalizeSiteType, siteTypeBaseline };

package/dist/site-baseline.mjs

@@ -0,0 +1,112 @@
+const KNOWN_SITE_TYPES = /* @__PURE__ */ new Set([
+	"saas",
+	"ecommerce",
+	"docs",
+	"blog",
+	"agency",
+	"portfolio",
+	"other"
+]);
+function normalizeSiteType(raw) {
+	if (!raw) return "other";
+	const t = raw.toLowerCase().trim();
+	return KNOWN_SITE_TYPES.has(t) ? t : "other";
+}
+const SITE_TYPE_BASELINE = {
+	docs: {
+		label: "Documentation",
+		coverageMatters: false,
+		ctrExpectation: "low",
+		primaryGoal: "content"
+	},
+	blog: {
+		label: "Blog / content",
+		coverageMatters: false,
+		ctrExpectation: "low",
+		primaryGoal: "content"
+	},
+	portfolio: {
+		label: "Portfolio",
+		coverageMatters: false,
+		ctrExpectation: "low",
+		primaryGoal: "content"
+	},
+	saas: {
+		label: "SaaS",
+		coverageMatters: true,
+		ctrExpectation: "medium",
+		primaryGoal: "authority"
+	},
+	agency: {
+		label: "Agency",
+		coverageMatters: true,
+		ctrExpectation: "medium",
+		primaryGoal: "authority"
+	},
+	ecommerce: {
+		label: "Ecommerce",
+		coverageMatters: true,
+		ctrExpectation: "high",
+		primaryGoal: "coverage"
+	},
+	other: {
+		label: "General",
+		coverageMatters: true,
+		ctrExpectation: "medium",
+		primaryGoal: "content"
+	}
+};
+function siteTypeBaseline(raw) {
+	return SITE_TYPE_BASELINE[normalizeSiteType(raw)];
+}
+const MIN_CONFIDENT_PEERS = 3;
+const LEADER_RATIO = 1.15;
+const BEHIND_RATIO = .85;
+function median(values) {
+	if (!values || values.length === 0) return null;
+	const xs = [...values].sort((a, b) => a - b);
+	const mid = Math.floor(xs.length / 2);
+	return xs.length % 2 ? xs[mid] : (xs[mid - 1] + xs[mid]) / 2;
+}
+function derivePeerStanding(input) {
+	const peerMedianDomainRank = median(input.competitorDomainRanks);
+	const peerMedianOrganicTraffic = median(input.competitorOrganicTraffic);
+	const peerCount = Math.max(input.competitorDomainRanks?.length ?? 0, input.competitorOrganicTraffic?.length ?? 0);
+	const confidence = peerCount === 0 ? "none" : peerCount >= MIN_CONFIDENT_PEERS ? "high" : "low";
+	const compare = (site, peer) => {
+		if (site == null || peer == null || peer === 0) return null;
+		const ratio = site / peer;
+		if (ratio >= LEADER_RATIO) return "leader";
+		if (ratio <= BEHIND_RATIO) return "behind";
+		return "on_par";
+	};
+	return {
+		standing: compare(input.siteDomainRank, peerMedianDomainRank) ?? compare(input.siteOrganicTraffic, peerMedianOrganicTraffic) ?? "unknown",
+		confidence,
+		peerMedianDomainRank,
+		peerMedianOrganicTraffic
+	};
+}
+const GOAL_HEADLINE = {
+	content: "publish & expand content",
+	authority: "build authority & backlinks",
+	conversion: "lift conversion & CTR",
+	coverage: "expand indexable catalogue"
+};
+function deriveSiteBaseline(rawType, peer = {}) {
+	const siteType = normalizeSiteType(rawType);
+	const baseline = SITE_TYPE_BASELINE[siteType];
+	const { standing, confidence, peerMedianDomainRank, peerMedianOrganicTraffic } = derivePeerStanding(peer);
+	const lever = GOAL_HEADLINE[baseline.primaryGoal];
+	return {
+		siteType,
+		baseline,
+		peerStanding: standing,
+		peerConfidence: confidence,
+		peerMedianDomainRank,
+		peerMedianOrganicTraffic,
+		recommendedGoal: standing === "behind" ? `Close the gap on peers — ${lever}` : standing === "leader" ? `Defend the lead — ${lever}` : standing === "on_par" ? `Pull ahead of peers — ${lever}` : `${baseline.label}: ${lever}`,
+		goalKind: baseline.primaryGoal
+	};
+}
+export { SITE_TYPE_BASELINE, derivePeerStanding, deriveSiteBaseline, normalizeSiteType, siteTypeBaseline };

package/dist/site-triage.d.mts

@@ -0,0 +1,86 @@
+import { SearchConsoleStageIssue } from "./search-console-stage.mjs";
+type ReachStage = 'waiting_for_data' | 'emerging' | 'growing' | 'plateaued' | 'declining' | 'faded' | 'decayed';
+type HealthStage = 'healthy' | 'crawl_faults' | 'quality_rejection';
+interface TriageEvidence {
+  label: string;
+  value: string;
+}
+/**
+ * Distance-to-next-stage for one axis, so the UI never re-derives thresholds.
+ *
+ * `direction`:
+ *  - `advance` — up-path rung (waiting → emerging → growing). `pct` = value/target.
+ *  - `escape`  — off-ramp recovery (declining/faded/decayed) or a held health gate
+ *    (crawl_faults/quality_rejection). `pct` = inverse distance: closer to passing ⇒ higher.
+ *  - `sustain` — already good (growing/healthy). `nextStage` null, `pct` 1, framed as momentum.
+ *
+ * `gapLabel` is always a concrete count (pages/clicks/points), never a bare %.
+ */
+interface StageProgression {
+  nextStage: ReachStage | HealthStage | null;
+  metric: string;
+  value: number;
+  target: number;
+  pct: number;
+  gapLabel: string;
+  direction: 'advance' | 'escape' | 'sustain';
+}
+interface ReachVerdict {
+  stage: ReachStage;
+  summary: string;
+  primaryAction: string;
+  evidence: TriageEvidence[];
+  progression: StageProgression;
+}
+interface HealthVerdict {
+  stage: HealthStage;
+  summary: string;
+  primaryAction: string;
+  evidence: TriageEvidence[];
+  progression: StageProgression;
+}
+interface SiteTriage {
+  reach: ReachVerdict;
+  health: HealthVerdict;
+  /** Which axis leads the dashboard headline. */
+  headline: 'reach' | 'health';
+}
+interface SiteTriageInput {
+  connected: boolean;
+  /** Impressions over the trailing 28 days — the maturity tier. */
+  impressions28d?: number | null;
+  /** Lifetime-ish impressions (trailing 12 months) — separates new from decayed/faded. */
+  impressions12m?: number | null;
+  /** Absolute clicks over the trailing 28 days — for the clicks≪impressions decay tell. */
+  clicks28d?: number | null;
+  clicksPct90d?: number | null;
+  clicksPct28d?: number | null;
+  /** Absolute prior-28d clicks — gates decline so a % crash on trivial traffic isn't a false decline. */
+  clicksPrior28d?: number | null;
+  impressionsPct90d?: number | null;
+  positionDelta90d?: number | null;
+  /** Latest complete week ÷ 90d peak week (lag-trimmed). <0.2 = faded (spike→died). */
+  livenessRatio?: number | null;
+  totalUrls?: number | null;
+  indexed?: number | null;
+  issues?: SearchConsoleStageIssue[] | null;
+  /** Real on-page faults from the crawl audit: 5xx, broken internal links/images. Excludes intentional noindex/404. */
+  crawlAuditBlockerCount?: number | null;
+  /** AI profile type — drives purpose-expected subtraction. */
+  siteType?: string | null;
+}
+/**
+ * Reach liveness: latest complete week ÷ peak rolling-7d week over a daily
+ * impressions series (typically the trailing 90 days). `<0.2` means recent
+ * impressions have collapsed versus the site's own peak (spike→died) — the
+ * signal a period-vs-prior delta cannot see. Trailing zero-impression days
+ * (GSC reporting lag) are trimmed before the latest-week sum. Returns null when
+ * the series is too short to judge.
+ */
+declare function reachLivenessRatio(daily: Array<{
+  impressions: number;
+}> | null | undefined): number | null;
+declare function classifyHealthStage(input: SiteTriageInput): HealthVerdict;
+declare function classifyReachStage(input: SiteTriageInput): ReachVerdict;
+declare function classifySiteTriage(input: SiteTriageInput): SiteTriage;
+export { HealthStage, HealthVerdict, ReachStage, ReachVerdict, SiteTriage, SiteTriageInput, StageProgression, TriageEvidence, classifyHealthStage, classifyReachStage, classifySiteTriage, reachLivenessRatio };