@gscdump/sdk 0.22.4 → 0.23.1

package/dist/index.mjs

@@ -1,5 +1,8 @@
+import { query_exports } from "./query.mjs";
 import { CANONICAL_WEBHOOK_EVENTS, VALID_WEBHOOK_EVENTS, WEBHOOK_CONTRACT_VERSION, WEBHOOK_CONTRACT_VERSION_HEADER, WEBHOOK_CONTRACT_VERSION_HEADER as WEBHOOK_CONTRACT_VERSION_HEADER$1, WEBHOOK_DELIVERY_HEADER, WEBHOOK_DELIVERY_HEADER as WEBHOOK_DELIVERY_HEADER$1, WEBHOOK_EVENT_HEADER, WEBHOOK_EVENT_HEADER as WEBHOOK_EVENT_HEADER$1, WEBHOOK_SIGNATURE_HEADER, WEBHOOK_SIGNATURE_HEADER as WEBHOOK_SIGNATURE_HEADER$1, WEBHOOK_TIMESTAMP_HEADER, WEBHOOK_TIMESTAMP_HEADER as WEBHOOK_TIMESTAMP_HEADER$1, analyticsRoutes, partnerEndpointSchemas, partnerRoutes, partnerWebhookEnvelopeSchema } from "@gscdump/contracts";
 import { ofetch } from "ofetch";
+import { resolveWindow } from "@gscdump/engine/period";
+import { endOfMonth, format, startOfMonth, startOfQuarter, startOfWeek, subDays, subMonths } from "date-fns";
 export * from "@gscdump/contracts";
 var PartnerApiError = class extends Error {
 	kind;
@@ -200,6 +203,20 @@ function createAnalyticsClient(options = {}) {
 		}
 	};
 }
+function defineGscAnalyzer(def) {
+	return def;
+}
+function weightedAnonPct(days, window = 28) {
+	if (!days?.length) return null;
+	const trailing = days.slice(-window);
+	let totalImpressions = 0;
+	let weighted = 0;
+	for (const d of trailing) {
+		totalImpressions += d.impressions;
+		weighted += d.impressions * d.anonymizedImpressionsPct;
+	}
+	return totalImpressions > 0 ? weighted / totalImpressions : null;
+}
 const ARCHETYPE_EXECUTION_CLASS = {
 	"site-daily-timeseries": "r2-sql",
 	"entity-daily-timeseries": "r2-sql-resolved",
@@ -693,6 +710,645 @@ function createPartnerClient(options = {}) {
 	};
 }
 const createGscdumpClient = createPartnerClient;
