@gscdump/sdk 7.12.1 → 7.13.0

package/dist/indexing/portfolio.d.mts

@@ -0,0 +1,99 @@
+import { IndexingSummaryReading, IndexingTrendReading } from "./readings.mjs";
+import { SiteIndexingIssue } from "./site-issues.mjs";
+import { IndexingReadingWindow, IndexingWindowDays } from "./window.mjs";
+export interface IndexingPortfolioSite {
+  id: string;
+  label: string;
+  trend: readonly IndexingTrendReading[];
+}
+export interface IndexingStackBucket {
+  /** First day folded into this bucket. */
+  start: string;
+  /** Last day folded into this bucket. */
+  end: string;
+}
+export interface IndexingStackSeries {
+  key: string;
+  label: string;
+  /** One value per bucket, aligned to `buckets`. */
+  values: number[];
+  isOther: boolean;
+}
+export interface IndexingStack {
+  buckets: IndexingStackBucket[];
+  series: IndexingStackSeries[];
+}
+export interface IndexingStackOptions {
+  /** Series kept by name before the rest fold into All Others. Default 5. */
+  topN?: number;
+  /** Most buckets on the axis. Default 30. */
+  maxBuckets?: number;
+}
+export interface PortfolioIssueSiteCount {
+  siteId: string;
+  label: string;
+  count: number;
+}
+/** One issue across every Site in the Portfolio, at the window end. */
+export interface PortfolioIssueRow {
+  id: string;
+  label: string;
+  count: number;
+  siteCount: number;
+  filter: SiteIndexingIssue['filter'];
+  /** Largest count first. */
+  sites: PortfolioIssueSiteCount[];
+}
+/** A Site's reading at the window end, and its indexed rate changes before it. */
+export interface IndexingWindowReading {
+  /** The trend reading its issues come from. Null when the Site has a summary and no trend. */
+  point: IndexingTrendReading | null;
+  indexed: number;
+  totalUrls: number;
+  indexedPercent: number;
+  /** Points, against the last reading on or before 7 days earlier. Null without one. */
+  change7d: number | null;
+  /** Points, against the last reading on or before 28 days earlier. Null without one. */
+  change28d: number | null;
+}
+/** One day of the Portfolio trend: every Site's held level summed. */
+export interface PortfolioIndexingTrendPoint {
+  date: string;
+  indexedPercent: number;
+  indexedCount: number;
+  /** Crawl errors: not found, soft 404, and server errors. */
+  errors: number;
+}
+/**
+ * The readings in the window, led by the held reading when one exists. A Site
+ * with no reading in the window keeps its held reading, so it holds its level
+ * across the window instead of leaving the Portfolio total.
+ */
+export declare function windowReadings<T extends Pick<IndexingTrendReading, 'date' | 'totalUrls'>>(trend: readonly T[], window: IndexingWindowDays): T[];
+/**
+ * The one reading every Site value comes from: tiles, rows, cards, popovers,
+ * export, and sort. A current window shows the Site summary, which carries the
+ * latest level and its 7 and 28 day changes. A past window shows the trend
+ * reading at its end, so it never shows today's level.
+ */
+export declare function siteIndexingReading(summary: IndexingSummaryReading | null | undefined, trend: readonly IndexingTrendReading[], window: IndexingReadingWindow): IndexingWindowReading | null;
+/** Not-indexed URLs per day, stacked by Site: the largest Sites plus All Others. */
+export declare function notIndexedStack(sites: readonly IndexingPortfolioSite[], window: IndexingWindowDays, options?: IndexingStackOptions): IndexingStack;
+/** Reported URLs per day, stacked by issue across every Site. */
+export declare function issueStack(sites: readonly IndexingPortfolioSite[], window: IndexingWindowDays, options?: IndexingStackOptions): IndexingStack;
+/** The reported issues across every Site at the window end, largest count first. */
+export declare function portfolioIssueCounts(sites: readonly IndexingPortfolioSite[], window: IndexingReadingWindow): PortfolioIssueRow[];
+/**
+ * The Portfolio trend, one point per reported day in the window. Each Site
+ * carries its last reading forward, or skipping a day would read as its URLs
+ * leaving the total. It starts from its held reading, or else holds its first
+ * reading, so joining the window does not read as a rate change. The rate is
+ * weighted by inspected URLs.
+ */
+export declare function portfolioIndexingTrend(series: readonly (readonly IndexingTrendReading[])[], window: IndexingWindowDays): PortfolioIndexingTrendPoint[];
+/** The Portfolio rate change between the latest day and the day `days` before it, in points. */
+export declare function portfolioRateChangeOver(trend: readonly PortfolioIndexingTrendPoint[], days: number): number | null;
+/** The rate change from the first to the last point, in points. Null below two points. */
+export declare function indexedRateChange(trend: ReadonlyArray<{
+  indexedPercent: number;
+}>): number | null;