+const COUNTRY_NAMES = {
+	US: "United States",
+	GB: "United Kingdom",
+	DE: "Germany",
+	FR: "France",
+	CA: "Canada",
+	AU: "Australia",
+	IN: "India",
+	BR: "Brazil",
+	JP: "Japan",
+	IT: "Italy",
+	ES: "Spain",
+	NL: "Netherlands",
+	SE: "Sweden",
+	CH: "Switzerland",
+	MX: "Mexico",
+	KR: "South Korea",
+	RU: "Russia",
+	PL: "Poland",
+	BE: "Belgium",
+	AT: "Austria",
+	NO: "Norway",
+	DK: "Denmark",
+	FI: "Finland",
+	PT: "Portugal",
+	IE: "Ireland",
+	NZ: "New Zealand",
+	SG: "Singapore",
+	HK: "Hong Kong",
+	TW: "Taiwan",
+	IL: "Israel",
+	ZA: "South Africa",
+	AR: "Argentina",
+	CL: "Chile",
+	CO: "Colombia",
+	TH: "Thailand",
+	PH: "Philippines",
+	MY: "Malaysia",
+	ID: "Indonesia",
+	VN: "Vietnam",
+	TR: "Turkey",
+	CZ: "Czech Republic",
+	RO: "Romania",
+	HU: "Hungary",
+	GR: "Greece",
+	UA: "Ukraine",
+	EG: "Egypt",
+	NG: "Nigeria",
+	KE: "Kenya",
+	PK: "Pakistan",
+	BD: "Bangladesh",
+	AE: "United Arab Emirates",
+	SA: "Saudi Arabia"
+};
+const countryName = (code) => COUNTRY_NAMES[code] || code;
+const CWV_GOOD_LCP = 2500;
+const CWV_POOR_LCP = 4e3;
+const CWV_GOOD_INP = 200;
+const CWV_POOR_INP = 500;
+const CWV_GOOD_CLS = .1;
+const CWV_POOR_CLS = .25;
+function cwvBucket(metric, v) {
+	if (metric === "lcp") return v <= 2500 ? "good" : v <= 4e3 ? "ni" : "poor";
+	if (metric === "inp") return v <= 200 ? "good" : v <= 500 ? "ni" : "poor";
+	return v <= .1 ? "good" : v <= .25 ? "ni" : "poor";
+}
+function truncateQuery(q, max = 48) {
+	return q.length > max ? `${q.slice(0, max - 1)}…` : q;
+}
+function siteUrlToHostname(url) {
+	if (!url) return void 0;
+	try {
+		return new URL(url.startsWith("http") ? url : `https://${url}`).hostname;
+	} catch {
+		return;
+	}
+}
+function splitOpportunityTitle(title) {
+	return title.split(/("[^"]+")/g).filter(Boolean).map((part) => ({
+		text: part.startsWith("\"") && part.endsWith("\"") ? part.slice(1, -1) : part,
+		highlight: part.startsWith("\"") && part.endsWith("\"")
+	}));
+}
+function gscConsoleUrl(opts) {
+	const base = "https://search.google.com/search-console";
+	const resource = opts.resource ?? "performance";
+	const params = new URLSearchParams();
+	const siteLabel = /^(?:https?:|sc-domain:)/.test(opts.siteLabel) ? opts.siteLabel : `sc-domain:${opts.siteLabel}`;
+	params.set("resource_id", siteLabel);
+	if (resource === "url-inspection") {
+		if (opts.page) params.set("id", opts.page);
+	} else {
+		if (opts.page) params.set("page", `*${opts.page}`);
+		if (opts.query) params.set("query", `*${opts.query}`);
+	}
+	return `${base}${resource === "performance" ? "/performance/search-analytics" : resource === "url-inspection" ? "/inspect" : resource === "sitemaps" ? "/sitemaps" : "/index"}?${params.toString()}`;
+}
+const GSC_STABLE_LATENCY_DAYS = 3;
+function classifyGscError(e) {
+	const code = e?.statusCode ?? e?.status;
+	const message = extractMessage(e);
+	if (code === 401 || code === 403) return {
+		status: "auth-missing",
+		code,
+		message
+	};
+	if (code === 429) {
+		const retry = e?.data?.retryAfter;
+		return {
+			status: "rate-limited",
+			code,
+			message,
+			retryAfter: typeof retry === "number" ? retry : void 0
+		};
+	}
+	if (code == null && !isAbort(e)) return {
+		status: "network",
+		message
+	};
+	return {
+		status: "error",
+		code,
+		message
+	};
+}
+function extractMessage(e) {
+	if (!e || typeof e !== "object") return void 0;
+	const data = e.data;
+	if (data && typeof data === "object") {
+		const m = data.message ?? data.error;
+		if (typeof m === "string") return m;
+	}
+	const m = e.message;
+	return typeof m === "string" ? m : void 0;
+}
+function isAbort(e) {
+	return e?.name === "AbortError";
+}
+function dateFilter(r) {
+	return {
+		type: "between",
+		column: "date",
+		from: r.start,
+		to: r.end
+	};
+}
+function andFilter(...filters) {
+	return {
+		type: "and",
+		filters: filters.filter((f) => f != null)
+	};
+}
+const PERIOD_PRESETS = [
+	{
+		value: "7d",
+		label: "Last 7 days",
+		shortLabel: "7d",
+		group: "rolling"
+	},
+	{
+		value: "28d",
+		label: "Last 28 days",
+		shortLabel: "28d",
+		group: "rolling"
+	},
+	{
+		value: "3m",
+		label: "Last 3 months",
+		shortLabel: "3m",
+		group: "rolling"
+	},
+	{
+		value: "6m",
+		label: "Last 6 months",
+		shortLabel: "6m",
+		group: "rolling"
+	},
+	{
+		value: "12m",
+		label: "Last 12 months",
+		shortLabel: "12m",
+		group: "rolling"
+	},
+	{
+		value: "this-week",
+		label: "This week",
+		shortLabel: "Week",
+		group: "calendar"
+	},
+	{
+		value: "this-month",
+		label: "This month",
+		shortLabel: "Month",
+		group: "calendar"
+	},
+	{
+		value: "last-month",
+		label: "Last month",
+		shortLabel: "Last mo",
+		group: "calendar"
+	},
+	{
+		value: "this-quarter",
+		label: "This quarter",
+		shortLabel: "Qtr",
+		group: "calendar"
+	},
+	{
+		value: "this-year",
+		label: "This year",
+		shortLabel: "Year",
+		group: "calendar"
+	}
+];
+const COMPARE_OPTIONS = [
+	{
+		value: "previous",
+		label: "Previous period",
+		description: "Compare to the period immediately before"
+	},
+	{
+		value: "year",
+		label: "Year over year",
+		description: "Compare to the same period last year"
+	},
+	{
+		value: "none",
+		label: "No comparison",
+		description: "Disable comparison"
+	}
+];
+const GSC_PERIOD_OPTIONS = PERIOD_PRESETS.filter((p) => p.group === "rolling").map((p) => ({
+	label: p.shortLabel,
+	value: p.value,
+	longLabel: p.label
+}));
+const GSC_PERIOD_OPTIONS_LONG = GSC_PERIOD_OPTIONS.map((o) => ({
+	label: o.longLabel,
+	value: o.value
+}));
+const GSC_COLUMN_OPTIONS = [
+	{
+		key: "clicks",
+		label: "Clicks",
+		icon: "i-lucide-mouse-pointer-click",
+		color: "blue"
+	},
+	{
+		key: "impressions",
+		label: "Views",
+		icon: "i-lucide-eye",
+		color: "purple"
+	},
+	{
+		key: "ctr",
+		label: "CTR",
+		icon: "i-lucide-percent",
+		color: "green"
+	},
+	{
+		key: "position",
+		label: "Pos",
+		icon: "i-lucide-hash",
+		color: "orange"
+	}
+];
+function coerceRowMetrics(row) {
+	return {
+		...row,
+		sum_position: row.sum_position ?? (row.position ?? 0) * row.impressions
+	};
+}
+function summarizeDailyRows(raw) {
+	const daily = raw.map(coerceRowMetrics).map((r) => ({
+		date: r.date,
+		clicks: r.clicks,
+		impressions: r.impressions,
+		sum_position: r.sum_position
+	})).sort((a, b) => a.date.localeCompare(b.date));
+	let clicks = 0;
+	let impressions = 0;
+	let weightedPosition = 0;
+	for (const d of daily) {
+		clicks += d.clicks;
+		impressions += d.impressions;
+		weightedPosition += d.sum_position;
+	}
+	return {
+		daily,
+		totals: {
+			clicks,
+			impressions,
+			ctr: impressions > 0 ? clicks / impressions : 0,
+			position: impressions > 0 ? weightedPosition / impressions + 1 : 0
+		},
+		chartData: daily.map((d) => ({
+			date: d.date,
+			clicks: d.clicks,
+			impressions: d.impressions
+		}))
+	};
+}
+function positionFor(r) {
+	return r.impressions > 0 ? r.sum_position / r.impressions + 1 : 0;
+}
+const issueDetails = {
+	crawled_not_indexed: {
+		description: "Google crawled these pages but decided not to add them to the index. This often means the content was deemed low-quality, duplicate, or not useful enough.",
+		fix: "Improve content quality and uniqueness. Add internal links pointing to these pages. Ensure they have clear, distinct value compared to other pages on your site."
+	},
+	discovered_not_indexed: {
+		description: "Google knows these URLs exist but hasn't crawled them yet. This is usually a crawl-budget or priority signal — Google deemed other pages more important.",
+		fix: "Add strong internal links from indexed pages. Submit the URL via Search Console's URL Inspection > Request Indexing. Improve site authority and crawl-budget signals; check no resource constraints (slow server, large response sizes) are deterring the crawl."
+	},
+	server_error: {
+		description: "Google encountered 5xx server errors when trying to crawl these URLs. The pages were unreachable at crawl time.",
+		fix: "Check your server logs for errors. Ensure your hosting can handle Googlebot traffic. Fix any backend issues causing 500/502/503 errors."
+	},
+	unknown_to_google: {
+		description: "These URLs exist on your site but Google hasn't discovered them yet. They may be orphaned pages or missing from your sitemap.",
+		fix: "Add these URLs to your sitemap. Create internal links to them from well-indexed pages. Submit the sitemap in Google Search Console."
+	},
+	stale_crawl: {
+		description: "Google hasn't re-crawled these pages in over 30 days. They may have low perceived value or your crawl budget may be exhausted.",
+		fix: "Update content on these pages to signal freshness. Improve internal linking. Ensure your site loads quickly to maximize crawl budget efficiency."
+	},
+	very_stale_crawl: {
+		description: "Google hasn't visited these pages in over 60 days. They are at risk of being dropped from the index entirely.",
+		fix: "Prioritize updating these pages immediately. Add fresh internal links. Consider requesting re-indexing via Google Search Console's URL Inspection tool."
+	},
+	not_found: {
+		description: "These URLs return 404 errors. Google previously knew about them but they no longer exist.",
+		fix: "If the content moved, add 301 redirects to the new URLs. If intentionally removed, ensure no internal links still point to them. The 404s will clear over time."
+	},
+	soft_404: {
+		description: "These pages return a 200 status but Google detects them as effectively empty or error pages — \"soft\" 404s.",
+		fix: "Return a proper 404 status code for missing pages. If the pages should exist, add meaningful content. Avoid thin placeholder pages."
+	},
+	blocked_robots: {
+		description: "Your robots.txt file is preventing Google from crawling these URLs.",
+		fix: "Review your robots.txt rules. Remove Disallow directives for pages you want indexed. Remember that blocked pages can't be indexed even if linked."
+	},
+	noindex: {
+		description: "These pages have a noindex meta tag or X-Robots-Tag header, telling Google not to include them in search results.",
+		fix: "If these pages should be indexed, remove the noindex directive. Check for noindex in meta tags, HTTP headers, and any SEO plugin configuration."
+	},
+	redirect: {
+		description: "These URLs redirect to other pages. Google follows the redirect and indexes the destination instead.",
+		fix: "This is usually expected behavior. Ensure redirects point to the correct destination. Update internal links to point directly to the final URL to save crawl budget."
+	},
+	canonical_mismatch: {
+		description: "The canonical URL declared on these pages points to a different URL. Google may index the canonical target instead.",
+		fix: "Ensure each page's canonical tag points to itself, or intentionally to the preferred version. Fix any unintended canonical tags added by CMS plugins."
+	},
+	fragment_url: {
+		description: "These URLs contain fragment identifiers (#). Googlebot typically ignores fragments as they're client-side only.",
+		fix: "Avoid using fragment URLs as unique pages. If using client-side routing with hashes, migrate to proper URL paths for better indexability."
+	},
+	not_indexed: {
+		description: "These URLs are not in Google's index. This is a general category — the specific reason may vary.",
+		fix: "Check individual URLs in Google Search Console's URL Inspection tool for specific reasons. Common causes include quality, duplicate content, or crawl issues."
+	}
+};
+const nuxtSeoTips = {
+	blocked_robots: {
+		modules: ["@nuxtjs/robots", "@nuxtjs/seo"],
+		tip: "Check nuxt.config robots rules and route rules for Disallow:\n\nexport default defineNuxtConfig({\n  robots: { disallow: ['/admin'] },\n  routeRules: {\n    '/secret/**': { robots: false }\n  }\n})"
+	},
+	noindex: {
+		modules: ["@nuxtjs/seo"],
+		tip: "Check for noindex in route rules or page meta:\n\n// nuxt.config.ts\nrouteRules: { '/draft/**': { index: false } }\n\n// pages/draft.vue\ndefinePageMeta({ robots: 'noindex' })"
+	},
+	unknown_to_google: {
+		modules: ["@nuxtjs/sitemap", "@nuxtjs/seo"],
+		tip: "Ensure @nuxtjs/sitemap includes these routes. Dynamic routes need sources:\n\nexport default defineNuxtConfig({\n  sitemap: {\n    sources: ['/api/__sitemap__/urls']\n  }\n})\n\nVerify at /sitemap.xml that these URLs appear."
+	},
+	canonical_mismatch: {
+		modules: ["@nuxtjs/seo"],
+		tip: "@nuxtjs/seo auto-generates canonicals from site.url. Check for conflicts:\n\n// nuxt.config.ts — set your canonical origin\nsite: { url: 'https://example.com' }\n\n// Override per page if needed\nuseHead({ link: [{ rel: 'canonical', href: 'https://example.com/preferred' }] })"
+	},
+	soft_404: {
+		modules: ["@nuxtjs/seo"],
+		tip: "Ensure pages render content server-side, not just client-side. Check for missing data:\n\n// pages/[slug].vue\nconst { data } = await useAsyncData(() => fetchContent(slug))\nif (!data.value)\n  throw createError({ statusCode: 404 }) // Return real 404, not empty page"
+	}
+};
+const severityOrder = [
+	"error",
+	"warning",
+	"info"
+];
+const investigationStatusConfig = {
+	investigated: {
+		label: "Investigated",
+		icon: "i-lucide-check-circle",
+		color: "success"
+	},
+	fixed: {
+		label: "Fixed",
+		icon: "i-lucide-wrench",
+		color: "success"
+	},
+	false_positive: {
+		label: "False positive",
+		icon: "i-lucide-shield-check",
+		color: "info"
+	},
+	wont_fix: {
+		label: "Won't fix",
+		icon: "i-lucide-ban",
+		color: "neutral"
+	},
+	monitoring: {
+		label: "Monitoring",
+		icon: "i-lucide-eye",
+		color: "warning"
+	}
+};
+const coverageLabels = {
+	"Crawled - currently not indexed": {
+		short: "Crawled, not indexed",
+		color: "text-error"
+	},
+	"Discovered - currently not indexed": {
+		short: "Discovered, not indexed",
+		color: "text-warning"
+	},
+	"Server error (5xx)": {
+		short: "Server error",
+		color: "text-error"
+	},
+	"Not found (404)": {
+		short: "404",
+		color: "text-error"
+	},
+	"Soft 404": {
+		short: "Soft 404",
+		color: "text-error"
+	},
+	"URL is unknown to Google": {
+		short: "Unknown",
+		color: "text-warning"
+	},
+	"Blocked by robots.txt": {
+		short: "Robots blocked",
+		color: "text-warning"
+	}
+};
+function coverageLabel(state) {
+	return coverageLabels[state] || {
+		short: state,
+		color: "text-muted"
+	};
+}
+const issueGroups = [
+	{
+		id: "quick-wins",
+		label: "Quick Wins",
+		icon: "i-lucide-zap",
+		description: "Configuration changes you can make right now",
+		effort: "quick",
+		controlLevel: "full",
+		education: "These issues are caused by your site's configuration preventing Google from indexing certain pages. If these pages should be indexed, the fix is usually a one-line config change — remove a robots.txt rule or fix a canonical URL. Highest-ROI fixes, zero content work.",
+		issueTypes: ["blocked_robots", "canonical_mismatch"]
+	},
+	{
+		id: "technical",
+		label: "Technical Fixes",
+		icon: "i-lucide-wrench",
+		description: "Server and URL issues to resolve",
+		effort: "moderate",
+		controlLevel: "full",
+		education: "These are infrastructure problems — your server is returning errors, pages have been deleted without redirects, or pages appear empty to Google. Fix server errors first (they affect crawl budget), then handle 404s with redirects, and ensure pages with real content return proper status codes.",
+		issueTypes: [
+			"server_error",
+			"not_found",
+			"soft_404"
+		]
+	},
+	{
+		id: "content-discovery",
+		label: "Content & Discovery",
+		icon: "i-lucide-file-search",
+		description: "Help Google find and value your pages",
+		effort: "involved",
+		controlLevel: "partial",
+		education: "Google found these pages but either didn't think they were worth indexing, or hasn't discovered them yet. For crawled-but-not-indexed pages, improving content quality and internal linking helps — but Google ultimately decides what to index. For undiscovered pages, adding them to your sitemap and linking to them from indexed pages is the fix.",
+		issueTypes: [
+			"crawled_not_indexed",
+			"discovered_not_indexed",
+			"unknown_to_google",
+			"stale_crawl",
+			"very_stale_crawl"
+		]
+	},
+	{
+		id: "expected",
+		label: "Expected Behavior",
+		icon: "i-lucide-info",
+		description: "Usually intentional — review but likely fine",
+		effort: "quick",
+		controlLevel: "none",
+		education: "These aren't really \"issues\" — they're usually intentional. Noindex tags are set deliberately to keep pages out of search. Redirects are normal when you move pages. Fragment URLs are stripped by Google by design. Review to make sure nothing unexpected is here.",
+		issueTypes: [
+			"noindex",
+			"redirect",
+			"fragment_url"
+		]
+	}
+];
+const issueTypeToGroup = Object.fromEntries(issueGroups.flatMap((g) => g.issueTypes.map((t) => [t, g.id])));
+function enrichIssueDetails(modules) {
+	const moduleNames = new Set(modules?.map((m) => m.name) ?? []);
+	const result = { ...issueDetails };
+	for (const [issueType, nuxtTip] of Object.entries(nuxtSeoTips)) if (nuxtTip.modules.some((m) => moduleNames.has(m)) && result[issueType]) result[issueType] = {
+		...result[issueType],
+		fix: `${result[issueType].fix}\n\nNuxt SEO: ${nuxtTip.tip}`
+	};
+	return result;
+}
+function isCustomPeriod(p) {
+	return typeof p === "string" && p.startsWith("custom:");
+}
+function parseCustomPeriod(p) {
+	if (!isCustomPeriod(p)) return null;
+	const [, start, end, prevStart, prevEnd] = p.split(":");
+	if (!start || !end) return null;
+	if (prevStart && prevEnd) return {
+		start,
+		end,
+		prevStart,
+		prevEnd
+	};
+	return {
+		start,
+		end
+	};
+}
+function todayInPST() {
+	return /* @__PURE__ */ new Date(`${(0, query_exports.currentPstDate)()}T00:00:00`);
+}
+const ROLLING_TO_UPSTREAM = {
+	"7d": "last-7d",
+	"28d": "last-28d",
+	"3m": "last-90d",
+	"6m": "last-180d",
+	"12m": "last-365d"
+};
+const CALENDAR_TO_UPSTREAM = {
+	"this-month": "mtd",
+	"this-year": "ytd"
+};
+function fmt(d) {
+	return format(d, "yyyy-MM-dd");
+}
+function buildResultFromIso(start, end) {
+	const startDate = /* @__PURE__ */ new Date(`${start}T00:00:00`);
+	const endDate = /* @__PURE__ */ new Date(`${end}T00:00:00`);
+	const days = Math.round((endDate.getTime() - startDate.getTime()) / 864e5) + 1;
+	const prev = resolveWindow({
+		preset: "custom",
+		start,
+		end,
+		comparison: "prev-period"
+	});
+	const yoy = resolveWindow({
+		preset: "custom",
+		start,
+		end,
+		comparison: "yoy"
+	});
+	return {
+		start,
+		end,
+		prevStart: prev.comparison.start,
+		prevEnd: prev.comparison.end,
+		yearStart: yoy.comparison.start,
+		yearEnd: yoy.comparison.end,
+		days
+	};
+}
+function periodToDateRange(period, stableData = true) {
+	const custom = parseCustomPeriod(period);
+	if (custom) {
+		const result = buildResultFromIso(custom.start, custom.end);
+		if (custom.prevStart && custom.prevEnd) return {
+			...result,
+			prevStart: custom.prevStart,
+			prevEnd: custom.prevEnd,
+			yearStart: custom.prevStart,
+			yearEnd: custom.prevEnd
+		};
+		return result;
+	}
+	const today = todayInPST();
+	const end = stableData ? subDays(today, 3) : subDays(today, 1);
+	const endIso = fmt(end);
+	const upstreamPreset = ROLLING_TO_UPSTREAM[period] ?? CALENDAR_TO_UPSTREAM[period];
+	if (upstreamPreset) {
+		const win = resolveWindow({
+			preset: upstreamPreset,
+			anchor: endIso
+		});
+		return buildResultFromIso(win.start, win.end);
+	}
+	let start;
+	switch (period) {
+		case "this-week":
+			start = startOfWeek(end, { weekStartsOn: 1 });
+			break;
+		case "last-month": {
+			const prevMonth = subMonths(end, 1);
+			return buildResultFromIso(fmt(startOfMonth(prevMonth)), fmt(endOfMonth(prevMonth)));
+		}
+		case "this-quarter":
+			start = startOfQuarter(end);
+			break;
+		default: start = subDays(end, 27);
+	}
+	return buildResultFromIso(fmt(start), endIso);
+}
+function periodToDays(period) {
+	return periodToDateRange(period).days;
+}
+function compareRange(range, mode) {
+	if (mode === "none") return null;
+	if (mode === "year") return {
+		start: range.yearStart,
+		end: range.yearEnd
+	};
+	return {
+		start: range.prevStart,
+		end: range.prevEnd
+	};
+}
+function getGscUnstableCutoffDate() {
+	const [y, m, d] = (/* @__PURE__ */ new Date()).toLocaleDateString("en-CA", { timeZone: "America/Los_Angeles" }).split("-").map(Number);
+	const cutoff = new Date(y, m - 1, d - 3);
+	return `${cutoff.getFullYear()}-${String(cutoff.getMonth() + 1).padStart(2, "0")}-${String(cutoff.getDate()).padStart(2, "0")}`;
+}
 const HTTP_PROTOCOL_RE = /^http/i;
 const API_SUFFIX_RE = /\/api\/?$/;
 const TRAILING_SLASH_RE = /\/+$/;
@@ -822,6 +1478,263 @@ function createPartnerRealtimeClient(options) {
 	};
 }
 const createGscdumpRealtimeClient = createPartnerRealtimeClient;
+function formatCount(value) {
+	return new Intl.NumberFormat("en").format(Math.max(0, Math.round(value)));
+}
+function issueCount(issues, ...types) {
+	if (!issues?.length) return 0;
+	const wanted = new Set(types);
+	return issues.reduce((sum, issue) => sum + (wanted.has(issue.type) ? issue.count : 0), 0);
+}
+function totalSitemapErrors(sitemaps) {
+	return (sitemaps ?? []).reduce((sum, sitemap) => {
+		return sum + (sitemap.errors ?? 0) + (sitemap.lastError ? 1 : 0);
+	}, 0);
+}
+function stage(key, evidence) {
+	return {
+		key,
+		evidence,
+		...{
+			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, growth ready",
+				severity: "success",
+				summary: "Google can discover, index, and show the site. The next work is growth, not cleanup.",
+				primaryAction: "Use expansion work: striking-distance pages, content gaps, and authority building.",
+				nextStage: null,
+				sprintFindingTypes: ["striking-distance", "competitor-content-gap"]
+			}
+		}[key]
+	};
+}
+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 sitemapUrlCount = sitemaps.reduce((sum, sitemap) => sum + (sitemap.urlCount ?? 0), 0);
+	const unknown = issueCount(issues, "unknown_to_google");
+	const discovered = issueCount(issues, "discovered_not_indexed");
+	const crawled = issueCount(issues, "crawled_not_indexed");
+	const crawlBlocks = issueCount(issues, "blocked_robots", "server_error", "not_found", "soft_404", "access_denied", "forbidden");
+	const indexBlocks = issueCount(issues, "noindex", "canonical_mismatch");
+	const canonicalMismatches = input.canonicalMismatchCount ?? issueCount(issues, "canonical_mismatch");
+	const zeroImpressionPages = (input.pageInventory ?? []).filter((page) => page.impressions === 0).length;
+	const visibleNoClickPages = (input.pageInventory ?? []).filter((page) => page.impressions >= 50 && page.clicks === 0).length;
+	const poorPositionPages = (input.pageInventory ?? []).filter((page) => page.impressions >= 50 && (page.position ?? 0) > 20).length;
+	const pageMoverDropCount = input.pageMoverDropCount ?? 0;
+	const ctrOutlierCount = input.ctrOutlierCount ?? 0;
+	if (summary.change7d != null && summary.change7d <= -5) return stage("declining_visibility", [{
+		label: "Index rate change",
+		value: `${summary.change7d.toFixed(1)}% in 7 days`,
+		source: "indexing"
+	}, {
+		label: "Indexed pages",
+		value: `${formatCount(indexed)} of ${formatCount(totalUrls)}`,
+		source: "indexing"
+	}]);
+	if (pageMoverDropCount > 0) return stage("declining_visibility", [{
+		label: "Falling pages",
+		value: formatCount(pageMoverDropCount),
+		source: "performance"
+	}]);
+	if (sitemaps.length === 0 || sitemapUrlCount === 0 || sitemapErrors > 0 || unknown > Math.max(5, totalUrls * .1)) return stage("weak_discovery", [{
+		label: "Sitemaps",
+		value: sitemaps.length === 0 ? "None registered" : `${formatCount(sitemapErrors)} errors`,
+		source: "sitemap"
+	}, ...unknown > 0 ? [{
+		label: "Unknown URLs",
+		value: formatCount(unknown),
+		source: "indexing"
+	}] : []]);
+	if (discovered > Math.max(10, totalUrls * .15)) return stage("discovery_backlog", [{
+		label: "Discovered, not crawled",
+		value: formatCount(discovered),
+		source: "indexing"
+	}, {
+		label: "Indexed pages",
+		value: `${indexedPercent.toFixed(1)}%`,
+		source: "indexing"
+	}]);
+	if (crawlBlocks > Math.max(5, totalUrls * .05)) return stage("crawl_blocked", [{
+		label: "Crawl blockers",
+		value: formatCount(crawlBlocks),
+		source: "indexing"
+	}, {
+		label: "Indexed pages",
+		value: `${formatCount(indexed)} of ${formatCount(totalUrls)}`,
+		source: "indexing"
+	}]);
+	if (indexBlocks > Math.max(5, totalUrls * .05) || canonicalMismatches > Math.max(5, totalUrls * .05)) return stage("indexability_blocked", [...indexBlocks > 0 ? [{
+		label: "Index signal blockers",
+		value: formatCount(indexBlocks),
+		source: "indexing"
+	}] : [], ...canonicalMismatches > 0 ? [{
+		label: "Canonical mismatches",
+		value: formatCount(canonicalMismatches),
+		source: "canonical"
+	}] : []]);
+	if (crawled > Math.max(10, totalUrls * .15)) return stage("index_rejection", [{
+		label: "Crawled, not indexed",
+		value: formatCount(crawled),
+		source: "indexing"
+	}, {
+		label: "Not indexed",
+		value: formatCount(notIndexed),
+		source: "indexing"
+	}]);
+	if (indexedPercent < 80) return stage("partially_indexed", [{
+		label: "Indexed",
+		value: `${indexedPercent.toFixed(1)}%`,
+		source: "indexing"
+	}, {
+		label: "Not indexed",
+		value: formatCount(notIndexed),
+		source: "indexing"
+	}]);
+	if (zeroImpressionPages >= Math.max(1, (input.pageInventory?.length ?? 0) * .25)) return stage("indexed_invisible", [{
+		label: "No-impression pages",
+		value: formatCount(zeroImpressionPages),
+		source: "performance"
+	}]);
+	if (ctrOutlierCount > 0 || visibleNoClickPages >= Math.max(1, (input.pageInventory?.length ?? 0) * .25)) return stage("visible_not_clicked", [...ctrOutlierCount > 0 ? [{
+		label: "CTR outliers",
+		value: formatCount(ctrOutlierCount),
+		source: "performance"
+	}] : [], ...visibleNoClickPages > 0 ? [{
+		label: "Visible, no clicks",
+		value: formatCount(visibleNoClickPages),
+		source: "performance"
+	}] : []]);
+	if (poorPositionPages >= Math.max(1, (input.pageInventory?.length ?? 0) * .25)) return stage("ranking_stalled", [{
+		label: "Low-ranking visible pages",
+		value: formatCount(poorPositionPages),
+		source: "performance"
+	}]);
+	return stage("healthy_growth_ready", [{
+		label: "Indexed",
+		value: `${indexedPercent.toFixed(1)}%`,
+		source: "indexing"
+	}, {
+		label: "Critical blockers",
+		value: "0",
+		source: "indexing"
+	}]);
+}
 const encoder = new TextEncoder();
 function toPayloadString(payload) {
 	return typeof payload === "string" ? payload : JSON.stringify(payload);
@@ -896,4 +1809,4 @@ function readWebhookHeaders(headers) {
 		signature: headers.signature ?? null
 	};
 }