package/dist/indexing/portfolio.mjs

@@ -0,0 +1,206 @@
+import { clampIndexedPercent, crawlErrorCount, notIndexedCount } from "./readings.mjs";
+import { getSiteIndexingIssues } from "./site-issues.mjs";
+import { readingDatesInWindow } from "./window.mjs";
+const DEFAULT_TOP_N = 5;
+const DEFAULT_MAX_BUCKETS = 30;
+const OTHER_KEY = "__other";
+const OTHER_LABEL = "All Others";
+const DAY_MS = 864e5;
+function byDate(a, b) {
+	return a.date.localeCompare(b.date);
+}
+function daysBefore(date, days) {
+	return (/* @__PURE__ */ new Date(Date.parse(`${date}T00:00:00Z`) - days * DAY_MS)).toISOString().slice(0, 10);
+}
+function windowReadings(trend, window) {
+	const readings = trend.filter((point) => point.totalUrls > 0 && point.date <= window.end).toSorted(byDate);
+	const start = readings.findIndex((point) => point.date >= window.start);
+	if (start < 0) return readings.slice(-1);
+	return readings.slice(Math.max(0, start - 1));
+}
+function readingAtWindowEnd(trend, window) {
+	const point = windowReadings(trend, window).at(-1);
+	if (!point) return null;
+	const readings = trend.filter((reading) => reading.totalUrls > 0);
+	function changeOver(days) {
+		const target = daysBefore(point.date, days);
+		const base = readings.filter((reading) => reading.date <= target).toSorted(byDate).at(-1);
+		return base ? Math.round((point.indexedPercent - base.indexedPercent) * 10) / 10 : null;
+	}
+	return {
+		point,
+		indexed: point.indexedCount,
+		totalUrls: point.totalUrls,
+		indexedPercent: point.indexedPercent,
+		change7d: changeOver(7),
+		change28d: changeOver(28)
+	};
+}
+function windowEndPoint(trend, window) {
+	if (!window.current) return readingAtWindowEnd(trend, window)?.point ?? null;
+	return trend.toSorted(byDate).at(-1) ?? null;
+}
+function siteIndexingReading(summary, trend, window) {
+	if (!window.current) return readingAtWindowEnd(trend, window);
+	if (!summary || summary.totalUrls <= 0) return null;
+	return {
+		point: windowEndPoint(trend, window),
+		indexed: summary.indexed,
+		totalUrls: summary.totalUrls,
+		indexedPercent: summary.indexedPercent,
+		change7d: summary.change7d ?? null,
+		change28d: summary.change28d ?? null
+	};
+}
+function bucketAxis(dates, maxBuckets) {
+	const size = Math.max(1, Math.ceil(dates.length / maxBuckets));
+	const out = [];
+	for (let start = 0; start < dates.length; start += size) {
+		const last = Math.min(start + size, dates.length) - 1;
+		out.push({
+			bucket: {
+				start: dates[start],
+				end: dates[last]
+			},
+			last
+		});
+	}
+	return out;
+}
+function stackLevels(dates, levels, options) {
+	const topN = options.topN ?? DEFAULT_TOP_N;
+	const present = levels.filter((series) => series.levels.some((level) => level > 0));
+	if (!dates.length || !present.length) return {
+		buckets: [],
+		series: []
+	};
+	const ranked = [...present].sort((a, b) => (b.levels.at(-1) ?? 0) - (a.levels.at(-1) ?? 0));
+	const axis = bucketAxis(dates, options.maxBuckets ?? DEFAULT_MAX_BUCKETS);
+	const pick = (series) => axis.map(({ last }) => series.levels[last] ?? 0);
+	const kept = ranked.length === topN + 1 ? ranked.length : topN;
+	const series = ranked.slice(0, kept).map((entry) => ({
+		key: entry.key,
+		label: entry.label,
+		values: pick(entry),
+		isOther: false
+	}));
+	const rest = ranked.slice(kept);
+	if (rest.length) series.push({
+		key: OTHER_KEY,
+		label: OTHER_LABEL,
+		values: axis.map(({ last }) => rest.reduce((sum, entry) => sum + (entry.levels[last] ?? 0), 0)),
+		isOther: true
+	});
+	return {
+		buckets: axis.map(({ bucket }) => bucket),
+		series
+	};
+}
+function carryForward(points, dates, read) {
+	let next = 0;
+	let level = points[0] ? read(points[0]) : 0;
+	return dates.map((date) => {
+		while (next < points.length && points[next].date <= date) {
+			level = read(points[next]);
+			next++;
+		}
+		return level;
+	});
+}
+function notIndexedStack(sites, window, options = {}) {
+	const inWindow = sites.map((site) => ({
+		site,
+		points: windowReadings(site.trend, window)
+	}));
+	const dates = readingDatesInWindow(inWindow.map((entry) => entry.points), window);
+	return stackLevels(dates, inWindow.map(({ site, points }) => ({
+		key: site.id,
+		label: site.label,
+		levels: carryForward(points, dates, notIndexedCount)
+	})), options);
+}
+function issueStack(sites, window, options = {}) {
+	const inWindow = sites.map((site) => windowReadings(site.trend, window));
+	const dates = readingDatesInWindow(inWindow, window);
+	const byIssue = /* @__PURE__ */ new Map();
+	for (const points of inWindow) {
+		const issuesByDate = new Map(points.map((point) => [point.date, getSiteIndexingIssues(point)]));
+		const issues = [...issuesByDate.values()].flat();
+		for (const id of new Set(issues.map((issue) => issue.id))) {
+			const levels = carryForward(points, dates, (point) => issuesByDate.get(point.date)?.find((issue) => issue.id === id)?.count ?? 0);
+			const label = issues.find((issue) => issue.id === id).label;
+			const entry = byIssue.get(id);
+			if (entry) entry.levels = entry.levels.map((level, index) => level + (levels[index] ?? 0));
+			else byIssue.set(id, {
+				key: id,
+				label,
+				levels
+			});
+		}
+	}
+	return stackLevels(dates, [...byIssue.values()], options);
+}
+function portfolioIssueCounts(sites, window) {
+	const rows = /* @__PURE__ */ new Map();
+	for (const site of sites) for (const issue of getSiteIndexingIssues(windowEndPoint(site.trend, window))) {
+		const row = rows.get(issue.id) ?? {
+			id: issue.id,
+			label: issue.label,
+			count: 0,
+			siteCount: 0,
+			filter: issue.filter,
+			sites: []
+		};
+		row.count += issue.count;
+		row.siteCount += 1;
+		row.sites.push({
+			siteId: site.id,
+			label: site.label,
+			count: issue.count
+		});
+		rows.set(issue.id, row);
+	}
+	return Array.from(rows.values(), (row) => ({
+		...row,
+		sites: row.sites.toSorted((a, b) => b.count - a.count)
+	})).sort((a, b) => b.count - a.count);
+}
+function portfolioIndexingTrend(series, window) {
+	const inWindow = series.map((trend) => windowReadings(trend, window));
+	const dates = readingDatesInWindow(inWindow, window);
+	const days = new Map(dates.map((date) => [date, {
+		totalUrls: 0,
+		indexedCount: 0,
+		errors: 0
+	}]));
+	for (const trend of inWindow) {
+		let next = 0;
+		let latest = trend[0];
+		for (const date of dates) {
+			while (next < trend.length && trend[next].date <= date) latest = trend[next++];
+			if (!latest) continue;
+			const day = days.get(date);
+			day.totalUrls += latest.totalUrls;
+			day.indexedCount += latest.indexedCount ?? 0;
+			day.errors += crawlErrorCount(latest);
+		}
+	}
+	return Array.from(days, ([date, day]) => ({
+		date,
+		indexedPercent: day.totalUrls > 0 ? clampIndexedPercent(day.indexedCount / day.totalUrls * 100) : 0,
+		indexedCount: day.indexedCount,
+		errors: day.errors
+	})).sort(byDate);
+}
+function portfolioRateChangeOver(trend, days) {
+	const last = trend.at(-1);
+	if (!last) return null;
+	const target = daysBefore(last.date, days);
+	const base = trend.findLast((point) => point.date <= target);
+	return base ? last.indexedPercent - base.indexedPercent : null;
+}
+function indexedRateChange(trend) {
+	if (trend.length < 2) return null;
+	return trend.at(-1).indexedPercent - trend[0].indexedPercent;
+}
+export { indexedRateChange, issueStack, notIndexedStack, portfolioIndexingTrend, portfolioIssueCounts, portfolioRateChangeOver, siteIndexingReading, windowReadings };

package/dist/indexing/readings.d.mts

@@ -0,0 +1,42 @@
+import { GscdumpIndexingResponse, GscdumpIndexingTrendPoint } from "@gscdump/contracts";
+type IssueKey = 'notFound' | 'soft404' | 'serverError' | 'blockedByRobots';
+type CoverageKey = 'crawledNotIndexed' | 'discoveredNotCrawled';
+type SignalKey = 'richResultsPass' | 'richResultsFail';
+/**
+ * One day of a Site's indexing trend, with no null counts and a rate within
+ * 0 to 100. The field names are those of `GscdumpIndexingTrendPoint`.
+ */
+export interface IndexingTrendReading {
+  /** `YYYY-MM-DD`. */
+  date: GscdumpIndexingTrendPoint['date'];
+  totalUrls: number;
+  indexedCount: number;
+  /** 0 to 100. */
+  indexedPercent: number;
+  issues?: { [Key in IssueKey]?: number; };
+  /** Google's "knows about it and chose not to index it" counts. */
+  coverage?: { [Key in CoverageKey]?: number; };
+  signals?: { [Key in SignalKey]?: number; };
+}
+/** A Site's latest indexing summary, with its rate changes in points. */
+export interface IndexingSummaryReading {
+  indexed: number;
+  totalUrls: number;
+  /** 0 to 100. */
+  indexedPercent: number;
+  change7d?: number | null;
+  change28d?: number | null;
+}
+export interface SiteIndexingReadings {
+  summary: IndexingSummaryReading;
+  /** Oldest first, as the hosted read returns it. */
+  trend: IndexingTrendReading[];
+}
+/** Clamp an index rate to 0 to 100. */
+export declare function clampIndexedPercent(value: number): number;
+/** Parse one hosted Site indexing read into the readings every portfolio function takes. */
+export declare function readSiteIndexing(response: Pick<GscdumpIndexingResponse, 'summary' | 'trend'>): SiteIndexingReadings;
+/** Inspected URLs that are not indexed on this day. Never negative. */
+export declare function notIndexedCount(point: Pick<IndexingTrendReading, 'indexedCount' | 'totalUrls'>): number;
+/** Crawl errors on one reading: not found, soft 404, and server errors. */
+export declare function crawlErrorCount(point: Pick<IndexingTrendReading, 'issues'>): number;