-export { ARCHETYPE_EXECUTION_CLASS, CANONICAL_WEBHOOK_EVENTS, PartnerApiError, VALID_WEBHOOK_EVENTS, WEBHOOK_CONTRACT_VERSION, WEBHOOK_CONTRACT_VERSION_HEADER, WEBHOOK_DELIVERY_HEADER, WEBHOOK_EVENT_HEADER, WEBHOOK_SIGNATURE_HEADER, WEBHOOK_TIMESTAMP_HEADER, analyticsStatusToSyncStatus, createAnalyticsClient, createGscdumpClient, createGscdumpRealtimeClient, createPartnerClient, createPartnerRealtimeClient, findLifecycleSite, lifecycleSiteToSyncStatus, lifecycleSiteToUserSite, parseWebhookPayload, readWebhookHeaders, serializeWebhookPayload, toPartnerError, verifyWebhookSignature };
+export { ARCHETYPE_EXECUTION_CLASS, CANONICAL_WEBHOOK_EVENTS, COMPARE_OPTIONS, COUNTRY_NAMES, CWV_GOOD_CLS, CWV_GOOD_INP, CWV_GOOD_LCP, CWV_POOR_CLS, CWV_POOR_INP, CWV_POOR_LCP, GSC_COLUMN_OPTIONS, GSC_PERIOD_OPTIONS, GSC_PERIOD_OPTIONS_LONG, GSC_STABLE_LATENCY_DAYS, PERIOD_PRESETS, PartnerApiError, VALID_WEBHOOK_EVENTS, WEBHOOK_CONTRACT_VERSION, WEBHOOK_CONTRACT_VERSION_HEADER, WEBHOOK_DELIVERY_HEADER, WEBHOOK_EVENT_HEADER, WEBHOOK_SIGNATURE_HEADER, WEBHOOK_TIMESTAMP_HEADER, analyticsStatusToSyncStatus, andFilter, classifyGscError, classifySearchConsoleStage, coerceRowMetrics, compareRange, countryName, coverageLabel, coverageLabels, createAnalyticsClient, createGscdumpClient, createGscdumpRealtimeClient, createPartnerClient, createPartnerRealtimeClient, cwvBucket, dateFilter, defineGscAnalyzer, enrichIssueDetails, findLifecycleSite, getGscUnstableCutoffDate, gscConsoleUrl, investigationStatusConfig, isCustomPeriod, issueDetails, issueGroups, issueTypeToGroup, lifecycleSiteToSyncStatus, lifecycleSiteToUserSite, nuxtSeoTips, parseCustomPeriod, parseWebhookPayload, periodToDateRange, periodToDays, positionFor, readWebhookHeaders, serializeWebhookPayload, severityOrder, siteUrlToHostname, splitOpportunityTitle, summarizeDailyRows, toPartnerError, truncateQuery, verifyWebhookSignature, weightedAnonPct };