package/dist/indexing/readings.mjs

@@ -0,0 +1,47 @@
+function clampIndexedPercent(value) {
+	return Math.max(0, Math.min(100, value));
+}
+function count(value) {
+	return value ?? void 0;
+}
+function readSiteIndexing(response) {
+	return {
+		summary: {
+			indexed: response.summary.indexed,
+			totalUrls: response.summary.totalUrls,
+			indexedPercent: clampIndexedPercent(response.summary.indexedPercent),
+			change7d: response.summary.change7d,
+			change28d: response.summary.change28d
+		},
+		trend: response.trend.map((point) => {
+			const indexedPercent = clampIndexedPercent(point.indexedPercent);
+			return {
+				date: point.date,
+				indexedPercent,
+				indexedCount: point.indexedCount ?? Math.round(point.totalUrls * indexedPercent / 100),
+				totalUrls: point.totalUrls,
+				issues: {
+					notFound: count(point.issues.notFound),
+					soft404: count(point.issues.soft404),
+					serverError: count(point.issues.serverError),
+					blockedByRobots: count(point.issues.blockedByRobots)
+				},
+				coverage: {
+					crawledNotIndexed: count(point.coverage?.crawledNotIndexed),
+					discoveredNotCrawled: count(point.coverage?.discoveredNotCrawled)
+				},
+				signals: {
+					richResultsPass: count(point.signals.richResultsPass),
+					richResultsFail: count(point.signals.richResultsFail)
+				}
+			};
+		})
+	};
+}
+function notIndexedCount(point) {
+	return Math.max(0, point.totalUrls - (point.indexedCount ?? 0));
+}
+function crawlErrorCount(point) {
+	return (point.issues?.notFound ?? 0) + (point.issues?.soft404 ?? 0) + (point.issues?.serverError ?? 0);
+}
+export { clampIndexedPercent, crawlErrorCount, notIndexedCount, readSiteIndexing };

package/dist/indexing/regression-lead.d.mts

@@ -0,0 +1,22 @@
+import { IndexCohortCell } from "./cohorts.mjs";
+import { PartnerIndexingTransitionsV1Response } from "@gscdump/contracts/v1/http";
+/** One recorded transition, as the hosted transitions read returns it. */
+export type IndexingTransitionRow = Pick<PartnerIndexingTransitionsV1Response['data']['transitions'][number], 'url' | 'fromValue' | 'toValue' | 'changedAfter' | 'changedBefore'> & {
+  /** One of `GSCDUMP_INDEXING_TRANSITION_FIELDS`. Only `indexStatus` rows count. */
+  field: string;
+};
+export type IndexingRegressionLead = {
+  _tag: 'lead';
+  /** Distinct URLs whose verdict changed away from PASS. */
+  count: number;
+  title: string;
+  detail: string;
+  /** The earliest `changedAfter`, as ISO. */
+  start: string;
+  /** The latest `changedBefore`, as ISO. */
+  end: string;
+} | {
+  _tag: 'none';
+  reason: 'cohort-has-no-path' | 'no-index-regression';
+};
+export declare function selectIndexingRegressionLead(cohort: Pick<IndexCohortCell, 'label' | 'pathPrefix'>, transitions: readonly IndexingTransitionRow[]): IndexingRegressionLead;

package/dist/indexing/regression-lead.mjs

@@ -0,0 +1,48 @@
+function pathBelongsTo(path, prefix) {
+	return path === prefix || path.startsWith(`${prefix.replace(/\/$/, "")}/`);
+}
+function transitionTime(value) {
+	const time = Date.parse(value);
+	return Number.isFinite(time) ? time : null;
+}
+const transitionDateFormat = new Intl.DateTimeFormat("en-AU", {
+	day: "numeric",
+	month: "short",
+	timeZone: "UTC",
+	year: "numeric"
+});
+function selectIndexingRegressionLead(cohort, transitions) {
+	const prefix = cohort.pathPrefix;
+	if (!prefix) return {
+		_tag: "none",
+		reason: "cohort-has-no-path"
+	};
+	const regressions = transitions.flatMap((transition) => {
+		if (transition.field !== "indexStatus" || transition.fromValue !== "PASS" || transition.toValue === "PASS" || !URL.canParse(transition.url)) return [];
+		const start = transitionTime(transition.changedAfter);
+		const end = transitionTime(transition.changedBefore);
+		if (start === null || end === null || end < start) return [];
+		if (!pathBelongsTo(new URL(transition.url).pathname, prefix)) return [];
+		return [{
+			...transition,
+			end,
+			start
+		}];
+	});
+	if (!regressions.length) return {
+		_tag: "none",
+		reason: "no-index-regression"
+	};
+	const count = new Set(regressions.map((transition) => transition.url)).size;
+	const first = regressions.reduce((earliest, transition) => transition.start < earliest.start ? transition : earliest);
+	const last = regressions.reduce((latest, transition) => transition.end > latest.end ? transition : latest);
+	return {
+		_tag: "lead",
+		count,
+		detail: "URL Inspection samples bound the change window; they do not identify the exact drop time.",
+		end: last.changedBefore,
+		start: first.changedAfter,
+		title: `Google dropped ${count.toLocaleString("en-US")} ${count === 1 ? "page" : "pages"} in ${cohort.label} between ${transitionDateFormat.format(new Date(first.changedAfter))} and ${transitionDateFormat.format(new Date(last.changedBefore))}.`
+	};
+}
+export { selectIndexingRegressionLead };

package/dist/indexing/site-issues.d.mts

@@ -0,0 +1,15 @@
+import { IndexingTrendReading } from "./readings.mjs";
+export type SiteIndexingIssuePoint = Pick<IndexingTrendReading, 'issues' | 'coverage' | 'signals'>;
+export interface SiteIndexingIssue {
+  /** Kebab-case row id, such as `crawled-not-indexed`. */
+  id: string;
+  label: string;
+  count: number;
+  /** The URLs list filter that shows this row's URLs. */
+  filter: {
+    key: 'issue' | 'facet';
+    value: string;
+  };
+}
+/** The positive-count issue rows of one reading: failures first, then larger counts. */
+export declare function getSiteIndexingIssues(point: SiteIndexingIssuePoint | null | undefined): SiteIndexingIssue[];

package/dist/indexing/site-issues.mjs

@@ -0,0 +1,85 @@
+const ISSUE_SPECS = [
+	{
+		id: "server-error",
+		label: "Server error",
+		rank: 0,
+		pick: (p) => p.issues?.serverError,
+		filter: {
+			key: "issue",
+			value: "server_error"
+		}
+	},
+	{
+		id: "not-found",
+		label: "Not found",
+		rank: 0,
+		pick: (p) => p.issues?.notFound,
+		filter: {
+			key: "issue",
+			value: "not_found"
+		}
+	},
+	{
+		id: "soft-404",
+		label: "Soft 404",
+		rank: 0,
+		pick: (p) => p.issues?.soft404,
+		filter: {
+			key: "issue",
+			value: "soft_404"
+		}
+	},
+	{
+		id: "crawled-not-indexed",
+		label: "Crawled, not indexed",
+		rank: 0,
+		pick: (p) => p.coverage?.crawledNotIndexed,
+		filter: {
+			key: "issue",
+			value: "crawled_not_indexed"
+		}
+	},
+	{
+		id: "discovered-not-indexed",
+		label: "Discovered, not crawled",
+		rank: 1,
+		pick: (p) => p.coverage?.discoveredNotCrawled,
+		filter: {
+			key: "issue",
+			value: "discovered_not_indexed"
+		}
+	},
+	{
+		id: "blocked-robots",
+		label: "Blocked by robots.txt",
+		rank: 1,
+		pick: (p) => p.issues?.blockedByRobots,
+		filter: {
+			key: "issue",
+			value: "blocked_robots"
+		}
+	},
+	{
+		id: "rich-results",
+		label: "Rich result errors",
+		rank: 1,
+		pick: (p) => p.signals?.richResultsFail,
+		filter: {
+			key: "facet",
+			value: "rich_results"
+		}
+	}
+];
+function getSiteIndexingIssues(point) {
+	if (!point) return [];
+	return ISSUE_SPECS.map((spec) => ({
+		...spec,
+		count: spec.pick(point) ?? 0
+	})).filter((issue) => issue.count > 0).sort((a, b) => a.rank - b.rank || b.count - a.count).map(({ id, label, count, filter }) => ({
+		id,
+		label,
+		count,
+		filter
+	}));
+}
+export { getSiteIndexingIssues };

package/dist/indexing/trust-gate.d.mts

@@ -0,0 +1,63 @@
+import { CurrentSitemapScope, SitemapCollapseState } from "@gscdump/analysis/sitemap-health";
+export type TrustGateState = 'ok' | 'unknown' | 'blip' | 'broken' | 'no_sitemap' | 'not_connected' | 'pending';
+export interface TrustGate {
+  state: TrustGateState;
+  /** One plain sentence naming the state. */
+  reason: string;
+}
+/** States where the figures are degraded, so a panel shows its diagnosis variant. */
+export declare const TRUST_DEGRADED_STATES: ReadonlySet<TrustGateState>;
+export declare function isTrustDegraded(state: TrustGateState): boolean;
+/** Search Console downloads a healthy sitemap well within a week. Older than this is stale. */
+export declare const STALE_DOWNLOAD_DAYS = 7;
+/** One live sitemap probe result. */
+export interface SitemapLivenessCheck {
+  /** `timeout`: the probe aborted. `error`: a non-2xx response or a network failure. */
+  status: 'reachable' | 'timeout' | 'error';
+  /** The HTTP status when a response came back. */
+  statusCode?: number | null;
+}
+/** One day of a Site's sitemap URL count. */
+export interface SitemapCountPoint {
+  /** `YYYY-MM-DD` or an ISO timestamp. Only the order matters. */
+  date: string;
+  urlCount: number | null | undefined;
+}
+/** Did the sitemap URL count ever drop below 20% of an earlier peak? */
+export declare function sitemapHistoryCollapsed(history: readonly SitemapCountPoint[]): boolean;
+/**
+ * Compare the latest sitemap count with the earlier high-water mark. The calm
+ * state guard of the Indexing overview, distinct from the history check above,
+ * which corroborates probe failures.
+ */
+declare function compareCurrentSitemapScope$1(history: readonly SitemapCountPoint[]): CurrentSitemapScope | null;
+/**
+ * Classify only the latest large sitemap drop. A new drop waits for another
+ * count, two low counts in a row persist, and an immediate recovery is a blip.
+ */
+export declare function classifyCurrentSitemapDrop(history: readonly SitemapCountPoint[]): SitemapCollapseState;
+export interface TrustGateInput {
+  /** Search Console is connected for this Site. */
+  connected: boolean;
+  /**
+   * The URL Inspection sample size, never the sitemap total. 0 means Google has
+   * inspected nothing yet. `totalUrls` is the fallback when this is absent.
+   */
+  inspectedCount: number | null;
+  totalUrls: number | null;
+  /** The hosted indexing meta status: `pending`, `partial`, or `complete`. */
+  indexingStatus: string | null;
+  /** Search Console reports a submitted sitemap it has not parsed yet. */
+  sitemapsPending: boolean;
+  /** Search Console reports no submitted sitemap. */
+  noSitemapsSubmitted: boolean;
+  /** The live probe. Null when it has not run or is unavailable. */
+  liveness: SitemapLivenessCheck | null;
+  /** The latest Search Console sitemap download, as ISO. Null if never downloaded. */
+  lastDownloadedAt: string | null;
+  /** A sitemap collapse in the window. Corroboration for `broken`. */
+  sitemapCollapsed: boolean;
+  now: Date;
+}
+export declare function computeTrustGate(input: TrustGateInput): TrustGate;
+export { type CurrentSitemapScope, type SitemapCollapseState, compareCurrentSitemapScope$1 as compareCurrentSitemapScope };