seo 0.12.0 → 0.12.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 version, t as load } from "./esm-CQJgJ8TD.js";
+import { n as version, t as load } from "./esm-Cyusbw2J.js";
 import { SEO_PROVIDER_API_VERSION } from "./provider-sdk.js";
 import crypto, { createHash, randomUUID, sign } from "node:crypto";
 import { z } from "zod";
@@ -1730,6 +1730,87 @@ function bingCall(auth, options) {
 		return (await readJson(response, "Bing Webmaster", { maxBytes: MAX_BYTES$4 })).d;
 	};
 }
+function day$2(value) {
+	if (typeof value !== "string") return null;
+	const legacy = /^\/Date\((-?\d+)(?:[+-]\d{4})?\)\/$/.exec(value);
+	const date = legacy ? new Date(Number(legacy[1])) : new Date(value);
+	return Number.isNaN(date.getTime()) ? null : date.toISOString().slice(0, 10);
+}
+const count$2 = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+function list$1(data, label) {
+	if (!Array.isArray(data)) throw new SeoError("OPTIONAL_PROVIDER_UNAVAILABLE", `Bing Webmaster returned an invalid ${label}.`);
+	return data.filter((item) => Boolean(item) && typeof item === "object");
+}
+async function listBingSites(call) {
+	return list$1(await call("GetUserSites"), "site list").filter((row) => typeof row.Url === "string").map((row) => ({
+		url: row.Url,
+		verified: row.IsVerified === true
+	})).sort((a, b) => a.url.localeCompare(b.url, "en"));
+}
+async function bingTraffic(call, site) {
+	const rows = [];
+	let invalidRows = 0;
+	for (const row of list$1(await call("GetRankAndTrafficStats", { siteUrl: site }), "traffic list")) {
+		const date = day$2(row.Date);
+		const clicks = count$2(row.Clicks);
+		const impressions = count$2(row.Impressions);
+		if (!date || clicks === null || impressions === null) {
+			invalidRows += 1;
+			continue;
+		}
+		rows.push({
+			date,
+			clicks,
+			impressions
+		});
+	}
+	rows.sort((a, b) => a.date.localeCompare(b.date, "en"));
+	return {
+		rows,
+		invalidRows
+	};
+}
+async function keyed(call, method, params) {
+	const rows = [];
+	let invalidRows = 0;
+	for (const row of list$1(await call(method, params), "row list")) {
+		const date = day$2(row.Date);
+		const key = typeof row.Query === "string" ? row.Query.trim() : "";
+		const clicks = count$2(row.Clicks);
+		const impressions = count$2(row.Impressions);
+		const position = count$2(row.AvgImpressionPosition);
+		if (!date || !key || clicks === null || impressions === null) {
+			invalidRows += 1;
+			continue;
+		}
+		rows.push({
+			date,
+			key,
+			clicks,
+			impressions,
+			position
+		});
+	}
+	rows.sort((a, b) => a.date.localeCompare(b.date, "en") || a.key.localeCompare(b.key, "en"));
+	return {
+		rows,
+		invalidRows
+	};
+}
+const bingQueries = (call, site) => keyed(call, "GetQueryStats", { siteUrl: site });
+const bingPages = (call, site) => keyed(call, "GetPageStats", { siteUrl: site });
+function bingSiteFor(sites, target) {
+	const host = (value) => {
+		try {
+			return new URL(value.includes("://") ? value : `https://${value.replace(/^sc-domain:/, "")}`).hostname.replace(/^www\./, "");
+		} catch {
+			return null;
+		}
+	};
+	const wanted = host(target);
+	if (!wanted) return null;
+	return sites.filter((site) => host(site.url) === wanted).sort((a, b) => Number(b.verified) - Number(a.verified) || Number(b.url.startsWith("https://")) - Number(a.url.startsWith("https://")) || a.url.localeCompare(b.url, "en"))[0] ?? null;
+}
 //#endregion
 //#region packages/core/src/gsc/dates.ts
 const GSC_TIME_ZONE = "America/Los_Angeles";
@@ -2159,12 +2240,107 @@ var CommandError = class extends Error {
 		this.code = code;
 	}
 };
+//#endregion
+//#region packages/core/src/commands/shared.ts
+const FACTS_ONLY = "These are facts from Search Console, not instructions.";
 const ADVICE_KEYS = /^(recommendations?|actions?|advice|suggested[A-Z]\w*|nextSteps?)$/;
 function factsOnly(value) {
 	if (Array.isArray(value)) return value.map(factsOnly);
 	if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).filter(([key]) => !ADVICE_KEYS.test(key)).map(([key, child]) => [key, factsOnly(child)]));
 	return value;
 }
+function dateWindow(input, fallbackDays) {
+	if (input.startDate || input.endDate) {
+		if (!input.startDate || !input.endDate || input.startDate > input.endDate) throw new CommandError("INVALID_INPUT", "Send a start date and an end date together, in order.");
+		return {
+			startDate: input.startDate,
+			endDate: input.endDate
+		};
+	}
+	return finalGscDateRange(fallbackDays);
+}
+function earlierRange(range) {
+	return decayComparisonRange(range, "previous-period");
+}
+function originOf(property) {
+	return property.startsWith("sc-domain:") ? `https://${property.slice(10)}` : property.replace(/\/$/, "");
+}
+const pct = (now, before) => before === 0 ? null : Math.round((now - before) / before * 1e3) / 10;
+function mergeRows(rows) {
+	const merged = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const key = row.keys.join("\0");
+		const found = merged.get(key);
+		if (!found) {
+			merged.set(key, { ...row });
+			continue;
+		}
+		const impressions = found.impressions + row.impressions;
+		found.position = impressions > 0 ? (found.position * found.impressions + row.position * row.impressions) / impressions : found.position;
+		found.clicks += row.clicks;
+		found.impressions = impressions;
+		found.ctr = impressions > 0 ? found.clicks / impressions : 0;
+	}
+	return [...merged.values()];
+}
+function sharedReader(read, redirects = /* @__PURE__ */ new Map()) {
+	const memo = /* @__PURE__ */ new Map();
+	const merged = async (site, body, opts) => {
+		const result = await read(site, body, opts);
+		const pageAt = (body.dimensions ?? []).indexOf("page");
+		if (pageAt < 0 || redirects.size === 0) return result;
+		return {
+			...result,
+			rows: mergeRows(result.rows.map((row) => {
+				const target = redirects.get(row.keys[pageAt] ?? "");
+				if (!target) return row;
+				const keys = [...row.keys];
+				keys[pageAt] = target;
+				return {
+					...row,
+					keys
+				};
+			}))
+		};
+	};
+	return (site, body, opts) => {
+		const key = JSON.stringify([site, body]);
+		let found = memo.get(key);
+		if (!found) {
+			found = merged(site, body, opts);
+			memo.set(key, found);
+		}
+		return found;
+	};
+}
+const MAX_STATUS_BYTES = 10 * 1024 * 1024;
+async function googleUpdates(window) {
+	if (!window) return [];
+	const incidents = await fetch("https://status.search.google.com/incidents.json", { signal: AbortSignal.timeout(8e3) }).then((response) => response.ok ? readJson(response, "Google Search Status", { maxBytes: MAX_STATUS_BYTES }) : null).catch(() => null);
+	if (!Array.isArray(incidents)) return "Google Search Status could not be read.";
+	return findOverlappingSearchUpdates({
+		updates: searchUpdatesFromIncidents(withRankingHistory(incidents), {
+			product: "Ranking",
+			limit: Number.POSITIVE_INFINITY
+		}),
+		startDate: window.start,
+		endDate: window.end,
+		paddingDays: 3
+	});
+}
+function checkedDates(checked) {
+	const window = checked;
+	if (!window?.start || !window.end) return "in this window";
+	const dates = window.start === window.end ? window.start : `${window.start} to ${window.end}`;
+	return `within ${window.paddingDays ?? 3} days of ${dates}`;
+}
+function listOfUpdates(value, checked) {
+	if (typeof value === "string") return value;
+	if (!Array.isArray(value)) return null;
+	const where = checkedDates(checked);
+	if (value.length === 0) return `Google updates ${where}: none.`;
+	return `Google updates ${where} (timing only, not cause): ${value.map((update) => `${update.name} (${update.start.slice(0, 10)} to ${update.end?.slice(0, 10) ?? "ongoing"})`).join("; ")}.`;
+}
 function matchProperty(names, site) {
 	if (names.includes(site)) return site;
 	let host;
@@ -2181,6 +2357,270 @@ function matchProperty(names, site) {
 	return names.find((name) => name === `${origin}/` || name === `${origin.replace("://", "://www.")}/` || name === `${origin.replace("://www.", "://")}/`) ?? null;
 }
 //#endregion
+//#region packages/core/src/commands/present.ts
+const LIST_KEYS = [
+	"items",
+	"rows",
+	"results",
+	"pages",
+	"urls",
+	"queries",
+	"keywords",
+	"opportunities",
+	"candidates",
+	"clusters",
+	"issues",
+	"domains",
+	"competitors",
+	"links"
+];
+const SKIP_KEYS = /* @__PURE__ */ new Set([
+	"caveats",
+	"warnings",
+	"recommendations",
+	"findings",
+	"sampleUrls",
+	"sampleQueries",
+	"omissions",
+	"dimensions",
+	"brand",
+	"pageChecks"
+]);
+const ID_COLUMNS = [
+	"metric",
+	"direction",
+	"changeDate",
+	"query",
+	"queryFlags",
+	"keyword",
+	"url",
+	"page",
+	"finalUrl",
+	"title",
+	"domain",
+	"target",
+	"check",
+	"rule",
+	"severity",
+	"status",
+	"urls",
+	"topPage"
+];
+const METRIC_COLUMNS = [
+	"percentChange",
+	"baselineMean",
+	"comparisonMean",
+	"clicks",
+	"impressions",
+	"ctr",
+	"position",
+	"previousClicks",
+	"clicksChange",
+	"searchVolume",
+	"volume",
+	"cpc",
+	"difficulty",
+	"rank",
+	"count",
+	"affectedUrls",
+	"score",
+	"priority.score"
+];
+const SUMMARY_ROWS$1 = 10;
+const CELL_MAX = 80;
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isPrimitive = (value) => value === null || [
+	"string",
+	"number",
+	"boolean"
+].includes(typeof value);
+function mainList(report) {
+	const found = [];
+	const visit = (value, path, depth) => {
+		if (!isObject(value) || depth > 2) return;
+		for (const [key, child] of Object.entries(value)) {
+			if (SKIP_KEYS.has(key)) continue;
+			const childPath = path ? `${path}.${key}` : key;
+			if (Array.isArray(child) && child.length > 0 && child.every(isObject)) found.push({
+				path: childPath,
+				rows: child,
+				known: LIST_KEYS.includes(key)
+			});
+			else if (isObject(child)) visit(child, childPath, depth + 1);
+		}
+	};
+	visit(report, "", 0);
+	found.sort((a, b) => Number(b.known) - Number(a.known) || b.rows.length - a.rows.length || a.path.length - b.path.length);
+	return found[0] ?? null;
+}
+function flatten(row) {
+	const flat = {};
+	for (const [key, value] of Object.entries(row)) if (isPrimitive(value)) flat[key] = value;
+	else if (Array.isArray(value) && value.length && value.every(isPrimitive)) flat[key] = value.join(" ");
+	else if (isObject(value)) {
+		for (const [inner, innerValue] of Object.entries(value)) if (isPrimitive(innerValue)) flat[`${key}.${inner}`] = innerValue;
+	}
+	return flat;
+}
+function columnsFor(rows, max) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const row of rows.slice(0, 50)) for (const [key, value] of Object.entries(row)) {
+		const entry = seen.get(key) ?? {
+			count: 0,
+			length: 0
+		};
+		entry.count++;
+		entry.length += String(value ?? "").length;
+		seen.set(key, entry);
+	}
+	const usable = [...seen].filter(([key, { count, length }]) => {
+		const average = length / count;
+		return ID_COLUMNS.includes(key) || average <= 60;
+	});
+	const rank = (key) => {
+		const id = ID_COLUMNS.indexOf(key);
+		if (id >= 0) return id;
+		const metric = METRIC_COLUMNS.indexOf(key);
+		if (metric >= 0) return 100 + metric;
+		return 1e3;
+	};
+	return usable.map(([key]) => key).filter((key) => !/(^|\.)(id|method|heuristic|estimatedClickLift|confidence|label)$|^site$/.test(key)).sort((a, b) => rank(a) - rank(b)).slice(0, max);
+}
+function cell(value, origin, max = CELL_MAX) {
+	if (value === null || value === void 0) return "";
+	let text = String(value);
+	if (origin && text.startsWith(origin)) text = text.slice(origin.length) || "/";
+	if (typeof value === "number" && !Number.isInteger(value)) {
+		const places = Math.abs(value) < 1 ? 1e3 : 100;
+		text = String(Math.round(value * places) / places);
+	}
+	text = text.replaceAll("|", "\\|").replaceAll("\n", " ");
+	return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+function table$1(rows, columns, origin, max = CELL_MAX) {
+	if (rows.length === 0 || columns.length === 0) return "";
+	return [columns.join(" | "), ...rows.map((row) => columns.map((key) => cell(row[key], origin, max)).join(" | "))].join("\n");
+}
+function findString(report, keys) {
+	for (const key of keys) {
+		const value = report[key];
+		if (typeof value === "string") return value;
+	}
+	return null;
+}
+function dateRange$1(report) {
+	const range = isObject(report.range) ? report.range : report;
+	const from = findString(range, [
+		"startDate",
+		"from",
+		"start"
+	]);
+	const to = findString(range, [
+		"endDate",
+		"to",
+		"end"
+	]);
+	return from && to ? `${from} to ${to}` : null;
+}
+function limitsOf(report) {
+	return [report.caveats, isObject(report.retainedEvidence) ? report.retainedEvidence.caveats : null].flatMap((list) => Array.isArray(list) ? list : []).filter((line) => typeof line === "string").filter((line) => !/^(Date window|Selection):/.test(line)).slice(0, 4).map((line) => line.length > 200 ? `${line.slice(0, 199)}…` : line);
+}
+function keyFacts(report) {
+	if (!isObject(report.summary)) return null;
+	const facts = Object.entries(report.summary).filter(([key, value]) => key !== "verdict" && isPrimitive(value) && value !== null).slice(0, 8).map(([key, value]) => `${key} ${cell(value, null)}`);
+	return facts.length ? facts.join(", ") : null;
+}
+function filteredLine(report) {
+	if (!isObject(report.selection)) return null;
+	const counts = Object.entries(report.selection).filter(([key, value]) => typeof value === "number" && value > 0 && !/(source|aggregated|valid|eligible|returned|total|groups|days)/i.test(key)).map(([key, value]) => `${key} ${value}`);
+	return counts.length ? `Filtered out: ${counts.join(", ")}.` : null;
+}
+function findingsFirst(report) {
+	const last = Object.keys(report).filter((key) => /suppress|omitted|excluded/i.test(key));
+	if (!last.length) return report;
+	const out = {};
+	for (const [key, value] of Object.entries(report)) if (!last.includes(key)) out[key] = value;
+	for (const key of last) out[key] = report[key];
+	return out;
+}
+function presentReport(input) {
+	const { report, headline, origin } = input;
+	if (!report) return {
+		text: headline,
+		data: null
+	};
+	if (input.detail === "full") {
+		const ordered = findingsFirst(report);
+		return {
+			text: `${headline}\n\n${JSON.stringify(ordered)}`,
+			data: ordered
+		};
+	}
+	const list = mainList(report);
+	const flat = list ? list.rows.map(flatten) : [];
+	const head = [
+		input.label,
+		input.range ?? dateRange$1(report),
+		findString(report, ["dataStatus"])
+	].filter(Boolean).join(" · ");
+	const facts = keyFacts(report);
+	const limits = limitsOf(report);
+	if (input.detail === "rows") {
+		const page = flat.slice(input.offset, input.offset + input.limit);
+		const columns = columnsFor(flat, 14);
+		const end = input.offset + page.length;
+		return {
+			text: [
+				head,
+				list ? `${list.path}: rows ${input.offset + 1} to ${end} of ${flat.length}.` : "This report has no list of rows. Use detail \"full\".",
+				table$1(page, columns, origin),
+				end < flat.length ? `Next page: ${input.more("rows", end)}` : ""
+			].filter(Boolean).join("\n\n"),
+			data: {
+				path: list?.path ?? null,
+				total: flat.length,
+				offset: input.offset,
+				columns,
+				rows: page
+			}
+		};
+	}
+	const shown = flat.slice(0, Math.min(input.limit, SUMMARY_ROWS$1));
+	const columns = columnsFor(flat, 8);
+	return {
+		text: [
+			head,
+			headline,
+			facts ? `Facts: ${facts}.` : "",
+			...input.notes ?? [],
+			flat.length < 5 ? filteredLine(report) : null,
+			list ? `${list.path} (${shown.length} of ${flat.length} shown):\n${table$1(shown, columns, origin)}` : "",
+			limits.length ? `Limits:\n${limits.map((line) => `- ${line}`).join("\n")}` : "",
+			`More: ${shown.length < flat.length ? `${input.more("rows", shown.length)} for more rows, or ` : ""}${input.more("full")} for every field.`
+		].filter(Boolean).join("\n\n"),
+		data: {
+			summary: isObject(report.summary) ? report.summary : null,
+			path: list?.path ?? null,
+			total: flat.length,
+			columns,
+			rows: shown,
+			limits
+		}
+	};
+}
+function preview(report, origin, rows) {
+	const list = mainList(report);
+	if (!list) return {
+		total: 0,
+		text: ""
+	};
+	const flat = list.rows.map(flatten);
+	return {
+		total: flat.length,
+		text: table$1(flat.slice(0, rows), columnsFor(flat, 6), origin)
+	};
+}
+//#endregion
 //#region packages/core/src/commands/sites.ts
 async function readableSites(google, signIn) {
 	return (await listSearchConsoleSites(google, { signIn })).filter((entry) => entry.permissionLevel !== "siteUnverifiedUser").map((entry) => ({
@@ -2188,6 +2628,73 @@ async function readableSites(google, signIn) {
 		permissionLevel: entry.permissionLevel ?? ""
 	})).sort((a, b) => a.siteUrl.localeCompare(b.siteUrl));
 }
+const hostOf$2 = (value) => {
+	try {
+		return new URL(value.includes("://") ? value : `https://${value.replace(/^sc-domain:/, "")}`).hostname.replace(/^www\./, "");
+	} catch {
+		return value;
+	}
+};
+async function runSites(input) {
+	const named = input.accounts.length > 1;
+	const [google, bing] = await Promise.all([Promise.all(input.accounts.map(async (account) => {
+		const [properties, analytics] = await Promise.all([readableSites(account.google, input.signIn).catch((error) => error instanceof Error ? error : new Error(String(error))), listAnalyticsAccounts(account.google, { signIn: input.signIn }).catch(() => null)]);
+		return {
+			email: account.email,
+			properties,
+			analytics
+		};
+	})), input.bing ? listBingSites(input.bing).catch((error) => error instanceof Error ? error : new Error(String(error))) : Promise.resolve(null)]);
+	const bingSites = Array.isArray(bing) ? bing.filter((site) => site.verified) : [];
+	const bingByHost = new Map(bingSites.map((site) => [hostOf$2(site.url), site]));
+	const properties = google.flatMap((account) => account.properties instanceof Error ? [] : account.properties.map((property) => ({
+		...property,
+		...named ? { account: account.email ?? "" } : {},
+		...Array.isArray(bing) ? { bing: bingByHost.get(hostOf$2(property.siteUrl))?.url ?? "" } : {}
+	})));
+	const googleHosts = new Set(properties.map((property) => hostOf$2(property.siteUrl)));
+	const bingOnly = bingSites.filter((site) => !googleHosts.has(hostOf$2(site.url)));
+	const failed = google.filter((account) => account.properties instanceof Error);
+	const analytics = google.flatMap((account) => (account.analytics ?? []).flatMap((summary) => summary.propertySummaries.map((property) => ({
+		property: property.property.replace("properties/", ""),
+		name: property.displayName ?? "",
+		account: summary.displayName ?? "",
+		...named ? { signIn: account.email ?? "" } : {}
+	}))));
+	const research = [["dataforseo", "x-dataforseo-login"], ["ahrefs", "x-ahrefs-key"]].filter(([, name]) => input.keys.get(name ?? "")).map(([provider]) => provider);
+	const columns = [
+		"siteUrl",
+		"permissionLevel",
+		...named ? ["account"] : [],
+		...Array.isArray(bing) ? ["bing"] : []
+	];
+	return {
+		text: [
+			named ? `Google accounts: ${input.accounts.map((account) => account.email).join(", ")}.` : null,
+			`Search Console properties (${properties.length}):`,
+			properties.length ? table$1(properties, columns, null) : "None. These Google sign-ins have no Search Console access, so the reports cannot run.",
+			...failed.map((account) => `${account.email ?? "Google"}: could not list properties. ${account.properties.message}`),
+			analytics.length ? `Google Analytics properties (${analytics.length}):\n${table$1(analytics, [
+				"property",
+				"name",
+				"account",
+				...named ? ["signIn"] : []
+			], null)}` : "Google Analytics: no properties readable with these sign-ins.",
+			input.bing === void 0 ? null : bing === null ? "Bing Webmaster: not connected." : bing instanceof Error ? `Bing Webmaster: could not list sites. ${bing.message}` : bingOnly.length ? `Bing Webmaster sites with no Search Console property here (${bingOnly.length}): ${bingOnly.map((site) => site.url).join(", ")}.` : `Bing Webmaster: ${bingSites.length} verified sites; the bing column shows each one.`,
+			`Research keys: ${research.length ? research.join(", ") : "none"}.`,
+			input.clicky?.length ? `Clicky sites (seo_data with source "clicky"): ${input.clicky.join(", ")}.` : null,
+			`Add a Google account${input.bing === void 0 ? "" : ", Bing"} or a key: ${input.connect}`,
+			"Next: seo_report with a site."
+		].filter(Boolean).join("\n\n"),
+		data: {
+			searchConsole: properties,
+			googleAnalytics: analytics,
+			bing: Array.isArray(bing) ? bingSites : null,
+			research,
+			clicky: input.clicky ?? []
+		}
+	};
+}
 //#endregion
 //#region packages/core/src/commands/linked.ts
 const MAX_ROWS$2 = 1e5;
@@ -2264,6 +2771,9 @@ var LinkedAccounts = class {
 		})();
 		return this.owners;
 	}
+	async properties() {
+		return [...(await this.ownerMap()).keys()].sort();
+	}
 	async resolve(site) {
 		if (this.google.length === 0) throw new CommandError("NOT_CONNECTED", `No Google account is connected. ${this.hint.signIn}`);
 		const found = matchProperty([...(await this.ownerMap()).keys()], site);
@@ -5108,11 +5618,11 @@ function analyzeAiReferralRows(input) {
 }
 //#endregion
 //#region packages/core/src/analyze/ai-referrals-query.ts
-const PAGE_SIZE$2 = 25e3;
+const PAGE_SIZE$3 = 25e3;
 async function fetchAiReferralRows(input) {
-	const pageSize = input.pageSize ?? PAGE_SIZE$2;
+	const pageSize = input.pageSize ?? PAGE_SIZE$3;
 	if (!Number.isInteger(input.maxRows) || input.maxRows < 1) throw new Error("maxRows must be a positive whole number.");
-	if (!Number.isInteger(pageSize) || pageSize < 1 || pageSize > PAGE_SIZE$2) throw new Error(`pageSize must be a whole number between 1 and ${PAGE_SIZE$2}.`);
+	if (!Number.isInteger(pageSize) || pageSize < 1 || pageSize > PAGE_SIZE$3) throw new Error(`pageSize must be a whole number between 1 and ${PAGE_SIZE$3}.`);
 	const rows = [];
 	const warnings = /* @__PURE__ */ new Set();
 	const retainedKeys = /* @__PURE__ */ new Set();
@@ -5219,7 +5729,7 @@ function resultLimit(input) {
 	if (!Number.isInteger(value) || value < 1 || value > MAX_RESULT_LIMIT) throw new SeoError("INVALID_INPUT", `resultLimit must be a whole number between 1 and ${MAX_RESULT_LIMIT}.`);
 	return value;
 }
-function evidence(result) {
+function evidence$1(result) {
 	return {
 		status: result.truncated || result.warnings.length ? "partial" : "complete",
 		calls: result.calls,
@@ -5322,7 +5832,7 @@ async function aiReferralsReport(input, dependencies = {}) {
 				label: "AI referral landing-page detail query",
 				query
 			});
-			detailEvidence = evidence(detailResult);
+			detailEvidence = evidence$1(detailResult);
 		} catch (error) {
 			detailEvidence = unavailableEvidence(`The landing-page detail query failed: ${error instanceof Error ? error.message : String(error)}`);
 		}
@@ -5340,7 +5850,7 @@ async function aiReferralsReport(input, dependencies = {}) {
 				query
 			});
 			totalUsers = totalUsersFromRows(usersResult.rows) ?? null;
-			totalUsersEvidence = evidence(usersResult);
+			totalUsersEvidence = evidence$1(usersResult);
 			if (totalUsers === null) totalUsersEvidence = unavailableEvidence("The de-duplicated total-users query returned no valid value.");
 		} catch (error) {
 			totalUsersEvidence = unavailableEvidence(`The de-duplicated total-users query failed: ${error instanceof Error ? error.message : String(error)}`);
@@ -5355,7 +5865,7 @@ async function aiReferralsReport(input, dependencies = {}) {
 		sourceRows: sourceResult.rows,
 		detailRows: detailResult?.rows ?? [],
 		totalUsers,
-		sourceDiscovery: evidence(sourceResult),
+		sourceDiscovery: evidence$1(sourceResult),
 		detail: detailEvidence,
 		totalUsersEvidence
 	});
@@ -8310,10 +8820,29 @@ async function urlInspectionQuota(input) {
 		property: input.siteUrl
 	});
 }
+function reserveOrSkip(input) {
+	try {
+		return reserveUrlInspectionQuota(input);
+	} catch (error) {
+		if (error instanceof SeoError) throw error;
+		return;
+	}
+}
+function finalize(reservation, outcome, blockedUntil, now) {
+	if (!reservation) return;
+	try {
+		finalizeUrlInspectionQuota({
+			reservation,
+			outcome,
+			blockedUntil,
+			now
+		});
+	} catch {}
+}
 async function inspectUrl(input) {
 	const inspectionUrl = assertUrlMatchesGscProperty(input.siteUrl, input.inspectionUrl);
 	const { client, quotaIdentity } = await getAuthorized(input.accountEmail ?? await cloudAccountFor(input.siteUrl));
-	const reservation = reserveUrlInspectionQuota({
+	const reservation = reserveOrSkip({
 		credentialKey: credentialKey(quotaIdentity),
 		property: input.siteUrl,
 		limit: input.quotaLimit
@@ -8329,35 +8858,24 @@ async function inspectUrl(input) {
 			})
 		});
 	} catch (error) {
-		finalizeUrlInspectionQuota({
-			reservation,
-			outcome: "consumed"
-		});
+		finalize(reservation, "consumed");
 		if (error instanceof SeoError) throw error;
 		throw new SeoError("PROVIDER_UNAVAILABLE", `URL Inspection request failed: ${error instanceof Error ? error.message : String(error)}`);
 	}
 	if (response.status === 429) {
 		const now = /* @__PURE__ */ new Date();
 		const blockedUntil = retryAfter$1(response, now);
-		finalizeUrlInspectionQuota({
-			reservation,
-			outcome: "exhausted",
-			blockedUntil,
-			now
-		});
+		finalize(reservation, "exhausted", blockedUntil, now);
 		throw new UrlInspectionQuotaError({
 			property: input.siteUrl,
-			resetAt: (blockedUntil ?? new Date(reservation.resetAt)).toISOString(),
-			used: reservation.used + reservation.count,
-			limit: reservation.limit,
+			resetAt: (blockedUntil ?? (reservation ? new Date(reservation.resetAt) : urlInspectionQuotaResetAt(now))).toISOString(),
+			used: reservation ? reservation.used + reservation.count : 0,
+			limit: reservation?.limit ?? 2e3,
 			reason: "provider",
 			requestSent: true
 		});
 	}
-	finalizeUrlInspectionQuota({
-		reservation,
-		outcome: "consumed"
-	});
+	finalize(reservation, "consumed");
 	if (!response.ok) throw inspectionResponseError(response, input);
 	return await readJson(response, "URL Inspection");
 }
@@ -28488,8 +29006,63 @@ async function detectBrandTerms(input) {
 	};
 }
 //#endregion
+//#region packages/core/src/clicky/api.ts
+const ENDPOINT$1 = "https://api.clicky.com/api/stats/4";
+const MAX_BYTES$3 = 5e6;
+var ClickyError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+	}
+};
+function isClickySiteId(value) {
+	return /^\d{1,30}$/u.test(value.trim());
+}
+function isClickySitekey(value) {
+	return /^[A-Za-z0-9]{12,64}$/u.test(value.trim());
+}
+async function clickyStats(site, types, options = {}) {
+	const url = new URL(ENDPOINT$1);
+	url.searchParams.set("site_id", site.siteId);
+	url.searchParams.set("sitekey", site.sitekey);
+	url.searchParams.set("type", types.join(","));
+	url.searchParams.set("output", "json");
+	url.searchParams.set("limit", String(options.limit ?? 1e3));
+	url.searchParams.set("app", "seo");
+	if (options.date) url.searchParams.set("date", options.date);
+	const response = await fetch(url).catch(() => {
+		throw new ClickyError("remote", "Could not reach Clicky. Try again.");
+	});
+	if (!response.ok) throw new ClickyError("remote", `Clicky returned ${response.status}.`);
+	const groups = await readJson(response, "Clicky", { maxBytes: MAX_BYTES$3 });
+	if (!Array.isArray(groups)) throw new ClickyError("remote", "Clicky returned invalid data.");
+	const failed = groups.find((group) => typeof group?.error === "string");
+	if (failed?.error) throw /sitekey|site id|authenticat|permission/iu.test(failed.error) ? new ClickyError("auth", `Clicky rejected site ID ${site.siteId} or its sitekey.`) : new ClickyError("remote", `Clicky: ${failed.error.slice(0, 200)}`);
+	const out = {};
+	for (const type of types) out[type] = [];
+	for (const group of groups) {
+		if (!group?.type || !(group.type in out)) continue;
+		for (const date of group.dates ?? []) for (const item of date.items ?? []) if (item && typeof item === "object") out[group.type]?.push(item);
+	}
+	return out;
+}
+async function clickyDomain(site) {
+	const { pages } = await clickyStats(site, ["pages"], {
+		date: "last-30-days",
+		limit: 1
+	});
+	const url = pages?.find((item) => item.url)?.url;
+	if (!url) return null;
+	try {
+		return new URL(url).hostname.replace(/^www\./u, "");
+	} catch {
+		return null;
+	}
+}
+//#endregion
 //#region packages/core/src/analyze/ai-queries.ts
-const RULES = [
+const RULES$1 = [
 	["agent_prompt", "^(search the web for|browse the web|find sources)|do not invent|return the [0-9]+ most relevant|include source urls|context: location|do not include location|question: |reply only with|the model you are using"],
 	["tracker", "\\. ?my location is |\\?\\. ?my( |$)|^evaluate the .+ on "],
 	["reply", "^(yes|yeah|yep|ok|okay|sure|yes please|go on|continue|keep going|tell me more|why not|how so|really|exactly|show me|and then|thanks|thank you|got it|what else|anything else)[?!.,]*$"],
@@ -28498,10 +29071,255 @@ const RULES = [
 	["chat", "\\b(please|can you|could you|give me|show me|tell me|i want|i need|i have|i am|should i|do i need|is it worth|help me|walk me through)\\b|^(what|how|why|is|does|can|will|would) (it|that|this|they)\\b"],
 	["long", "^(\\S+\\s+){9,}\\S+$"]
 ];
-RULES.map(([kind, pattern]) => [kind, new RegExp(pattern)]);
-RULES.map(([, pattern]) => `(?:${pattern})`).join("|");
-new Set("the and for with that this what which who how why when where are is was can does do did you your our from about into than then them they their there have has had will would should could not but its it’s me my i am of to in on at by or an as be if so".split(" "));
-new Map(`
+const AI_QUERY_KINDS = {
+	agent_prompt: "text from an agent prompt, such as \"search the web for\"",
+	tracker: "a visibility-tool probe, such as \"my location is\"",
+	reply: "a bare reply, such as \"yes\" or \"tell me more\"",
+	follow_up: "a follow-up, such as \"what about …\"",
+	operator: "search operators, such as site:, before: or \"a\" or \"b\"",
+	chat: "chat phrasing, such as \"can you\" or \"should i\"",
+	long: "ten or more words with no other sign"
+};
+const MATCHERS = RULES$1.map(([kind, pattern]) => [kind, new RegExp(pattern)]);
+const AI_QUERY_PATTERN = RULES$1.map(([, pattern]) => `(?:${pattern})`).join("|");
+const NOISE = [
+	["spaced_letters", /(^|\s)(\S\s){3,}\S(\s|$)/u],
+	["broken_encoding", /^(яю|ÿþ|þÿ)|&#[0-9]+;?|&[a-z]+;|[âÃÂ][\u0080-\u00bf€™œ“”]|\ufffd/u],
+	["pasted_text", /^(p [a-z]{3,} |here (are|is) (all )?the |here's the |done[,.!]? (you|here) |current state: )/u]
+];
+function aiQueryNoise(query) {
+	const text = query.trim().toLowerCase();
+	return NOISE.find(([, pattern]) => pattern.test(text))?.[0] ?? null;
+}
+const QUESTION = /^(how|what|what's|whats|which|why|when|where|who|is|are|can|could|does|do|should|would|will|i need|i want|i have|i'm looking|we need|we want)\b|\?$/u;
+const ASKABLE_KINDS = /* @__PURE__ */ new Set(["chat", "long"]);
+const PROMPT_CHARACTERS = 500;
+function askable(query, kind) {
+	const text = query.trim().toLowerCase().replace(/^["'“]+/u, "");
+	return Boolean(kind && ASKABLE_KINDS.has(kind)) && text.length <= PROMPT_CHARACTERS && QUESTION.test(text);
+}
+function aiQueryKind(query) {
+	const text = query.trim().toLowerCase();
+	return MATCHERS.find(([, pattern]) => pattern.test(text))?.[0] ?? null;
+}
+const STOP = new Set("the and for with that this what which who how why when where are is was can does do did you your our from about into than then them they their there have has had will would should could not but its it’s me my i am of to in on at by or an as be if so".split(" "));
+function words(query) {
+	return new Set(query.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((word) => word.length >= 3 && !STOP.has(word)).map((word) => word.length > 4 && word.endsWith("s") ? word.slice(0, -1) : word));
+}
+const SAME_QUESTION = .6;
+const MAX_ROWS = 25e3;
+const EXAMPLES = 3;
+const CANDIDATES = 200;
+const overlap = (a, b, weight) => {
+	let shared = 0;
+	let union = 0;
+	for (const word of a) {
+		union += weight(word);
+		if (b.has(word)) shared += weight(word);
+	}
+	for (const word of b) if (!a.has(word)) union += weight(word);
+	return union ? shared / union : 0;
+};
+const round = (value, places) => Math.round(value * 10 ** places) / 10 ** places;
+async function aiQueriesReport(input, searchAnalytics) {
+	const range = {
+		startDate: input.startDate,
+		endDate: input.endDate
+	};
+	const [matched, site] = await Promise.all([searchAnalytics(input.site, {
+		...range,
+		dimensions: ["query", "page"],
+		type: "web",
+		dataState: "final",
+		maxRows: MAX_ROWS,
+		dimensionFilterGroups: [{ filters: [{
+			dimension: "query",
+			operator: "includingRegex",
+			expression: AI_QUERY_PATTERN
+		}] }]
+	}), searchAnalytics(input.site, {
+		...range,
+		dimensions: [],
+		type: "web",
+		dataState: "final"
+	})]);
+	const rows = [...matched.rows].sort((a, b) => b.impressions - a.impressions || String(a.keys[0]).localeCompare(String(b.keys[0])) || String(a.keys[1]).localeCompare(String(b.keys[1])));
+	const usage = /* @__PURE__ */ new Map();
+	const unique = new Set(rows.map((row) => String(row.keys[0] ?? "")));
+	for (const query of unique) for (const word of words(query)) usage.set(word, (usage.get(word) ?? 0) + 1);
+	const weight = (word) => Math.log((unique.size + 1) / (usage.get(word) ?? 1));
+	const groups = [];
+	const byWord = /* @__PURE__ */ new Map();
+	const byText = /* @__PURE__ */ new Map();
+	const kindOf = /* @__PURE__ */ new Map();
+	const noise = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const query = String(row.keys[0] ?? "");
+		const page = String(row.keys[1] ?? "");
+		const kind = aiQueryKind(query);
+		if (!kind) continue;
+		const junk = aiQueryNoise(query);
+		if (junk) {
+			const seen = noise.get(junk) ?? /* @__PURE__ */ new Set();
+			seen.add(query.trim().toLowerCase());
+			noise.set(junk, seen);
+			continue;
+		}
+		const text = query.trim().toLowerCase();
+		const own = words(query);
+		let group = byText.get(text);
+		if (!group) {
+			let checked = 0;
+			for (const word of own) {
+				for (const candidate of byWord.get(word) ?? []) {
+					if (++checked > CANDIDATES) break;
+					if (overlap(own, candidate.words, weight) >= SAME_QUESTION) {
+						group = candidate;
+						break;
+					}
+				}
+				if (group || checked > CANDIDATES) break;
+			}
+		}
+		if (!group) {
+			group = {
+				words: own,
+				queries: /* @__PURE__ */ new Map(),
+				pages: /* @__PURE__ */ new Map(),
+				kinds: /* @__PURE__ */ new Map(),
+				clicks: 0,
+				impressions: 0,
+				positionWeight: 0
+			};
+			groups.push(group);
+			for (const word of own) {
+				const list = byWord.get(word) ?? [];
+				list.push(group);
+				byWord.set(word, list);
+			}
+		}
+		byText.set(text, group);
+		if (!kindOf.has(text)) {
+			kindOf.set(text, kind);
+			group.kinds.set(kind, (group.kinds.get(kind) ?? 0) + 1);
+		}
+		group.queries.set(query, (group.queries.get(query) ?? 0) + row.impressions);
+		group.pages.set(page, (group.pages.get(page) ?? 0) + row.impressions);
+		group.clicks += row.clicks;
+		group.impressions += row.impressions;
+		group.positionWeight += row.position * row.impressions;
+	}
+	const byKind = /* @__PURE__ */ new Map();
+	for (const kind of kindOf.values()) {
+		const entry = byKind.get(kind) ?? {
+			queries: 0,
+			impressions: 0
+		};
+		entry.queries += 1;
+		byKind.set(kind, entry);
+	}
+	for (const row of rows) {
+		const kind = kindOf.get(String(row.keys[0] ?? "").trim().toLowerCase());
+		const entry = kind && byKind.get(kind);
+		if (entry) entry.impressions += row.impressions;
+	}
+	const queries = kindOf.size;
+	const impressions = groups.reduce((sum, g) => sum + g.impressions, 0);
+	const clicks = groups.reduce((sum, g) => sum + g.clicks, 0);
+	const total = site.rows[0] ?? {
+		clicks: 0,
+		impressions: 0
+	};
+	const items = groups.map((group) => {
+		const most = (map) => [...map].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).map(([name]) => name);
+		const [first, ...rest] = most(group.queries);
+		const kind = [...group.kinds].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))[0]?.[0];
+		return {
+			query: first ?? "",
+			page: most(group.pages)[0] ?? "",
+			askable: askable(first ?? "", kind),
+			pages: group.pages.size,
+			kind,
+			wordings: group.queries.size,
+			impressions: group.impressions,
+			clicks: group.clicks,
+			ctr: group.impressions ? round(group.clicks / group.impressions, 4) : 0,
+			position: group.impressions ? round(group.positionWeight / group.impressions, 1) : 0,
+			otherWordings: rest.slice(0, EXAMPLES)
+		};
+	}).sort((a, b) => b.impressions - a.impressions || b.wordings - a.wordings || a.query.localeCompare(b.query) || a.page.localeCompare(b.page));
+	const pct = (part, whole) => whole ? round(part / whole * 100, 1) : null;
+	const kinds = [...byKind].sort((a, b) => b[1].impressions - a[1].impressions || a[0].localeCompare(b[0])).map(([kind, entry]) => `${kind} ${entry.queries}`).join(", ");
+	const leftOut = [...noise].sort((a, b) => a[0].localeCompare(b[0])).map(([reason, seen]) => `${reason.replace("_", " ")} ${seen.size}`).join(", ");
+	const asked = items.filter((item) => item.askable).length;
+	const capped = matched.rowsFetched >= MAX_ROWS;
+	return {
+		range,
+		verdict: queries ? `${queries} queries in ${groups.length} questions have the shape of AI conversations or agent searches.` : "No queries with the shape of AI conversations or agent searches.",
+		summary: {
+			queries,
+			questions: groups.length,
+			askable: asked,
+			leftOut: leftOut || "none",
+			impressions,
+			clicks,
+			shareOfImpressionsPct: pct(impressions, total.impressions),
+			byKind: kinds || "none",
+			ctr: impressions ? round(clicks / impressions, 4) : 0,
+			siteCtr: total.impressions ? round(total.clicks / total.impressions, 4) : 0
+		},
+		kinds: AI_QUERY_KINDS,
+		items,
+		caveats: [
+			"A heuristic: these queries match the patterns of AI conversations and agent searches. Search Console does not mark AI Mode or AI Overviews, and people type some of these too.",
+			"A minimum: Search Console leaves out rare queries, and these are rare by nature.",
+			"Rewordings of one question are grouped by their shared words; page is the page with the most impressions for it.",
+			"Left out and counted, not shown: letters split by spaces, text broken by a wrong encoding, and text pasted from a tool or an agent’s output.",
+			"askable: a chat or long question that opens with a question word or a request such as \"i need\", or ends with a question mark, so an AI engine can be asked it as it is. ai_answers checks the top askable questions only.",
+			"Search Console’s Generative AI report is not in its API, so it is not here.",
+			...capped ? [`Capped at the first ${MAX_ROWS} matching query and page rows.`] : []
+		]
+	};
+}
+//#endregion
+//#region packages/core/src/commands/research-providers.ts
+function need(headers, provider) {
+	const values = provider === "dataforseo" ? [headers.get("x-dataforseo-login"), headers.get("x-dataforseo-password")] : [headers.get("x-ahrefs-key")];
+	if (values.some((value) => !value)) throw new CommandError("NO_KEY", `No ${provider} key. Hosted MCP: save it at https://seoskill.dev/account#keys. CLI and local MCP: run \`seo login\` to use the account's keys, or \`seo providers ${provider} connect\`.`);
+	return values;
+}
+async function call(provider, request) {
+	const response = await fetch(request);
+	if (response.ok) return response;
+	const text = (await response.text()).slice(0, 300);
+	throw new CommandError(response.status === 401 || response.status === 403 ? "NO_KEY" : "PROVIDER_ERROR", `${provider} answered ${response.status}. ${text}`);
+}
+function requireInput(input) {
+	const needsKeywords = input.action === "keyword_metrics" || input.action === "serp";
+	if (needsKeywords && input.keywords.length === 0) throw new CommandError("INVALID_INPUT", `${input.action} needs keywords.`);
+	if (!needsKeywords && !input.target) throw new CommandError("INVALID_INPUT", `${input.action} needs a target domain or URL.`);
+}
+async function research(provider, headers, input) {
+	requireInput(input);
+	const keys = need(headers, provider);
+	if (provider === "dataforseo") return dataForSeo(keys, input);
+	return {
+		rows: await ahrefs(keys[0] ?? "", input),
+		costUsd: null,
+		partial: false
+	};
+}
+function countryName(code) {
+	return new Intl.DisplayNames("en", { type: "region" }).of(code.toUpperCase()) ?? "United States";
+}
+function mainLanguage(country) {
+	try {
+		return new Intl.Locale(`und-${country.toUpperCase()}`).maximize().language;
+	} catch {
+		return "en";
+	}
+}
+const LABS_LANGUAGES = new Map(`
   ae:ar al:sq am:hy ao:pt ar:es at:de au:en az:az ba:bs bd:bn be:nl bf:fr
   bg:bg bh:ar bo:es br:pt ca:en ch:de ci:fr cl:es cm:fr co:es cr:es cy:el
   cz:cs de:de dk:da dz:ar ec:es ee:et eg:ar es:es fi:fi fr:fr gb:en gh:en
@@ -28511,16 +29329,588 @@ new Map(`
   pl:pl pt:pt py:es ro:ro rs:sr sa:ar se:sv sg:en si:sl sk:sk sn:fr sv:es
   th:th tn:ar tr:tr tw:zh-TW ua:uk us:en uy:es ve:es vn:vi za:en
 `.trim().split(/\s+/).map((pair) => pair.split(":")));
-const DIMENSIONS = [
-	"query",
-	"page",
-	"date",
-	"country",
-	"device",
-	"searchAppearance"
-];
-//#endregion
-//#region packages/core/src/ga4/matching.ts
+function dataForSeoLanguage(country) {
+	return LABS_LANGUAGES.get(country.toLowerCase()) ?? null;
+}
+function dataForSeoMarket(country, language) {
+	return {
+		location_name: countryName(country),
+		language_code: language ?? mainLanguage(country)
+	};
+}
+function dataForSeoKeys(headers) {
+	return need(headers, "dataforseo");
+}
+async function dataForSeoList([login, password], path) {
+	const task = (await readJson(await call("dataforseo", new Request(`https://api.dataforseo.com/${path}`, { headers: { authorization: `Basic ${btoa(`${login}:${password}`)}` } })), "DataForSEO")).tasks?.[0];
+	if (!task || task.status_code >= 4e4) throw new CommandError("PROVIDER_ERROR", `dataforseo: no list at ${path}`);
+	return task.result ?? [];
+}
+async function dataForSeoTask([login, password], path, task) {
+	const result = (await readJson(await call("dataforseo", new Request(`https://api.dataforseo.com/${path}`, {
+		method: "POST",
+		headers: {
+			authorization: `Basic ${btoa(`${login}:${password}`)}`,
+			"content-type": "application/json"
+		},
+		body: JSON.stringify([task])
+	})), "DataForSEO")).tasks?.[0];
+	if (result?.status_code === NO_RESULTS) return {
+		cost: result.cost ?? 0,
+		result: null,
+		partial: false
+	};
+	if (!result || result.status_code >= 4e4 && result.status_code !== PARTIAL) throw Object.assign(new CommandError("PROVIDER_ERROR", `dataforseo: ${result?.status_message ?? "no task result"}`), { cost: result?.cost ?? 0 });
+	return {
+		cost: result.cost ?? 0,
+		result: result.result?.[0] ?? null,
+		partial: result.status_code === PARTIAL
+	};
+}
+const NO_RESULTS = 40102;
+const PARTIAL = 40106;
+async function dataForSeo(keys, input) {
+	const spent = {
+		cost: 0,
+		partial: false
+	};
+	return {
+		rows: await dataForSeoRows(keys, input, spent),
+		costUsd: Math.round(spent.cost * 1e4) / 1e4,
+		partial: spent.partial
+	};
+}
+async function dataForSeoRows(keys, input, spent) {
+	const language = dataForSeoLanguage(input.country);
+	if (!language && input.action !== "serp" && input.action !== "backlinks") throw new CommandError("INVALID_INPUT", `DataForSEO has no ${input.action} data for country "${input.country}".`);
+	const market = dataForSeoMarket(input.country, language);
+	const post = async (path, task) => {
+		const done = await dataForSeoTask(keys, path, {
+			...market,
+			...task
+		}).catch((error) => {
+			spent.cost += error.cost ?? 0;
+			throw error;
+		});
+		spent.cost += done.cost;
+		spent.partial ||= done.partial;
+		return done.result?.items ?? [];
+	};
+	const get = (value, path) => path.split(".").reduce((current, key) => current && typeof current === "object" ? current[key] : void 0, value);
+	const pick = (item, fields) => Object.fromEntries(Object.entries(fields).map(([name, path]) => [name, get(item, path) ?? null]));
+	if (input.action === "keyword_metrics") return (await post("v3/dataforseo_labs/google/keyword_overview/live", { keywords: input.keywords.slice(0, 700) })).map((item) => pick(item, {
+		keyword: "keyword",
+		search_volume: "keyword_info.search_volume",
+		keyword_difficulty: "keyword_properties.keyword_difficulty",
+		cpc: "keyword_info.cpc",
+		competition: "keyword_info.competition",
+		main_intent: "search_intent_info.main_intent"
+	}));
+	if (input.action === "ranked_keywords") return (await post("v3/dataforseo_labs/google/ranked_keywords/live", {
+		target: bareTarget(input.target),
+		limit: input.limit,
+		order_by: ["ranked_serp_element.serp_item.etv,desc"]
+	})).map((item) => pick(item, {
+		keyword: "keyword_data.keyword",
+		position: "ranked_serp_element.serp_item.rank_absolute",
+		url: "ranked_serp_element.serp_item.url",
+		search_volume: "keyword_data.keyword_info.search_volume",
+		etv: "ranked_serp_element.serp_item.etv",
+		keyword_difficulty: "keyword_data.keyword_properties.keyword_difficulty",
+		main_intent: "keyword_data.search_intent_info.main_intent"
+	}));
+	if (input.action === "serp") {
+		const rows = [];
+		for (const keyword of input.keywords.slice(0, 5)) {
+			const items = await post("v3/serp/google/organic/live/advanced", {
+				keyword,
+				depth: Math.min(input.limit, 100)
+			});
+			for (const item of items) {
+				if (item.type !== "organic") continue;
+				rows.push({
+					keyword,
+					...pick(item, {
+						position: "rank_absolute",
+						url: "url",
+						domain: "domain",
+						title: "title"
+					})
+				});
+			}
+		}
+		return rows;
+	}
+	if (input.action === "backlinks") return (await post("v3/backlinks/referring_domains/live", {
+		target: bareTarget(input.target),
+		limit: input.limit,
+		order_by: ["rank,desc"]
+	})).map((item) => pick(item, {
+		domain: "domain",
+		rank: "rank",
+		backlinks: "backlinks",
+		referring_pages: "referring_pages",
+		first_seen: "first_seen"
+	}));
+	return (await post("v3/dataforseo_labs/google/competitors_domain/live", {
+		target: bareTarget(input.target),
+		limit: input.limit
+	})).map((item) => pick(item, {
+		domain: "domain",
+		shared_keywords: "intersections",
+		avg_position: "avg_position",
+		organic_keywords: "full_domain_metrics.organic.count",
+		organic_etv: "full_domain_metrics.organic.etv"
+	}));
+}
+function isPage(target) {
+	return /\/./.test(bareTarget(target));
+}
+function bareTarget(target) {
+	return target.replace(/^https?:\/\//, "").replace(/\/$/, "");
+}
+async function ahrefs(key, input) {
+	const get = async (path, params) => {
+		const url = new URL(`https://api.ahrefs.com/v3/${path}`);
+		for (const [name, value] of Object.entries(params)) url.searchParams.set(name, value);
+		return readJson(await call("ahrefs", new Request(url, { headers: {
+			authorization: `Bearer ${key}`,
+			accept: "application/json"
+		} })), "Ahrefs");
+	};
+	const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+	if (input.action === "keyword_metrics") return ((await get("keywords-explorer/overview", {
+		select: "keyword,volume,difficulty,cpc,traffic_potential,intents",
+		country: input.country,
+		keywords: input.keywords.slice(0, 100).join(",")
+	})).keywords ?? []).map(flattenIntents);
+	if (input.action === "ranked_keywords") return (await get("site-explorer/organic-keywords", {
+		select: "keyword,best_position,best_position_url,volume,sum_traffic,keyword_difficulty,cpc",
+		target: input.target,
+		country: input.country,
+		date: today,
+		mode: isPage(input.target) ? "exact" : "subdomains",
+		limit: String(input.limit),
+		order_by: "sum_traffic:desc"
+	})).keywords ?? [];
+	if (input.action === "serp") {
+		const rows = [];
+		for (const keyword of input.keywords.slice(0, 5)) {
+			const data = await get("serp-overview/serp-overview", {
+				select: "position,type,url,title,domain_rating,traffic,keywords",
+				keyword,
+				country: input.country,
+				top_positions: String(Math.min(input.limit, 100))
+			});
+			for (const row of data.positions ?? []) rows.push({
+				keyword,
+				...row
+			});
+		}
+		return rows;
+	}
+	if (input.action === "backlinks") return (await get("site-explorer/refdomains", {
+		select: "domain,domain_rating,links_to_target,dofollow_links,first_seen,last_seen",
+		target: input.target,
+		mode: isPage(input.target) ? "exact" : "subdomains",
+		history: "live",
+		limit: String(input.limit),
+		order_by: "domain_rating:desc"
+	})).refdomains ?? [];
+	return (await get("site-explorer/organic-competitors", {
+		select: "competitor_domain,keywords_common,keywords_competitor,keywords_target,share,traffic,domain_rating",
+		target: input.target,
+		country: input.country,
+		date: today,
+		mode: "subdomains",
+		limit: String(input.limit),
+		order_by: "keywords_common:desc"
+	})).competitors ?? [];
+}
+function flattenIntents(row) {
+	const intents = row.intents;
+	if (!intents || typeof intents !== "object") return row;
+	const names = Object.entries(intents).filter(([, value]) => value === true).map(([name]) => name.replace(/^is_/, ""));
+	return {
+		...row,
+		intents: names.join(" ") || null
+	};
+}
+function rowsText(input) {
+	const total = input.rows.length;
+	if (input.detail === "full") return `${input.title}\n\n${JSON.stringify(input.rows.slice(input.offset, input.offset + input.limit))}`;
+	const size = input.detail === "summary" ? Math.min(input.limit, 25) : input.limit;
+	const page = input.rows.slice(input.offset, input.offset + size);
+	const columns = [...new Set(page.flatMap((row) => Object.keys(row)))];
+	const end = input.offset + page.length;
+	return [
+		input.title,
+		...input.notes ?? [],
+		total === 0 ? "No rows." : `Rows ${input.offset + 1} to ${end} of ${total}:\n${table$1(page, columns, input.origin ?? null)}`,
+		end < total ? `More: ${input.more ? input.more(end) : `detail "rows", offset ${end}`}.` : ""
+	].filter(Boolean).join("\n\n");
+}
+const DIMENSIONS = [
+	"query",
+	"page",
+	"date",
+	"country",
+	"device",
+	"searchAppearance"
+];
+const ROWS = 25e3;
+async function runRows(input, deps) {
+	const dimensions = input.dimensions?.length ? input.dimensions : ["query"];
+	const filters = input.filters ?? [];
+	const range = dateWindow(input, 28);
+	const previous = earlierRange(range);
+	const query = {
+		dimensions,
+		type: "web",
+		maxRows: ROWS,
+		...filters.length ? { dimensionFilterGroups: [{
+			groupType: "and",
+			filters
+		}] } : {}
+	};
+	const [current, before] = await Promise.all([deps.searchAnalytics(input.site, {
+		...query,
+		...range
+	}), deps.searchAnalytics(input.site, {
+		...query,
+		...previous
+	})]);
+	const pageAt = dimensions.indexOf("page");
+	const merge = (rows) => pageAt < 0 ? rows : collapseFragmentPageRows(rows, { pageKeyIndex: pageAt }).rows;
+	const now = merge(current.rows);
+	const then = merge(before.rows);
+	const name = (keys) => keys.join("\0");
+	const dateAt = dimensions.indexOf("date");
+	const keyOf = (keys, start) => name(keys.map((key, index) => index === dateAt ? String(Math.round((Date.parse(key) - Date.parse(start)) / 864e5)) : key));
+	const earlier = new Map(then.map((row) => [keyOf(row.keys, previous.startDate), row]));
+	const seen = /* @__PURE__ */ new Set();
+	const rows = now.map((row) => {
+		const key = keyOf(row.keys, range.startDate);
+		seen.add(key);
+		const old = earlier.get(key);
+		return {
+			...Object.fromEntries(dimensions.map((d, i) => [d, row.keys[i]])),
+			clicks: row.clicks,
+			impressions: row.impressions,
+			ctr: row.ctr,
+			position: row.position,
+			...dateAt >= 0 ? { previous_date: old?.keys[dateAt] ?? null } : {},
+			previous_clicks: old?.clicks ?? 0,
+			clicks_change: row.clicks - (old?.clicks ?? 0),
+			previous_position: old?.position ?? null
+		};
+	});
+	if (dateAt < 0) for (const old of then) {
+		if (seen.has(keyOf(old.keys, previous.startDate))) continue;
+		rows.push({
+			...Object.fromEntries(dimensions.map((d, i) => [d, old.keys[i]])),
+			clicks: 0,
+			impressions: 0,
+			ctr: 0,
+			position: null,
+			previous_clicks: old.clicks,
+			clicks_change: -old.clicks,
+			previous_position: old.position
+		});
+	}
+	rows.sort((a, b) => dateAt >= 0 ? String(a.date).localeCompare(String(b.date)) : Number(b.clicks ?? 0) - Number(a.clicks ?? 0));
+	const notes = [];
+	if (!dimensions.includes("query") && !dimensions.includes("page")) {
+		const sum = (key) => rows.reduce((total, row) => total + Number(row[key] ?? 0), 0);
+		notes.push(`Totals: clicks ${sum("clicks")}, impressions ${sum("impressions")}; previous period clicks ${sum("previous_clicks")}.`);
+	}
+	notes.push(`Compared with ${previous.startDate} to ${previous.endDate}${before.rowsFetched >= ROWS ? " (earlier period hit the row limit)" : ""}. 0 clicks with no position means the row had no impressions in the current period.`);
+	if (pageAt >= 0) notes.push("Page URLs with #fragments are merged into their page.");
+	if (current.rowsFetched >= ROWS) notes.push(`Search Console has more than ${ROWS} rows; add a filter to narrow it.`);
+	notes.push("Search Console hides some rare queries for privacy, so query rows do not add up to the site totals.");
+	const detail = input.detail ?? "summary";
+	return {
+		text: `${rowsText({
+			title: `Search Console ${input.site}, ${range.startDate} to ${range.endDate}, web, by ${dimensions.join(" and ")}.`,
+			rows,
+			offset: input.offset ?? 0,
+			limit: 50,
+			detail,
+			notes,
+			origin: originOf(input.site),
+			more: (offset) => deps.call("data", {
+				site: input.site,
+				dimensions: dimensions.join(","),
+				detail: "rows",
+				offset
+			})
+		})}\n\n${FACTS_ONLY}`,
+		data: {
+			range,
+			comparisonRange: previous,
+			total: rows.length,
+			offset: input.offset ?? 0,
+			rows: rows.slice(input.offset ?? 0, (input.offset ?? 0) + 50)
+		}
+	};
+}
+const QUESTION_DAYS = 90;
+const list = (value) => Array.isArray(value) ? value : [];
+const urls = (items) => items.map((item) => item.url).filter((url) => typeof url === "string");
+const overview = (result) => {
+	const block = list(result.items).find((item) => item.type === "ai_overview");
+	if (!block) return null;
+	const parts = list(block.items);
+	return {
+		markdown: typeof block.markdown === "string" ? block.markdown : parts.map((part) => String(part.markdown ?? "")).join("\n"),
+		sources: urls([...list(block.references), ...parts.flatMap((part) => list(part.references))]),
+		model: null
+	};
+};
+const ENGINES = [
+	{
+		name: "chatgpt",
+		means: "a ChatGPT search, read by DataForSEO",
+		path: "v3/ai_optimization/chat_gpt/llm_scraper/live/advanced",
+		languages: "v3/ai_optimization/chat_gpt/llm_scraper/languages",
+		task: (question, market) => ({
+			keyword: question,
+			...market
+		}),
+		shown: (result) => {
+			const markdown = typeof result.markdown === "string" ? result.markdown : "";
+			const sources = urls(list(result.sources));
+			if (!markdown && !sources.length) return null;
+			return {
+				markdown,
+				sources,
+				model: typeof result.model === "string" ? result.model : null
+			};
+		}
+	},
+	{
+		name: "google_ai_mode",
+		means: "Google AI Mode",
+		path: "v3/serp/google/ai_mode/live/advanced",
+		languages: "v3/serp/google/ai_mode/languages",
+		task: (question, market) => ({
+			keyword: question,
+			...market
+		}),
+		shown: overview
+	},
+	{
+		name: "google_ai_overview",
+		means: "the AI Overview on a Google search",
+		path: "v3/serp/google/organic/live/advanced",
+		languages: "v3/serp/google/languages",
+		task: (question, market) => ({
+			keyword: question,
+			depth: 10,
+			load_async_ai_overview: true,
+			...market
+		}),
+		shown: overview
+	}
+];
+function prose(markdown) {
+	return markdown.replace(/\[([^\]]*)\]\(https?:\/\/[^)]*\)/g, (_, label) => /^\s*(\d+|[\w-]+(\.[\w-]+)+)\s*$/.test(label) ? " " : label).replace(/https?:\/\/\S+/g, " ");
+}
+function onSite(url, domain) {
+	try {
+		const host = new URL(url).hostname.toLowerCase();
+		return host === domain || host.endsWith(`.${domain}`);
+	} catch {
+		return false;
+	}
+}
+async function ask(keys, engine, question, market, site) {
+	if (typeof market === "string") return {
+		result: "unavailable",
+		model: null,
+		cited_url: null,
+		answered_at: null,
+		cost_usd: 0,
+		error: market
+	};
+	try {
+		const done = await dataForSeoTask(keys, engine.path, engine.task(question, market));
+		const answered = {
+			answered_at: String(done.result?.datetime ?? "").slice(0, 10) || null,
+			cost_usd: done.cost
+		};
+		const shown = done.result && engine.shown(done.result);
+		if (!shown) return {
+			result: "no_answer",
+			model: null,
+			cited_url: null,
+			...answered
+		};
+		const base = {
+			model: shown.model,
+			...answered
+		};
+		const linked = shown.markdown.match(/https?:\/\/[^\s)\]]+/g) ?? [];
+		const cited = [...shown.sources, ...linked].find((url) => onSite(url, site.domain));
+		if (cited) return {
+			result: "cited",
+			cited_url: cited,
+			...base
+		};
+		const text = prose(shown.markdown);
+		return {
+			result: text.toLowerCase().includes(site.domain) || isBrandQuery(text, site.terms) ? "mentioned" : "neither",
+			cited_url: null,
+			...base
+		};
+	} catch (error) {
+		if (error instanceof CommandError && error.code === "NO_KEY") throw error;
+		return {
+			result: "unavailable",
+			model: null,
+			cited_url: null,
+			answered_at: null,
+			cost_usd: error.cost ?? 0,
+			error: error instanceof Error ? error.message.slice(0, 200) : "failed"
+		};
+	}
+}
+async function marketsFor(keys, country) {
+	const code = country.toUpperCase();
+	const language = dataForSeoLanguage(country) ?? dataForSeoMarket(country, null).language_code;
+	const [locations, ...languages] = await Promise.all([dataForSeoList(keys, "v3/ai_optimization/chat_gpt/llm_scraper/locations"), ...ENGINES.map((engine) => dataForSeoList(keys, engine.languages))]);
+	const place = locations.find((row) => row.location_type === "Country" && row.country_iso_code === code);
+	const where = place ? { location_code: Number(place.location_code) } : { location_name: dataForSeoMarket(country, null).location_name };
+	return new Map(ENGINES.map((engine, index) => {
+		if (engine.name === "chatgpt" && !place) return [engine.name, `DataForSEO's ChatGPT search has no data for country "${country}".`];
+		const known = (languages[index] ?? []).some((row) => row.language_code === language);
+		return [engine.name, known ? {
+			...where,
+			language_code: language
+		} : `DataForSEO's ${engine.name} has no "${language}" language, the language used for country "${country}".`];
+	}));
+}
+const usd = (value) => Math.round(value * 1e4) / 1e4;
+async function runAiAnswers(input, headers, deps, more) {
+	const keys = dataForSeoKeys(headers);
+	const domain = registrableDomain(input.site)?.domain;
+	if (!domain) throw new CommandError("INVALID_INPUT", `ai_answers needs a site with a domain, not "${input.site}".`);
+	const range = dateWindow({}, QUESTION_DAYS);
+	const questions = ((await aiQueriesReport({
+		site: input.site,
+		...range
+	}, deps.searchAnalytics)).items ?? []).filter((item) => item.askable).slice(0, 10);
+	const site = {
+		domain,
+		terms: deriveBrandTerms({ siteUrl: input.site })
+	};
+	const markets = questions.length ? await marketsFor(keys, input.country) : /* @__PURE__ */ new Map();
+	const answers = await Promise.all(questions.flatMap((question) => ENGINES.map(async (engine) => ({
+		question: question.query,
+		impressions: question.impressions,
+		engine: engine.name,
+		...await ask(keys, engine, question.query, markets.get(engine.name) ?? "no market", site)
+	}))));
+	const cost = usd(answers.reduce((sum, row) => sum + row.cost_usd, 0));
+	const count = (result) => answers.filter((row) => row.result === result).length;
+	const notes = [questions.length ? `The top ${questions.length} askable questions in Search Console’s AI-shaped queries for ${range.startDate} to ${range.endDate}, by impressions. No calls were made for other questions.` : `No askable questions in Search Console’s AI-shaped queries for ${range.startDate} to ${range.endDate}, so no answers were checked and nothing was spent.`, ...questions.length ? [
+		`Cited ${count("cited")}, mentioned ${count("mentioned")}, neither ${count("neither")}, no answer shown ${count("no_answer")}, unavailable ${count("unavailable")}. DataForSEO cost: $${cost}.`,
+		"Each row is one sample of an answer that changes from run to run, not a ranking.",
+		`cited: the answer lists or links a page on ${domain} or a subdomain. mentioned: no such source, but the answer text names ${[domain, ...site.terms].join(" or ")}, a text match. no_answer: the engine showed no AI answer for the question. model: the model DataForSEO reports for the answer, when it reports one.`,
+		`Engines: ${ENGINES.map((engine) => `${engine.name} is ${engine.means}`).join("; ")}.`
+	] : []];
+	return {
+		text: rowsText({
+			title: `AI answers for ${input.site}, ${input.country}.`,
+			rows: answers,
+			offset: input.offset,
+			limit: 50,
+			detail: input.detail,
+			notes,
+			more
+		}),
+		data: {
+			provider: "dataforseo",
+			action: "ai_answers",
+			site: input.site,
+			country: input.country,
+			questionsFrom: {
+				section: "ai-queries",
+				...range
+			},
+			questions: questions.map((question) => question.query),
+			costUsd: cost,
+			total: answers.length,
+			offset: input.offset,
+			rows: answers.slice(input.offset, input.offset + 50)
+		}
+	};
+}
+//#endregion
+//#region packages/core/src/commands/analytics.ts
+async function analyticsSignIn(accounts, property, signIn) {
+	const only = accounts.length === 1 ? accounts[0] : void 0;
+	if (only) return only.google;
+	const account = (await Promise.all(accounts.map(async (account) => {
+		return (await listAnalyticsAccounts(account.google, { signIn }).catch(() => [])).some((summary) => summary.propertySummaries.some((item) => item.property === `properties/${property}`)) ? account : null;
+	}))).find(Boolean);
+	if (account) return account.google;
+	throw new CommandError("NO_ACCESS", `No connected Google account can read Google Analytics property ${property}. Call seo_sites to list the properties.`);
+}
+async function runAnalyticsRows(input, google, options) {
+	const range = dateWindow(input, 28);
+	const offset = input.offset ?? 0;
+	const limit = Math.min(1e3, offset + 50);
+	const data = await runAnalyticsReport(google, input.property, {
+		dateRanges: [range],
+		dimensions: [{ name: "landingPage" }],
+		metrics: [
+			{ name: "sessions" },
+			{ name: "totalUsers" },
+			{ name: "engagedSessions" },
+			{ name: "keyEvents" }
+		],
+		dimensionFilter: { filter: {
+			fieldName: "sessionDefaultChannelGroup",
+			stringFilter: { value: "Organic Search" }
+		} },
+		orderBys: [{
+			metric: { metricName: "sessions" },
+			desc: true
+		}],
+		limit
+	}, options);
+	const notes = ["Sessions in the Organic Search default channel group."];
+	if (data.metadata?.subjectToThresholding) notes.push("Google Analytics applied thresholding; small rows can be hidden.");
+	if (data.metadata?.dataLossFromOtherRow) notes.push("Some rows were grouped into (other) by Google Analytics.");
+	if ((data.rowCount ?? 0) > limit) notes.push(`${data.rowCount} landing pages in total; ${limit} read.`);
+	const rows = (data.rows ?? []).map((row) => ({
+		page: row.dimensionValues[0]?.value ?? "",
+		sessions: Number(row.metricValues[0]?.value ?? 0),
+		users: Number(row.metricValues[1]?.value ?? 0),
+		engaged_sessions: Number(row.metricValues[2]?.value ?? 0),
+		key_events: Number(row.metricValues[3]?.value ?? 0)
+	}));
+	return {
+		text: rowsText({
+			title: `Google Analytics property ${input.property}: search landing pages, ${range.startDate} to ${range.endDate}.`,
+			rows,
+			offset,
+			limit: 50,
+			detail: input.detail ?? "summary",
+			notes,
+			more: options.call
+		}),
+		data: {
+			range,
+			total: rows.length,
+			offset,
+			rows: rows.slice(offset, offset + 50)
+		}
+	};
+}
+//#endregion
+//#region packages/core/src/ga4/matching.ts
 function hostnameFromUrl(value) {
 	try {
 		const url = new URL(value);
@@ -28562,7 +29952,85 @@ function ga4MatchReason(match, site) {
 	const location = match.match === "domain" ? "is inside" : "matches";
 	return `Matched Google Analytics web stream ${stream} (${match.defaultUri}): its hostname ${location} ${site}.`;
 }
-`${[
+//#endregion
+//#region packages/core/src/commands/analytics-site.ts
+const STREAM_CHECKS = 30;
+const AT_ONCE = 5;
+const TIED = 3;
+const hostOf$1 = (site) => {
+	const value = site.replace(/^sc-domain:/, "");
+	try {
+		return new URL(value.includes("://") ? value : `https://${value}`).hostname;
+	} catch {
+		return value;
+	}
+};
+const plain = (value) => value.toLowerCase().replace(/[^a-z0-9]/g, "");
+function ranked(site, candidates) {
+	const host = hostOf$1(site).replace(/^www\./, "");
+	const words = [plain(host), plain(host.split(".")[0] ?? "")].filter((word) => word.length >= 3);
+	const named = (candidate) => words.some((word) => plain(candidate.propertyName).includes(word)) ? 0 : 1;
+	return [...candidates].sort((a, b) => named(a) - named(b) || a.property.localeCompare(b.property, "en", { numeric: true }));
+}
+function best(site, matches) {
+	const host = hostOf$1(site).replace(/^www\./, "");
+	const score = (match) => match.hostname === host || match.hostname === `www.${host}` ? 0 : 1;
+	return [...matches].sort((a, b) => score(a) - score(b) || a.hostname.length - b.hostname.length || a.property.localeCompare(b.property, "en", { numeric: true }));
+}
+async function findProperty(access, site) {
+	const accounts = await access.accounts();
+	const listed = await Promise.all(accounts.map((account) => listAnalyticsAccounts(account.google, { signIn: access.signIn }).then((summaries) => ({
+		account,
+		summaries
+	}), (error) => error instanceof Error ? error : new Error(String(error)))));
+	const seen = /* @__PURE__ */ new Set();
+	const candidates = [];
+	for (const entry of listed) {
+		if (entry instanceof Error) continue;
+		for (const summary of entry.summaries) for (const item of summary.propertySummaries) {
+			const property = item.property.replace(/^properties\//, "");
+			if (seen.has(property) || !/^\d+$/.test(property)) continue;
+			seen.add(property);
+			candidates.push({
+				account: summary.account,
+				property,
+				propertyName: item.displayName ?? property,
+				google: entry.account.google
+			});
+		}
+	}
+	if (!candidates.length) {
+		const failed = listed.find((entry) => entry instanceof Error);
+		return failed ? `could not be read. ${failed.message}` : "the connected Google accounts cannot read any property.";
+	}
+	const order = ranked(site, candidates).slice(0, STREAM_CHECKS);
+	let failures = 0;
+	for (let start = 0; start < order.length; start += AT_ONCE) {
+		const batch = order.slice(start, start + AT_ONCE);
+		const streams = await Promise.all(batch.map((candidate) => listAnalyticsDataStreams(candidate.google, candidate.property, { signIn: access.signIn }).catch(() => {
+			failures += 1;
+			return [];
+		})));
+		const matches = best(site, batch.flatMap((candidate, index) => matchGa4WebStreams(site, (streams[index] ?? []).map((stream) => ({
+			...candidate,
+			stream
+		})))));
+		const found = /* @__PURE__ */ new Map();
+		for (const match of matches) {
+			const candidate = batch.find((item) => item.property === match.property);
+			if (!candidate || found.has(match.property)) continue;
+			found.set(match.property, {
+				property: match.property,
+				name: match.propertyName,
+				stream: match.defaultUri,
+				google: candidate.google
+			});
+		}
+		if (found.size) return [...found.values()].slice(0, TIED);
+	}
+	return `no web stream matches ${site} in ${order.length < candidates.length ? `the first ${order.length} of ${candidates.length} properties, named like the site first` : `${candidates.length} ${candidates.length === 1 ? "property" : "properties"}`}${failures ? ` (${failures} could not be read)` : ""}.`;
+}
+const AI_SOURCES = [
 	"chatgpt.com",
 	"chatgpt",
 	"chat.openai.com",
@@ -28579,83 +30047,1505 @@ function ga4MatchReason(match, site) {
 	"you.com",
 	"phind.com",
 	"poe.com"
-].map((source) => source.replaceAll(".", "\\.")).join("|")}`;
-//#endregion
-//#region packages/core/src/commands/clicky.ts
-const CLICKY_KEY_PREFIX = "x-clicky-";
-const MAX_INSPECT_LIMIT = 2e3;
-//#endregion
-//#region packages/core/src/commands/page-facts.ts
-const MAX_PAGES = 20;
-const TIMEOUT_MS$2 = 6e3;
-const MAX_BYTES$2 = 1e6;
-const clean = (value) => value?.trim().replace(/\s+/g, " ") || null;
-async function boundedText(response) {
-	if (!response.body) return "";
-	const reader = response.body.getReader();
-	const decoder = new TextDecoder();
-	let text = "";
-	let total = 0;
-	while (total < MAX_BYTES$2) {
-		const { done, value } = await reader.read();
-		if (done) return text + decoder.decode();
-		total += value.byteLength;
-		text += decoder.decode(value, { stream: true });
-	}
-	await reader.cancel();
-	return text;
-}
-function headFacts(html, url) {
-	let title = "";
-	let h1 = "";
-	let inTitle = false;
-	let inH1 = false;
-	let titleDone = false;
-	let h1Done = false;
-	let description = null;
-	let canonical = null;
-	const robots = [];
-	const parser = new Parser({
-		onopentag(name, attributes) {
-			if (name === "title" && !titleDone) inTitle = true;
-			if (name === "h1" && !h1Done) inH1 = true;
-			if (name === "meta") {
-				const metaName = attributes.name?.toLowerCase();
-				if (metaName === "description" && description === null) description = attributes.content ?? null;
-				if (metaName === "robots" && attributes.content) robots.push(attributes.content);
-			}
-			if (name === "link" && canonical === null && attributes.rel?.toLowerCase().split(/\s+/).includes("canonical") && attributes.href) try {
-				canonical = new URL(attributes.href, url).toString();
-			} catch {
-				canonical = attributes.href;
-			}
+];
+const AI_SOURCE_PATTERN = `(www\\.)?(${AI_SOURCES.map((source) => source.replaceAll(".", "\\.")).join("|")})`;
+const AI_ROWS = 5;
+const filter = (fieldName, value, matchType = "EXACT") => ({ filter: {
+	fieldName,
+	stringFilter: {
+		matchType,
+		value
+	}
+} });
+async function totals$1(found, access, range, before, pages) {
+	const read = (dimensions, filters) => runAnalyticsReport(found.google, found.property, {
+		dateRanges: [{
+			...range,
+			name: "now"
+		}, {
+			...before,
+			name: "before"
+		}],
+		dimensions: dimensions.map((name) => ({ name })),
+		metrics: [{ name: "sessions" }, { name: "keyEvents" }],
+		...filters.length ? { dimensionFilter: { andGroup: { expressions: filters } } } : {},
+		limit: 100
+	}, { signIn: access.signIn });
+	const onPages = pages ? [filter("landingPage", pages, "CONTAINS")] : [];
+	const fromAi = [...onPages, filter("sessionSource", AI_SOURCE_PATTERN, "FULL_REGEXP")];
+	const [channels, google, aiSources, aiPages, engines] = await Promise.all([
+		read(["sessionDefaultChannelGroup"], onPages),
+		read([], [
+			...onPages,
+			filter("sessionDefaultChannelGroup", "Organic Search"),
+			filter("sessionSource", "google")
+		]),
+		read(["sessionSource"], fromAi),
+		read(["landingPage"], fromAi),
+		read(["sessionSource"], [...onPages, filter("sessionDefaultChannelGroup", "Organic Search")])
+	]);
+	const sum = () => ({
+		google: {
+			sessions: 0,
+			keyEvents: 0
 		},
-		ontext(text) {
-			if (inTitle) title += text;
-			if (inH1) h1 += text;
+		organic: {
+			sessions: 0,
+			keyEvents: 0
 		},
-		onclosetag(name) {
-			if (name === "title" && inTitle) {
-				inTitle = false;
-				titleDone = true;
-			}
-			if (name === "h1" && inH1) {
-				inH1 = false;
-				h1Done = true;
-			}
+		all: {
+			sessions: 0,
+			keyEvents: 0
 		}
-	}, {
-		decodeEntities: true,
-		lowerCaseTags: true
 	});
-	parser.write(html);
-	parser.end();
-	return {
-		title: clean(title),
-		description: clean(description),
-		h1: clean(h1),
-		canonical,
-		robots: robots.length ? robots.join(", ") : null
+	const periods = {
+		now: sum(),
+		before: sum()
+	};
+	const each = (data, add) => {
+		const periodAt = (data.dimensionHeaders?.map((header) => header.name) ?? []).indexOf("dateRange");
+		for (const row of data.rows ?? []) {
+			const values = row.dimensionValues ?? [];
+			add((periodAt >= 0 ? values[periodAt] : values.at(-1))?.value === "before" ? periods.before : periods.now, values[0]?.value ?? "", {
+				sessions: Number(row.metricValues?.[0]?.value ?? 0),
+				keyEvents: Number(row.metricValues?.[1]?.value ?? 0)
+			});
+		}
+	};
+	const plus = (into, row) => {
+		into.sessions += row.sessions;
+		into.keyEvents += row.keyEvents;
+	};
+	each(channels, (period, channel, row) => {
+		plus(period.all, row);
+		if (channel === "Organic Search") plus(period.organic, row);
+	});
+	each(google, (period, _, row) => plus(period.google, row));
+	const byName = (data, key) => {
+		const rows = /* @__PURE__ */ new Map();
+		const periodAt = (data.dimensionHeaders?.map((header) => header.name) ?? []).indexOf("dateRange");
+		for (const row of data.rows ?? []) {
+			const values = row.dimensionValues ?? [];
+			const name = values[0]?.value ?? "";
+			const before = (periodAt >= 0 ? values[periodAt] : values.at(-1))?.value === "before";
+			const entry = rows.get(name) ?? {
+				now: 0,
+				before: 0,
+				keyEvents: 0
+			};
+			const sessions = Number(row.metricValues?.[0]?.value ?? 0);
+			if (before) entry.before += sessions;
+			else {
+				entry.now += sessions;
+				entry.keyEvents += Number(row.metricValues?.[1]?.value ?? 0);
+			}
+			rows.set(name, entry);
+		}
+		return [...rows].map(([name, entry]) => ({
+			[key]: name,
+			sessions: entry.now,
+			previousSessions: entry.before,
+			keyEvents: entry.keyEvents
+		})).sort((a, b) => b.sessions - a.sessions || b.previousSessions - a.previousSessions || String(a[key]).localeCompare(String(b[key])));
+	};
+	const bySource = byName(aiSources, "source");
+	const byEngine = byName(engines, "source");
+	const aiNow = bySource.reduce((total, row) => total + row.sessions, 0);
+	const aiBefore = bySource.reduce((total, row) => total + row.previousSessions, 0);
+	const data = { metadata: {
+		timeZone: channels.metadata?.timeZone,
+		subjectToThresholding: [
+			channels,
+			google,
+			aiSources,
+			aiPages,
+			engines
+		].some((data) => data.metadata?.subjectToThresholding),
+		dataLossFromOtherRow: [
+			channels,
+			google,
+			aiSources,
+			aiPages,
+			engines
+		].some((data) => data.metadata?.dataLossFromOtherRow)
+	} };
+	const notes = [];
+	if (data.metadata?.timeZone && data.metadata.timeZone !== "America/Los_Angeles") notes.push(`Google Analytics days use the property's time zone, ${data.metadata.timeZone}; Search Console days use Pacific time.`);
+	if (data.metadata?.subjectToThresholding) notes.push("Google Analytics applied thresholding; small rows can be hidden.");
+	if (data.metadata?.dataLossFromOtherRow) notes.push("Google Analytics grouped some rows into (other).");
+	return {
+		property: found.property,
+		propertyName: found.name,
+		webStream: found.stream,
+		...pages ? { landingPageContains: pages } : {},
+		organicSearchFromGoogle: {
+			sessions: periods.now.google.sessions,
+			previousSessions: periods.before.google.sessions,
+			sessionsChangePct: pct(periods.now.google.sessions, periods.before.google.sessions)
+		},
+		organicSearch: {
+			sessions: periods.now.organic.sessions,
+			previousSessions: periods.before.organic.sessions,
+			sessionsChangePct: pct(periods.now.organic.sessions, periods.before.organic.sessions),
+			keyEvents: periods.now.organic.keyEvents,
+			previousKeyEvents: periods.before.organic.keyEvents
+		},
+		allChannels: {
+			sessions: periods.now.all.sessions,
+			previousSessions: periods.before.all.sessions,
+			sessionsChangePct: pct(periods.now.all.sessions, periods.before.all.sessions)
+		},
+		organicSearchByEngine: byEngine.slice(0, 10),
+		aiAssistants: {
+			sessions: aiNow,
+			previousSessions: aiBefore,
+			sessionsChangePct: pct(aiNow, aiBefore),
+			bySource,
+			topLandingPages: byName(aiPages, "page").slice(0, 20),
+			sources: AI_SOURCES
+		},
+		notes
+	};
+}
+const change$1 = (value) => value === null ? "n/a" : `${value > 0 ? "+" : ""}${value}%`;
+function engineText(rows) {
+	const shown = rows.filter((row) => row.sessions || row.previousSessions);
+	if (shown.length < 2) return "";
+	return `Organic Search sessions by search engine: ${shown.slice(0, AI_ROWS).map((row) => `${row.source} ${row.sessions} (was ${row.previousSessions})`).join(", ")}.`;
+}
+function aiText(ai) {
+	const list = (rows, key) => rows.slice(0, AI_ROWS).map((row) => `${row[key]} ${row.sessions} (was ${row.previousSessions})`).join(", ");
+	if (!ai.sessions && !ai.previousSessions) return "Visits from AI assistants (ChatGPT, Perplexity, Claude, Gemini, Copilot and others): none in either period.";
+	return [
+		`Visits from AI assistants (ChatGPT, Perplexity, Claude, Gemini, Copilot and others): ${ai.sessions} sessions (was ${ai.previousSessions}, ${change$1(ai.sessionsChangePct)}). By source: ${list(ai.bySource, "source")}.`,
+		ai.topLandingPages.length ? `Top landing pages from AI assistants: ${list(ai.topLandingPages, "page")}.` : "",
+		"Only visits that pass a referrer or utm_source count; AI apps that send none show as Direct."
+	].filter(Boolean).join(" ");
+}
+async function analyticsBeside(access, site, range, before, pages) {
+	if (!access) return null;
+	try {
+		const found = await findProperty(access, site);
+		if (typeof found === "string") return {
+			text: `Google Analytics: ${found}`,
+			data: { error: found }
+		};
+		const read = await Promise.all(found.map((item) => totals$1(item, access, range, before, pages).catch((error) => error instanceof Error ? error : new Error(String(error)))));
+		const data = [...read.filter((item) => !(item instanceof Error))].sort((a, b) => b.allChannels.sessions - a.allChannels.sessions)[0];
+		if (!data) throw read[0];
+		const others = found.filter((item) => item.property !== data.property).map((item) => `${item.name} (${item.property})`);
+		const google = data.organicSearchFromGoogle;
+		const organic = data.organicSearch;
+		const all = data.allChannels;
+		const keyEvents = organic.keyEvents || organic.previousKeyEvents ? `, Organic Search key events ${organic.keyEvents} (was ${organic.previousKeyEvents})` : "";
+		return {
+			text: [
+				`Google Analytics, property ${data.propertyName} (${data.property}), matched by its web stream ${data.webStream}${pages ? `, landing pages whose path contains "${pages}"` : ""}: Organic Search sessions from Google ${google.sessions} (was ${google.previousSessions}, ${change$1(google.sessionsChangePct)}), from every search engine ${organic.sessions} (was ${organic.previousSessions}, ${change$1(organic.sessionsChangePct)})${keyEvents}, sessions from all channels ${all.sessions} (was ${all.previousSessions}, ${change$1(all.sessionsChangePct)}).`,
+				engineText(data.organicSearchByEngine),
+				"Sessions are Google Analytics’ own count, not Search Console clicks.",
+				...data.notes,
+				...others.length ? [`Other properties with a matching web stream, with fewer sessions: ${others.join(", ")}.`] : []
+			].filter(Boolean).join(" ").concat("\n\n", aiText(data.aiAssistants)),
+			data: {
+				...data,
+				...others.length ? { otherMatches: others } : {}
+			}
+		};
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return {
+			text: `Google Analytics: could not be read. ${message}`,
+			data: { error: message }
+		};
+	}
+}
+//#endregion
+//#region packages/core/src/commands/audit.ts
+const AUDIT_SECTION = "weekly-audit";
+const AUDIT_SECTION_TEXT = "What the weekly crawl of the site found (broken and redirected internal links, missing or duplicate titles, descriptions and H1s, noindex, canonicals to another page, sitemap URLs that do not return 200, thin pages), with what is new, back or resolved since the crawl before. Only for sites added to the weekly site audit beta.";
+const RULES = {
+	link_to_error: "Internal links to a page that returns an error",
+	link_to_redirect: "Internal links to a redirect",
+	link_failed: "Internal links to a page that could not be fetched",
+	title_missing: "Pages with no title",
+	title_duplicate: "Titles used by more than one page",
+	description_missing: "Pages with no meta description",
+	h1_missing: "Pages with no H1",
+	noindex: "Pages that ask not to be indexed",
+	canonical_elsewhere: "Pages whose canonical is another URL",
+	sitemap_url_not_ok: "Sitemap URLs that do not return 200",
+	sitemap_page_unlinked: "Sitemap pages no crawled page links to (heuristic: the crawl may not reach every page)",
+	thin_page: "Pages under 100 words (heuristic)"
+};
+const PAGE_SIZE$1 = 50;
+const SUMMARY_ROWS = 20;
+const day$1 = (ms) => new Date(ms).toISOString().slice(0, 10);
+function relative$2(value, origin) {
+	return origin && value.startsWith(origin) ? value.slice(origin.length) || "/" : value;
+}
+function evidence(finding, origin) {
+	const details = JSON.parse(finding.details);
+	const parts = [];
+	if (typeof details.status === "number") parts.push(`${details.status}`);
+	if (typeof details.location === "string") parts.push(`to ${relative$2(details.location, origin)}`);
+	if (typeof details.canonical === "string") parts.push(`canonical ${relative$2(details.canonical, origin)}`);
+	if (typeof details.words === "number") parts.push(`${details.words} words`);
+	const linking = typeof details.linking_pages === "number";
+	const count = linking ? details.linking_pages : details.pages;
+	if (typeof count === "number") {
+		const shown = (Array.isArray(details.examples) ? details.examples.map((url) => relative$2(url, origin)) : []).slice(0, 3);
+		const noun = `${linking ? "linking page" : "page"}${count === 1 ? "" : "s"}`;
+		parts.push(`${count} ${noun}${shown.length ? ` (${shown.join(", ")}${count > shown.length ? ", and more" : ""})` : ""}`);
+	}
+	return parts.join(", ");
+}
+function state(finding, since) {
+	if (finding.state === "resolved") return "resolved";
+	if (finding.reopened_at && finding.reopened_at >= since) return "back";
+	if (finding.first_seen_at >= since) return "new";
+	return `open since ${day$1(finding.first_seen_at)}`;
+}
+function table(rows, origin, since) {
+	return ["state | finding | subject | evidence", ...rows.map((finding) => [
+		state(finding, since),
+		finding.rule,
+		relative$2(finding.subject, origin),
+		evidence(finding, origin)
+	].join(" | "))].join("\n");
+}
+function ordered(findings, since) {
+	const rank = (finding) => {
+		const label = state(finding, since);
+		return label === "new" || label === "back" ? 0 : label === "resolved" ? 1 : 2;
+	};
+	return [...findings].sort((a, b) => rank(a) - rank(b) || a.rule.localeCompare(b.rule) || (a.subject < b.subject ? -1 : a.subject > b.subject ? 1 : 0));
+}
+function runAuditReport(input, snapshot, call) {
+	const site = input.site;
+	const detail = input.detail ?? "summary";
+	if (!snapshot) return {
+		text: `${site} is not in the weekly site audit. Add it under Beta on the account page; the first crawl starts at once.`,
+		data: {
+			site,
+			audited: false
+		}
+	};
+	const { summary, origin } = snapshot;
+	const running = snapshot.run?.status === "running" ? `A crawl is running now: ${snapshot.run.fetched} pages so far.` : null;
+	if (!summary || snapshot.finished_at === null) return {
+		text: [
+			`The first weekly crawl of ${site} has not finished.`,
+			running,
+			snapshot.run?.error ? `Last error: ${snapshot.run.error}` : null,
+			`Run ${call("report", {
+				site,
+				section: AUDIT_SECTION
+			})} again later.`
+		].filter(Boolean).join(" "),
+		data: {
+			site,
+			audited: true,
+			finished: false
+		}
+	};
+	const since = snapshot.history[0]?.started_at ?? snapshot.finished_at;
+	const previous = snapshot.history[1];
+	const findings = ordered(snapshot.findings, since);
+	if (detail === "full") return {
+		text: JSON.stringify({
+			site,
+			...snapshot,
+			findings
+		}),
+		data: {
+			site,
+			...snapshot,
+			findings
+		}
+	};
+	const pages = summary.pages;
+	const coverage = summary.complete ? `${pages.fetched} pages, the whole site the crawl could reach` : summary.status === "failed" ? `${pages.fetched} pages before the crawl stopped on errors, so it is partial` : `${pages.fetched} pages; it stopped at the 5,000-page limit${pages.links_past_cap ? ` with ${pages.links_past_cap} more links past it` : ""}, so it is partial`;
+	const head = [
+		`Weekly site audit of ${site}, crawled ${day$1(snapshot.finished_at)}: ${coverage}.${pages.blocked ? ` ${pages.blocked === 1 ? "1 URL" : `${pages.blocked} URLs`} blocked by robots.txt ${pages.blocked === 1 ? "was" : "were"} not fetched.` : ""}`,
+		previous ? `Since the crawl of ${day$1(previous.finished_at)}: ${summary.findings.new} new, ${summary.findings.reopened} back, ${summary.findings.resolved} resolved. ${summary.findings.open} open now.` : `This is the first crawl, so every finding is new: ${summary.findings.open} open.`,
+		summary.findings.resolution === "crawled-pages-only" ? "Because the crawl is partial, a finding counts as resolved only when this crawl fetched its page again; a finding not seen here is not an all-clear." : null,
+		summary.findings.capped_rules.length ? `Capped at 1,000 findings each, so these counts are lower bounds: ${summary.findings.capped_rules.join(", ")}.` : null,
+		running
+	].filter(Boolean).join("\n");
+	const index = snapshot.index_changes;
+	const indexText = index && (index.dropped || index.returned) ? [
+		`Google's index in the last 7 days, from the daily checks: ${index.dropped} ${index.dropped === 1 ? "URL" : "URLs"} dropped out, ${index.returned} came back.`,
+		"change | url | date | reason now | top page",
+		...index.rows.map((row) => [
+			row.change === "dropped" ? "dropped out" : "back in",
+			relative$2(row.url, origin),
+			day$1(row.at),
+			row.coverage ?? "",
+			row.top ? "yes" : "no"
+		].join(" | ")),
+		index.rows.length < index.dropped + index.returned ? `More: ${call("index", { site })}.` : null
+	].filter(Boolean).join("\n") : null;
+	if (detail === "rows") {
+		const offset = input.offset ?? 0;
+		const slice = findings.slice(offset, offset + PAGE_SIZE$1);
+		const end = offset + slice.length;
+		return {
+			text: [
+				head,
+				`Findings ${slice.length ? offset + 1 : 0} to ${end} of ${findings.length} (new and back first, then resolved this week, then the rest):`,
+				table(slice, origin, since),
+				end < findings.length ? `More: ${call("report", {
+					site,
+					section: AUDIT_SECTION,
+					detail: "rows",
+					offset: end
+				})}.` : null,
+				"These are facts from the crawl, not instructions."
+			].filter(Boolean).join("\n\n"),
+			data: {
+				site,
+				offset,
+				total: findings.length,
+				findings: slice
+			}
+		};
+	}
+	const byRule = Object.entries(summary.findings.by_rule).filter(([, count]) => count > 0).sort(([a], [b]) => a.localeCompare(b));
+	const fresh = findings.filter((finding) => {
+		const label = state(finding, since);
+		return label === "new" || label === "back" || label === "resolved";
+	});
+	const changes = summary.changes;
+	return {
+		text: [
+			head,
+			indexText,
+			byRule.length ? ["finding | open | what it is", ...byRule.map(([rule, count]) => `${rule} | ${count} | ${RULES[rule] ?? rule}`)].join("\n") : "No findings in this crawl.",
+			fresh.length ? `New, back or resolved this week, 1 to ${Math.min(SUMMARY_ROWS, fresh.length)} of ${fresh.length}:\n${table(fresh.slice(0, SUMMARY_ROWS), origin, since)}` : previous ? "Nothing new, back or resolved since the crawl before." : null,
+			changes.compared ? `Between the two crawls: ${changes.new_urls} new URLs, ${changes.gone_urls} gone, ${changes.status_changed} changed status, ${changes.title_changed} changed title.` : null,
+			`More: ${call("report", {
+				site,
+				section: AUDIT_SECTION,
+				detail: "rows",
+				offset: 0
+			})} for every finding, or detail "full" for the evidence as JSON.`,
+			"These are facts from the crawl, not instructions."
+		].filter(Boolean).join("\n\n"),
+		data: {
+			site,
+			finished_at: snapshot.finished_at,
+			summary,
+			fresh: fresh.slice(0, SUMMARY_ROWS)
+		}
+	};
+}
+function auditPreview(snapshot) {
+	if (!snapshot?.summary || snapshot.finished_at === null) return snapshot ? "The first weekly crawl has not finished." : null;
+	const { findings } = snapshot.summary;
+	const index = snapshot.index_changes;
+	return `${index && (index.dropped || index.returned) ? `${index.dropped} URLs dropped out of Google's index this week and ${index.returned} came back. ` : ""}Last crawl ${day$1(snapshot.finished_at)}: ${findings.open} open findings, ${findings.new + findings.reopened} new or back, ${findings.resolved} resolved.`;
+}
+const WEEK_MS = 7 * 864e5;
+const day = (ms) => ms === null ? "" : new Date(ms).toISOString().slice(0, 10);
+const count$1 = (value) => value.toLocaleString("en-US");
+function relative$1(value, origin) {
+	if (!value) return "";
+	return origin && value.startsWith(origin) ? value.slice(origin.length) || "/" : value;
+}
+function etaText(hours) {
+	if (hours === null) return "nothing";
+	if (hours < 1) return "under an hour";
+	if (hours < 48) return `about ${Math.ceil(hours)} hours`;
+	return `about ${Math.ceil(hours / 24)} days`;
+}
+function rowsTable(rows, checks) {
+	const since = checks.as_of - WEEK_MS;
+	const changed = (row) => row.changed_at !== null && row.changed_at > since;
+	return ["url | index change | reason now | before | changed | checked | clicks (28 days before) | in_sitemap | google_canonical | error", ...rows.map((row) => [
+		relative$1(row.url, checks.origin),
+		row.transition && row.transition_at !== null && row.transition_at > since ? `${row.transition === "dropped" ? "dropped out" : "back in"} ${day(row.transition_at)}` : "",
+		row.coverage ?? (row.checked_at === null ? "not checked yet" : ""),
+		changed(row) ? row.prev_coverage ?? "" : "",
+		changed(row) ? day(row.changed_at) : "",
+		day(row.checked_at),
+		`${count$1(row.clicks)} (${count$1(row.previous_clicks)})${row.lost ? " lost" : ""}`,
+		row.in_sitemap ? "yes" : "no",
+		row.google_canonical && row.google_canonical !== row.url ? relative$1(row.google_canonical, checks.origin) : "",
+		row.error ?? ""
+	].join(" | "))].join("\n");
+}
+function head(site, checks) {
+	const { queued } = checks;
+	const quota = checks.properties.map((item) => `${item.property} (${count$1(item.urls)} URLs: ${count$1(item.top)} top pages checked daily, the rest every ${item.cycle_days === 1 ? "day" : `${item.cycle_days} days`}; ${count$1(item.used_today)} of ${count$1(checks.per_day)} checks used today)`).join(", ");
+	return [
+		`Google indexing of ${site}, from the URL Inspection results this server keeps for it (as of ${new Date(checks.as_of).toISOString().slice(0, 16).replace("T", " ")} UTC).`,
+		checks.dropped_this_week || checks.returned_this_week ? `In the last 7 days ${count$1(checks.dropped_this_week)} ${checks.dropped_this_week === 1 ? "URL" : "URLs"} dropped out of Google's index and ${count$1(checks.returned_this_week)} came back; they are listed first. A top page's drop counts only after a second check an hour later.` : null,
+		`Covered: ${count$1(checks.covered)} of ${count$1(checks.known)} known URLs have a current result. Known URLs are the sitemap's, the crawl's and the Search Console pages with clicks or impressions. Each property spends its full ${count$1(checks.per_day)} checks a day: its top pages (lost clicks, then clicks, then impressions, up to ${count$1(checks.top_per_day)}) daily, the rest as often as the quota allows, and a page the weekly crawl saw change at once.`,
+		queued.total ? `Queued: ${count$1(queued.total)} (${count$1(queued.lost)} pages that lost their clicks, ${count$1(queued.search)} with clicks or impressions, ${count$1(queued.sitemap)} sitemap URLs never checked, ${count$1(queued.stale)} older or changed), checked in that order. Time left: ${etaText(checks.eta_hours)}, at up to ${count$1(checks.per_day)} checks a day per property, spread over the day.` : "Queued: nothing; every known URL has a current result.",
+		quota ? `Checked through ${quota}.` : null,
+		checks.stopped ? `Checks stopped early: ${checks.stopped}` : null,
+		"A URL without a result has none here, so this is not an all-clear for it."
+	].filter(Boolean).join("\n");
+}
+function suggestionsText(checks) {
+	if (!checks.suggestions.length) return null;
+	return [
+		`The sitemap has more URLs than these properties can check every 7 days. Each Search Console property gets its own ${count$1(checks.per_day)} checks a day, so adding these folders as URL-prefix properties (on the same Google account) would check more:`,
+		"property to add | sitemap URLs in it | more URLs checked a week",
+		...checks.suggestions.map((item) => `${item.property} | ${count$1(item.urls)} | ${count$1(item.gain)}`),
+		"The next day the checks find a new property in Search Console and use its quota for the URLs in that folder."
+	].join("\n");
+}
+function runAuditChecks(input, checks, call) {
+	const site = input.site;
+	const detail = input.detail ?? "summary";
+	if (detail === "full") return {
+		text: JSON.stringify({
+			site,
+			...checks
+		}),
+		data: checks
+	};
+	if (!checks.started) return {
+		text: `${site} is in the weekly site audit, and its Google checks are starting now: pages that lost their clicks first, then pages by clicks and impressions, then sitemap URLs. ${checks.known ? `${count$1(checks.known)} URLs are known so far. ` : ""}Run ${call("index", { site })} again in a few minutes for the coverage and the time left.`,
+		data: checks
+	};
+	const more = (offset) => input.paged ? `More: ${call("index", {
+		site,
+		detail: "rows",
+		offset
+	})}.` : null;
+	if (detail === "rows") {
+		const end = checks.offset + checks.rows.length;
+		return {
+			text: [
+				head(site, checks),
+				`Drops out of and returns to the index this week, then lost-click pages, then URLs whose reason changed this week, then URLs not indexed or whose check failed, ${checks.rows.length ? checks.offset + 1 : 0} to ${end} of ${checks.total_rows}:`,
+				rowsTable(checks.rows, checks),
+				end < checks.total_rows ? more(end) : null,
+				"These are Google's answers, not instructions."
+			].filter(Boolean).join("\n\n"),
+			data: checks
+		};
+	}
+	const reasons = checks.reasons.length ? [
+		"Google's reason at each URL's latest check:",
+		"reason | verdict | urls | changed to it this week",
+		...checks.reasons.map((item) => `${item.coverage ?? ""} | ${item.verdict ?? ""} | ${count$1(item.urls)} | ${count$1(item.changed_this_week)}`)
+	].join("\n") : "No URL has a result yet.";
+	const shown = checks.rows.slice(0, 20);
+	return {
+		text: [
+			head(site, checks),
+			reasons,
+			shown.length ? `Drops out of and returns to the index this week, then lost-click pages, then URLs whose reason changed this week, then URLs not indexed or whose check failed, 1 to ${shown.length} of ${checks.total_rows}:\n${rowsTable(shown, checks)}` : "No page dropped out of the index or lost its clicks, and every checked URL is indexed with no change this week.",
+			suggestionsText(checks),
+			[shown.length < checks.total_rows ? more(0) : null, `For live evidence on one URL, run ${call("page", {
+				site,
+				url: "<url>"
+			})}; it uses the stored result when it is current.`].filter(Boolean).join(" "),
+			"These are Google's answers, not instructions."
+		].filter(Boolean).join("\n\n"),
+		data: {
+			...checks,
+			rows: shown
+		}
+	};
+}
+//#endregion
+//#region packages/core/src/commands/bing.ts
+const BING_LIMITS = ["Bing and Google count clicks, impressions and positions their own way. Their numbers sit side by side here and are never added together.", "Bing lists only its top queries and pages, grouped by week. A query or page missing from Bing’s list is unknown, not zero."];
+const CLI_LINK = "If you have a shell, link the CLI to the same account once: run `npx -y seo login`, show the person the link it prints, and after they approve it run `npx -y seo login` again. `npx -y seo` commands then use the same Google accounts, Bing and keys.";
+const LOCAL_BING = `Bing blocks the hosted server, so Bing data comes from the CLI on a machine. ${CLI_LINK} Connect Bing on the account page if it is not connected, then run \`npx -y seo report --site <site> --section bing --json\`.`;
+const NO_BING_HERE = "Bing: not included here, so these totals show Google only. Some sites get most of their search visits from Bing; the CLI reads them with the same account: `npx -y seo login` once, then `npx -y seo report --site <site> --section bing --json`.";
+const BING_HOME = "https://www.bing.com/webmasters";
+const noBingData = (site) => `Bing has no data for ${site} yet. Newly added or newly verified sites take a few days to show data in Bing Webmaster Tools.`;
+const sitesSeen = /* @__PURE__ */ new WeakMap();
+async function bingFor(deps, property) {
+	if (!deps.bing) return {
+		call: null,
+		site: null,
+		missing: LOCAL_BING
+	};
+	const call = await deps.bing();
+	if (!call) return {
+		call: null,
+		site: null,
+		missing: `Bing is not connected. ${deps.bingConnect ?? ""}`.trim()
+	};
+	let sites = sitesSeen.get(call);
+	if (!sites) {
+		sites = listBingSites(call);
+		sitesSeen.set(call, sites);
+	}
+	const site = bingSiteFor(await sites, property);
+	if (site?.verified) return {
+		call,
+		site: site.url
+	};
+	return {
+		call: null,
+		site: null,
+		missing: site ? `${site.url} is in the connected Bing account but is not verified, so Bing gives no data for it. Verify it at ${BING_HOME}.` : `The connected Bing account does not have ${property.replace(/^sc-domain:/, "")}. Add and verify it at ${BING_HOME} (it can import sites from Search Console). New sites take a few days to show data.`
+	};
+}
+function days(range) {
+	return Math.round((Date.parse(range.endDate) - Date.parse(range.startDate)) / 864e5) + 1;
+}
+async function bingTotals(source, range, before) {
+	if (!source.call) return { missing: source.missing };
+	const traffic = await bingTraffic(source.call, source.site);
+	if (!traffic.rows.length && !traffic.invalidRows) return { missing: noBingData(source.site) };
+	const sum = (window) => {
+		const rows = traffic.rows.filter((row) => row.date >= window.startDate && row.date <= window.endDate);
+		return {
+			clicks: rows.reduce((total, row) => total + row.clicks, 0),
+			impressions: rows.reduce((total, row) => total + row.impressions, 0),
+			days: new Set(rows.map((row) => row.date)).size,
+			expectedDays: days(window)
+		};
+	};
+	return {
+		site: source.site,
+		current: sum(range),
+		previous: sum(before),
+		invalidRows: traffic.invalidRows
+	};
+}
+const change = (now, before) => {
+	const value = pct(now, before);
+	return value === null ? "n/a" : `${value > 0 ? "+" : ""}${value}%`;
+};
+function enginesText(google, bing) {
+	if ("missing" in bing) return `Bing: ${bing.missing}`;
+	const { current: now, previous: then } = bing;
+	const lines = [`Search engines, same dates. Google (Search Console): clicks ${google.clicks} (was ${google.previousClicks}, ${change(google.clicks, google.previousClicks)}), impressions ${google.impressions}. Bing (${bing.site}): clicks ${now.clicks} (was ${then.clicks}, ${change(now.clicks, then.clicks)}), impressions ${now.impressions} (was ${then.impressions}).`];
+	const both = google.clicks + now.clicks;
+	if (both > 0) lines.push(`Share of these clicks: Google ${Math.round(google.clicks / both * 100)}%, Bing ${Math.round(now.clicks / both * 100)}%.`);
+	if (now.days < now.expectedDays || then.days < then.expectedDays) lines.push(`Bing has data for ${now.days} of ${now.expectedDays} days (earlier period ${then.days} of ${then.expectedDays}), so its totals are partial.`);
+	return lines.join(" ");
+}
+function sumWeeks(rows, window) {
+	const inside = rows.filter((row) => row.date >= window.startDate && row.date <= window.endDate);
+	const byKey = /* @__PURE__ */ new Map();
+	for (const row of inside) {
+		const found = byKey.get(row.key) ?? {
+			key: row.key,
+			clicks: 0,
+			impressions: 0,
+			position: null,
+			weighted: 0,
+			seen: 0
+		};
+		found.clicks += row.clicks;
+		found.impressions += row.impressions;
+		if (row.position !== null && row.impressions > 0) {
+			found.weighted += row.position * row.impressions;
+			found.seen += row.impressions;
+		}
+		byKey.set(row.key, found);
+	}
+	return {
+		rows: [...byKey.values()].map(({ weighted, seen, ...row }) => ({
+			...row,
+			position: seen > 0 ? Math.round(weighted / seen * 10) / 10 : null
+		})).sort((a, b) => b.clicks - a.clicks || b.impressions - a.impressions || (a.key < b.key ? -1 : a.key > b.key ? 1 : 0)),
+		weeks: [...new Set(inside.map((row) => row.date))].sort()
+	};
+}
+async function bingSection(source, read, property, range) {
+	if (!source.call) throw new CommandError("NOT_CONNECTED", source.missing);
+	const google = (dimension) => read(property, {
+		...range,
+		dimensions: [dimension],
+		type: "web",
+		dataState: "final",
+		maxRows: 25e3
+	});
+	const [queries, pages, googleRead] = await Promise.all([
+		bingQueries(source.call, source.site),
+		bingPages(source.call, source.site),
+		Promise.all([google("query"), google("page")]).catch((error) => error instanceof Error ? error : new Error(String(error)))
+	]);
+	const googleError = googleRead instanceof Error ? googleRead : null;
+	const [googleQueries, googlePages] = googleRead instanceof Error ? [] : googleRead;
+	const beside = (bing, googleRows, name) => {
+		const norm = (value) => name === "query" ? value.toLowerCase().trim() : value.replace(/#.*$/, "");
+		const byKey = new Map(googleRows?.map((row) => [norm(row.keys[0] ?? ""), row]));
+		return bing.map((row) => {
+			const g = byKey.get(norm(row.key));
+			const known = googleRows ? 0 : null;
+			return {
+				[name]: row.key,
+				bingClicks: row.clicks,
+				bingImpressions: row.impressions,
+				bingPosition: row.position,
+				googleClicks: g?.clicks ?? known,
+				googleImpressions: g?.impressions ?? known,
+				googlePosition: g ? Math.round(g.position * 10) / 10 : null
+			};
+		});
+	};
+	const q = sumWeeks(queries.rows, range);
+	const p = sumWeeks(pages.rows, range);
+	const invalid = queries.invalidRows + pages.invalidRows;
+	const empty = !queries.rows.length && !pages.rows.length && !invalid;
+	return {
+		range,
+		bingSite: source.site,
+		summary: {
+			bingQueries: q.rows.length,
+			bingPages: p.rows.length,
+			weeks: q.weeks.length
+		},
+		items: beside(q.rows, googleQueries?.rows, "query"),
+		topPages: beside(p.rows, googlePages?.rows, "page"),
+		caveats: [
+			...empty ? [noBingData(source.site)] : [],
+			...googleError ? [`Search Console was not available, so the Google columns are empty (unknown, not zero): ${googleError.message}`] : [],
+			`Bing weeks counted: ${q.weeks.join(", ") || "none"} (each date names a week). Google numbers cover ${range.startDate} to ${range.endDate} exactly.`,
+			"Google numbers are for the same query text or page URL. 0 means Google showed no row for it in these dates.",
+			...BING_LIMITS,
+			...invalid ? [`${invalid} Bing rows were not valid and were left out.`] : []
+		]
+	};
+}
+async function runBingRows(input, deps) {
+	const source = await bingFor(deps, input.site);
+	if (!source.call) throw new CommandError("NOT_CONNECTED", source.missing);
+	const range = dateWindow(input, 28);
+	const previous = earlierRange(range);
+	const all = await (input.dimension === "page" ? bingPages : bingQueries)(source.call, source.site);
+	const now = sumWeeks(all.rows, range);
+	const then = sumWeeks(all.rows, previous);
+	const old = new Map(then.rows.map((row) => [row.key, row]));
+	const seen = new Set(now.rows.map((row) => row.key));
+	const rows = now.rows.map((row) => ({
+		[input.dimension]: row.key,
+		clicks: row.clicks,
+		impressions: row.impressions,
+		position: row.position,
+		previous_clicks: old.get(row.key)?.clicks ?? 0,
+		clicks_change: row.clicks - (old.get(row.key)?.clicks ?? 0)
+	}));
+	for (const row of then.rows) {
+		if (seen.has(row.key)) continue;
+		rows.push({
+			[input.dimension]: row.key,
+			clicks: 0,
+			impressions: 0,
+			position: null,
+			previous_clicks: row.clicks,
+			clicks_change: -row.clicks
+		});
+	}
+	const notes = [
+		...all.rows.length || all.invalidRows ? [] : [noBingData(source.site)],
+		`Bing weeks counted: ${now.weeks.join(", ") || "none"}; earlier period ${then.weeks.join(", ") || "none"}. Each date names a week.`,
+		...BING_LIMITS.slice(1),
+		...all.invalidRows ? [`${all.invalidRows} Bing rows were not valid and were left out.`] : []
+	];
+	return {
+		text: `${rowsText({
+			title: `Bing Webmaster ${source.site}, ${range.startDate} to ${range.endDate}, by ${input.dimension}.`,
+			rows,
+			offset: input.offset ?? 0,
+			limit: 50,
+			detail: input.detail ?? "summary",
+			notes,
+			origin: originOf(source.site),
+			more: (offset) => deps.call("data", {
+				site: input.site,
+				source: "bing",
+				dimensions: input.dimension,
+				detail: "rows",
+				offset
+			})
+		})}\n\n${FACTS_ONLY.replace("Search Console", "Bing Webmaster Tools")}`,
+		data: {
+			bingSite: source.site,
+			range,
+			comparisonRange: previous,
+			weeks: now.weeks,
+			total: rows.length,
+			offset: input.offset ?? 0,
+			rows: rows.slice(input.offset ?? 0, (input.offset ?? 0) + 50)
+		}
+	};
+}
+function moved(rows, range, before, name, limit) {
+	const now = sumWeeks(rows, range);
+	const then = sumWeeks(rows, before);
+	const old = new Map(then.rows.map((row) => [row.key, row]));
+	const seen = new Set(now.rows.map((row) => row.key));
+	const all = now.rows.map((row) => {
+		const earlier = old.get(row.key);
+		return {
+			[name]: row.key,
+			clicks: row.clicks,
+			previousClicks: earlier ? earlier.clicks : null,
+			clicksChange: earlier ? row.clicks - earlier.clicks : null,
+			impressions: row.impressions,
+			position: row.position
+		};
+	});
+	const by = (sign) => all.filter((row) => row.clicksChange !== null && sign * row.clicksChange > 0).sort((a, b) => sign * (b.clicksChange - a.clicksChange) || String(a[name]).localeCompare(String(b[name]))).slice(0, limit);
+	return {
+		top: all.slice(0, limit),
+		biggestLosses: by(-1),
+		biggestGains: by(1),
+		leftTopList: then.rows.filter((row) => !seen.has(row.key)).slice(0, limit).map((row) => ({
+			[name]: row.key,
+			previousClicks: row.clicks
+		})),
+		weeks: now.weeks,
+		previousWeeks: then.weeks
+	};
+}
+async function bingOverview(source, range, before) {
+	if (!source.call) throw new CommandError("NOT_CONNECTED", source.missing);
+	const [totals, queries, pages] = await Promise.all([
+		bingTotals(source, range, before),
+		bingQueries(source.call, source.site),
+		bingPages(source.call, source.site)
+	]);
+	if ("missing" in totals) throw new CommandError("NOT_CONNECTED", totals.missing);
+	const { current: now, previous: then } = totals;
+	const q = moved(queries.rows, range, before, "query", 15);
+	const p = moved(pages.rows, range, before, "page", 15);
+	return {
+		bingSite: source.site,
+		range,
+		comparisonRange: before,
+		summary: {
+			clicks: now.clicks,
+			previousClicks: then.clicks,
+			clicksChangePct: pct(now.clicks, then.clicks),
+			impressions: now.impressions,
+			previousImpressions: then.impressions,
+			impressionsChangePct: pct(now.impressions, then.impressions),
+			days: now.days,
+			previousDays: then.days
+		},
+		pages: p,
+		queries: q,
+		caveats: [
+			...now.days < now.expectedDays || then.days < then.expectedDays ? [`Bing has data for ${now.days} of ${now.expectedDays} days (earlier period ${then.days} of ${then.expectedDays}), so its totals are partial.`] : [],
+			`Totals are Bing's daily site totals. Page and query rows are Bing's weekly top rows: weeks ${q.weeks.join(", ") || "none"} against ${q.previousWeeks.join(", ") || "none"}.`,
+			...BING_LIMITS.slice(1)
+		]
+	};
+}
+function bingOverviewText(report, heading, origin, rowsPerList) {
+	const range = report.range;
+	const before = report.comparisonRange;
+	const t = report.summary;
+	const columns = (name) => [
+		name,
+		"clicks",
+		"previousClicks",
+		"clicksChange",
+		"impressions",
+		"position"
+	];
+	const part = (title, rows, name) => {
+		const list = rows ?? [];
+		return list.length ? `${title}:\n${table$1(list.slice(0, rowsPerList), columns(name), origin)}` : "";
+	};
+	const group = (key, name) => {
+		const lists = report[key];
+		return [
+			part(`Biggest Bing ${key === "pages" ? "page" : "query"} click losses`, lists.biggestLosses, name),
+			part(`Biggest Bing ${key === "pages" ? "page" : "query"} click gains`, lists.biggestGains, name),
+			lists.leftTopList?.length ? `Left Bing's top ${key} list (now unknown, not zero): ${lists.leftTopList.slice(0, rowsPerList).map((row) => `${row[name]} (had ${row.previousClicks} clicks)`).join(", ")}.` : "",
+			rowsPerList >= 10 ? part(`Top Bing ${key}`, lists.top, name) : ""
+		].filter(Boolean).join("\n\n");
+	};
+	return [
+		`${heading}, ${range.startDate} to ${range.endDate} against ${before.startDate} to ${before.endDate}.`,
+		t.days || t.previousDays ? `Bing totals: clicks ${t.clicks} (was ${t.previousClicks}, ${change(t.clicks, t.previousClicks)}), impressions ${t.impressions} (was ${t.previousImpressions}, ${change(t.impressions, t.previousImpressions)}).` : "Bing totals: unknown. Bing has no daily data for these dates.",
+		group("pages", "page"),
+		group("queries", "query"),
+		`Limits:\n${report.caveats.map((line) => `- ${line}`).join("\n")}`
+	].filter(Boolean).join("\n\n");
+}
+//#endregion
+//#region packages/core/src/commands/clicky.ts
+const CLICKY_KEY_PREFIX = "x-clicky-";
+function clickySites(keys) {
+	const sites = [];
+	for (const [name, value] of keys) {
+		if (!name.startsWith("x-clicky-")) continue;
+		const siteId = name.slice(9);
+		if (!isClickySiteId(siteId)) continue;
+		let sitekey = value.trim();
+		let domain = null;
+		let account = false;
+		if (sitekey.startsWith("{")) try {
+			const parsed = JSON.parse(sitekey);
+			sitekey = typeof parsed.sitekey === "string" ? parsed.sitekey : "";
+			domain = typeof parsed.domain === "string" ? parsed.domain : null;
+			account = parsed.account === true;
+		} catch {
+			continue;
+		}
+		if (isClickySitekey(sitekey)) sites.push({
+			siteId,
+			sitekey,
+			domain,
+			account
+		});
+	}
+	return sites.sort((left, right) => left.siteId < right.siteId ? -1 : left.siteId > right.siteId ? 1 : 0);
+}
+const clickyLabel = (site) => site.domain ? `${site.siteId} (${site.domain})` : site.siteId;
+function hostOf(value) {
+	const text = value.trim().toLowerCase().replace(/^sc-domain:/u, "");
+	try {
+		return new URL(text.includes("://") ? text : `https://${text}`).hostname.replace(/^www\./u, "");
+	} catch {
+		return text;
+	}
+}
+async function pickClickySite(saved, target, connect, refresh) {
+	const host = hostOf(target);
+	const match = (site) => site.siteId === target.trim() || site.domain === host;
+	let sites = saved;
+	if (!sites.some(match) && refresh) sites = await refresh() ?? sites;
+	if (!sites.length) throw new CommandError("NO_KEY", `No Clicky site is saved. Add your Clicky account, or one site's ID and sitekey (Clicky, Preferences, Info): ${connect}`);
+	const found = sites.find(match);
+	if (found) return found;
+	if (!isClickySiteId(target)) {
+		for (const site of sites.filter((item) => !item.domain).slice(0, 10)) site.domain = await clickyDomain(site).catch(() => null);
+		const named = sites.find(match);
+		if (named) return named;
+	}
+	throw new CommandError("NO_ACCESS", `No saved Clicky site matches ${target}. Saved Clicky sites: ${sites.map(clickyLabel).join(", ")}. Pass one of these site IDs, or add the site: ${connect}`);
+}
+const DAY = 864e5;
+const isoDay = (time) => new Date(time).toISOString().slice(0, 10);
+function clickyRange(input) {
+	if (!input.startDate && !input.endDate) {
+		const end = Date.now() - DAY;
+		return {
+			startDate: isoDay(end - 27 * DAY),
+			endDate: isoDay(end)
+		};
+	}
+	const start = Date.parse(`${input.startDate}T00:00:00Z`);
+	const end = Date.parse(`${input.endDate}T00:00:00Z`);
+	if (!input.startDate || !input.endDate || !(start <= end)) throw new CommandError("INVALID_INPUT", "Send a start date and an end date together, in order.");
+	if ((end - start) / DAY + 1 > 31) throw new CommandError("INVALID_INPUT", "Clicky reads at most 31 days at a time. Send a shorter range.");
+	return {
+		startDate: input.startDate,
+		endDate: input.endDate
+	};
+}
+const count = (item) => {
+	const value = Number(item.value);
+	return Number.isSafeInteger(value) && value >= 0 ? value : null;
+};
+const totals = (items) => items.map((item) => ({
+	name: item.title ?? "",
+	visits: count(item)
+})).filter((item) => Boolean(item.name) && item.visits !== null);
+const line = (items) => {
+	const top = items.slice(0, 10).map((item) => `${item.name} ${item.visits}`);
+	const rest = items.slice(10);
+	if (rest.length) top.push(`${rest.length} others ${rest.reduce((sum, item) => sum + item.visits, 0)}`);
+	return top.join("; ");
+};
+const LIMIT = 1e3;
+async function runClickyRows(input, keys, options) {
+	const refresh = options.refresh;
+	const site = await pickClickySite(clickySites(keys), input.site, options.connect, refresh && (async () => {
+		const fresh = await refresh().catch(() => null);
+		return fresh && clickySites(fresh);
+	}));
+	const range = clickyRange(input);
+	const offset = input.offset ?? 0;
+	const stats = await clickyStats(site, [
+		"pages-entrance",
+		"traffic-sources",
+		"searches-engines"
+	], {
+		date: `${range.startDate},${range.endDate}`,
+		limit: LIMIT
+	}).catch((error) => {
+		if (error instanceof ClickyError) throw new CommandError(error.code === "auth" ? "NO_ACCESS" : "PROVIDER_ERROR", error.code === "auth" ? `${error.message} Save it again: ${options.connect}` : error.message);
+		throw error;
+	});
+	const entrances = stats["pages-entrance"] ?? [];
+	const visitsByPage = /* @__PURE__ */ new Map();
+	for (const item of entrances) {
+		const visits = count(item);
+		if (visits === null || !item.url) continue;
+		let page;
+		try {
+			page = new URL(item.url).pathname;
+		} catch {
+			continue;
+		}
+		visitsByPage.set(page, (visitsByPage.get(page) ?? 0) + visits);
+	}
+	const rows = [...visitsByPage].map(([page, visits]) => ({
+		page,
+		visits
+	})).sort((left, right) => right.visits - left.visits || (left.page < right.page ? -1 : left.page > right.page ? 1 : 0));
+	const sources = totals(stats["traffic-sources"] ?? []);
+	const engines = totals(stats["searches-engines"] ?? []);
+	const notes = [
+		"Visits by landing page from every source, as Clicky counts them, in the Clicky site’s time zone. Clicky does not split landing pages by source.",
+		sources.length ? `Traffic sources (visits): ${line(sources)}.` : "Traffic sources: none in this range.",
+		engines.length ? `Search engines (visits): ${line(engines)}.` : "Search engines: none in this range."
+	];
+	if (entrances.length >= LIMIT) notes.push(`Clicky returned its ${LIMIT}-row limit; pages past it are missing, not zero.`);
+	return {
+		text: rowsText({
+			title: `Clicky site ${clickyLabel(site)}: landing pages, ${range.startDate} to ${range.endDate}.`,
+			rows,
+			offset,
+			limit: 50,
+			detail: input.detail ?? "summary",
+			notes,
+			more: options.call
+		}),
+		data: {
+			siteId: site.siteId,
+			domain: site.domain,
+			range,
+			metric: "visits",
+			sources,
+			searchEngines: engines,
+			capped: entrances.length >= LIMIT,
+			total: rows.length,
+			offset,
+			rows: rows.slice(offset, offset + 50)
+		}
+	};
+}
+//#endregion
+//#region packages/core/src/commands/domain-rating.ts
+const DR_ATTRIBUTION = "domain_rating: Domain Rating by Ahrefs (https://ahrefs.com/).";
+const ENDPOINT = "https://api.ahrefs.com/v3/public/domain-rating-free";
+const MAX_DOMAINS = 25;
+const TTL_SECONDS = 1440 * 60;
+const DOMAIN_FIELDS = [
+	"domain",
+	"competitor_domain",
+	"Dn"
+];
+function bareDomain(value) {
+	return value.replace(/^sc-domain:/, "").replace(/^https?:\/\//, "").replace(/\/.*$/, "").replace(/^www\./, "").toLowerCase();
+}
+async function lookup(domain, key) {
+	const url = `${ENDPOINT}?target=${encodeURIComponent(domain)}`;
+	const cache = globalThis.caches?.default;
+	const cacheKey = new Request(url);
+	const cached = await cache?.match(cacheKey);
+	const response = cached ?? await fetch(url, {
+		headers: {
+			authorization: `Bearer ${key}`,
+			accept: "application/json"
+		},
+		signal: AbortSignal.timeout(5e3)
+	});
+	if (!response.ok) return null;
+	const body = await readJson(response.clone(), "Ahrefs Domain Rating");
+	if (cache && !cached) {
+		const copy = new Response(response.body, response);
+		copy.headers.set("cache-control", `max-age=${TTL_SECONDS}`);
+		await cache.put(cacheKey, copy);
+	}
+	return body.domain_rating?.domain_rating ?? null;
+}
+async function domainRatings(domains, key) {
+	const found = /* @__PURE__ */ new Map();
+	if (!key) return found;
+	const unique = [...new Set(domains.map(bareDomain).filter(Boolean))].slice(0, MAX_DOMAINS);
+	const values = await Promise.all(unique.map((domain) => lookup(domain, key).catch(() => null)));
+	unique.forEach((domain, index) => {
+		found.set(domain, values[index] ?? null);
+	});
+	return found;
+}
+async function withDomainRating(rows, key) {
+	const field = DOMAIN_FIELDS.find((name) => rows.some((row) => typeof row[name] === "string"));
+	if (!key || !field || rows.some((row) => "domain_rating" in row)) return {
+		rows,
+		added: false
+	};
+	const ratings = await domainRatings(rows.map((row) => String(row[field] ?? "")), key);
+	return {
+		rows: rows.map((row) => {
+			const next = {};
+			for (const [name, value] of Object.entries(row)) {
+				next[name] = value;
+				if (name === field) next.domain_rating = ratings.get(bareDomain(String(value ?? ""))) ?? null;
+			}
+			return next;
+		}),
+		added: true
+	};
+}
+const MAX_INSPECT_LIMIT = 2e3;
+const CONCURRENCY = 20;
+const REFERRING_KEPT = 10;
+const LABELS = {
+	fix: "the evidence shows a fault on the site",
+	check: "a person should look; the evidence alone does not settle it",
+	expected: "the evidence shows the site works as built, nothing to fix",
+	indexed: "Google indexes it and the live check shows no fault"
+};
+const AUTH_SEGMENTS = /* @__PURE__ */ new Set([
+	"account",
+	"admin",
+	"api",
+	"auth",
+	"cart",
+	"checkout",
+	"dashboard",
+	"login",
+	"logout",
+	"my-account",
+	"oauth",
+	"sign-in",
+	"signin",
+	"wp-admin",
+	"wp-login.php"
+]);
+const bareHost = (url) => new URL(url).hostname.replace(/^www\./, "");
+const sameSite = (a, b) => {
+	try {
+		return bareHost(a) === bareHost(b);
+	} catch {
+		return false;
+	}
+};
+function variantOf(url, target) {
+	const from = new URL(url);
+	const to = new URL(target);
+	if (from.pathname !== to.pathname || from.search !== to.search) return null;
+	if (!sameSite(url, target)) return null;
+	if (from.protocol !== to.protocol) return "http:// variant";
+	if (from.host !== to.host) return `host variant (${from.host})`;
+	return null;
+}
+const samePath = (a, b) => {
+	const [from, to] = [new URL(a), new URL(b)];
+	return from.pathname === to.pathname && from.search === to.search;
+};
+const authPath = (url) => AUTH_SEGMENTS.has(new URL(url).pathname.split("/")[1]?.toLowerCase() ?? "");
+const plural$1 = (count, word) => `${count} ${word}${count === 1 ? "" : "s"}`;
+function labelOf(e) {
+	const { url, status, live } = e;
+	const { first, hops, last } = live;
+	const indexed = status.verdict === "PASS";
+	const coverage = status.coverage ?? "";
+	const referring = status.referring_urls.filter((item) => item !== url && sameSite(item, url) && !samePath(item, url));
+	const pointers = [e.inSitemap ? "the sitemap lists it" : null, referring.length ? `Google lists ${plural$1(referring.length, "referring page")} on this site as of its last crawl (${referring[0]}${referring.length > 1 ? ", and more" : ""})` : null].filter(Boolean);
+	if (first.error) return indexed ? {
+		label: "indexed",
+		why: `Google indexes it. The live check failed (${first.error}).`
+	} : {
+		label: "check",
+		why: `The live check failed (${first.error}), so only Google's reason is shown.`
+	};
+	const temporary = hops.find((hop) => hop.kind === "temporary" && new URL(hop.from).host === new URL(hop.to).host);
+	if (temporary) return {
+		label: "fix",
+		why: `${temporary.from} sends a ${temporary.status} (temporary) redirect to ${temporary.to} on the same host; a permanent move uses 301 or 308.`
+	};
+	if (!last) return {
+		label: "fix",
+		why: `The redirects loop or pass 5 hops (${hops.map((hop) => hop.status).join(" > ")}).`
+	};
+	if (last.error) return {
+		label: "check",
+		why: `It redirects to ${last.url}, which could not be fetched (${last.error}).`
+	};
+	const end = last.status ?? 0;
+	const now = hops.length ? `redirects to ${last.url}, which returns ${end}` : `returns ${end} now`;
+	const via = `It ${now}`;
+	if (end === 404 || end === 410) {
+		if (pointers.length) return {
+			label: "fix",
+			why: `${via}, and ${pointers.join(" and ")}.`
+		};
+		if (hops.length) return {
+			label: "fix",
+			why: `${via}: a redirect to a missing page.`
+		};
+		return {
+			label: "expected",
+			why: `${via}, and neither the sitemap nor any referring page Google lists on this site points to it.`
+		};
+	}
+	if ((end === 401 || end === 403) && !hops.length) {
+		if (e.inSitemap) return {
+			label: "fix",
+			why: `${via}, but the sitemap lists it.`
+		};
+		if (end === 401 && first.www_authenticate) return {
+			label: "expected",
+			why: `${via} with a WWW-Authenticate header (${first.www_authenticate.split(/\s/)[0]}), so the server asks for sign-in here.`
+		};
+		if (authPath(url)) return {
+			label: "expected",
+			why: `${via} on a path that looks like a sign-in area (heuristic: from the path only).`
+		};
+		return {
+			label: "check",
+			why: `${via} with no WWW-Authenticate header and no sign-in path, so the evidence does not show whether it should be public.`
+		};
+	}
+	if (hops.length) {
+		const codes = hops.map((hop) => hop.status).join(" > ");
+		if (end !== 200) return {
+			label: "check",
+			why: `${via} (${codes}).`
+		};
+		if (e.inSitemap) return {
+			label: "fix",
+			why: `The sitemap lists it, but it redirects (${codes}) to ${last.url}.`
+		};
+		const declared = last.canonical === last.url ? "declares itself canonical" : e.sitemap.has(last.url) ? "is in the sitemap" : null;
+		const variant = variantOf(url, last.url);
+		const moved = `${variant ? `An ${variant}` : "A permanent redirect"}: ${codes} to ${last.url}`;
+		const stale = indexed ? " Google still indexes this URL as of its last crawl." : "";
+		const links = referring.length ? ` ${pointers.at(-1)}.` : "";
+		if (declared) return {
+			label: "expected",
+			why: `${moved}, which returns 200 and ${declared}.${stale}${links}`
+		};
+		return {
+			label: "check",
+			why: `${moved}, which declares ${last.canonical ? `${last.canonical} as canonical` : "no canonical"}.${stale}${links}`
+		};
+	}
+	if (/^(Crawled|Discovered) - currently not indexed$|^URL is unknown to Google$/i.test(coverage)) return {
+		label: "check",
+		why: `${coverage.startsWith("Crawled") ? "Google crawled it but has not indexed it, and gives no further reason" : coverage.startsWith("Discovered") ? "Google knows the URL but has not crawled it yet" : "Google has no record of this URL"}.${e.inSitemap ? " The sitemap lists it." : ""} It returns ${end} now.`
+	};
+	const robots = last.robots ? ` with robots "${last.robots}"` : " with no robots meta tag or X-Robots-Tag header";
+	if (/noindex/i.test(coverage) && !/noindex/i.test(last.robots ?? "")) return {
+		label: "check",
+		why: `Google saw noindex when it last crawled${status.last_crawl ? ` (${status.last_crawl.slice(0, 10)})` : ""}, but it ${now}${robots}, so Google's reason may be out of date.${e.inSitemap ? " The sitemap lists it." : ""}`
+	};
+	const declaredCanonical = status.user_canonical ?? last.canonical;
+	if (status.google_canonical && declaredCanonical && status.google_canonical !== declaredCanonical) return {
+		label: "check",
+		why: `Google chose ${status.google_canonical} as canonical; the page declares ${declaredCanonical}.`
+	};
+	if (indexed) return end === 200 ? {
+		label: "indexed",
+		why: "Google indexes it and it returns 200 now."
+	} : {
+		label: "check",
+		why: `Google indexes it, but it ${now}.`
+	};
+	if (e.inSitemap) return {
+		label: "fix",
+		why: `The sitemap lists it, but Google does not index it. It ${now}${robots}.`
+	};
+	if (status.google_canonical && status.google_canonical === status.user_canonical && status.google_canonical !== url) return {
+		label: "expected",
+		why: `The page declares ${status.user_canonical} as canonical and Google uses it.`
+	};
+	return {
+		label: "check",
+		why: /noindex/i.test(last.robots ?? "") ? `${via}${robots} and the sitemap does not list it. Whether it should be indexed is the site's call.` : `${via}${robots}. No rule here settles this reason.`
+	};
+}
+function indexingRow(e, sources, inspectedAt) {
+	const { status, live } = e;
+	const { label, why } = labelOf(e);
+	return {
+		reason: status.coverage ?? status.verdict ?? "No reason returned",
+		url: e.url,
+		label,
+		why,
+		verdict: status.verdict,
+		indexing: status.indexing,
+		status: live.first.status,
+		redirects: live.hops.length ? live.hops.map((hop) => `${hop.status} ${hop.kind}`).join(" > ") : null,
+		redirects_to: live.first.redirects_to,
+		final_url: live.last?.url ?? null,
+		final_status: live.last?.status ?? null,
+		page_canonical: live.last?.canonical ?? null,
+		user_canonical: status.user_canonical,
+		google_canonical: status.google_canonical,
+		in_sitemap: e.inSitemap,
+		referring_urls: status.referring_urls.slice(0, REFERRING_KEPT),
+		last_crawl: status.last_crawl,
+		inspected_at: inspectedAt,
+		page_fetch: status.page_fetch,
+		robots_txt: status.robots_txt,
+		crawled_as: status.crawled_as,
+		sources,
+		...live.first.error ? { live_error: live.first.error } : {}
+	};
+}
+const byText = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+function sortRows(rows) {
+	return [...rows].sort((a, b) => byText(a.reason, b.reason) || byText(a.url, b.url));
+}
+function byReason(rows) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const counts = groups.get(row.reason) ?? {
+			fix: 0,
+			check: 0,
+			expected: 0,
+			indexed: 0
+		};
+		counts[row.label] += 1;
+		groups.set(row.reason, counts);
+	}
+	return [...groups].sort((a, b) => byText(a[0], b[0])).map(([reason, counts]) => ({
+		reason,
+		urls: counts.fix + counts.check + counts.expected + counts.indexed,
+		...counts
+	}));
+}
+const isCode = (error, codes) => codes.includes(String(error?.code));
+function knownUrls(input) {
+	const found = /* @__PURE__ */ new Map();
+	const add = (url, source) => {
+		const sources = found.get(url) ?? [];
+		if (!sources.includes(source)) sources.push(source);
+		found.set(url, sources);
+	};
+	const pages = input.pages.filter((page) => page.impressions > 0 && !page.url.includes("#")).sort((a, b) => b.clicks - a.clicks || b.impressions - a.impressions || byText(a.url, b.url));
+	for (const url of input.lost) add(url, "lost_clicks");
+	for (const page of pages) add(page.url, "search_console");
+	for (const url of input.sitemap.urls) add(url, "sitemap");
+	if (input.home) add(input.home, "home");
+	return {
+		urls: [...found].map(([url, sources]) => ({
+			url,
+			sources
+		})),
+		sitemap: input.sitemap,
+		searchConsole: pages.length,
+		searchConsoleCapped: input.pagesCapped,
+		lostClicks: input.lost.length
+	};
+}
+async function inspectKnown(site, known, deps, asked = 100) {
+	const cap = Math.min(Math.max(1, Math.floor(asked)), MAX_INSPECT_LIMIT);
+	const wanted = known.urls.slice(0, cap);
+	let saved = /* @__PURE__ */ new Map();
+	try {
+		saved = deps.savedInspections?.read(site, wanted.map((item) => item.url)) ?? saved;
+	} catch {}
+	const missing = wanted.filter((item) => !saved.has(item.url));
+	const quota = deps.inspectionQuota ? await deps.inspectionQuota(site).catch(() => null) : null;
+	const left = quota ? Math.max(0, quota.limit - quota.used) : missing.length;
+	const asking = new Set(missing.slice(0, left).map((item) => item.url));
+	const queue = wanted.filter((item) => saved.has(item.url) || asking.has(item.url));
+	const quotaShort = left < missing.length;
+	const statuses = /* @__PURE__ */ new Map();
+	const rows = [];
+	const failed = [];
+	const sitemap = new Set(known.sitemap.urls);
+	const now = () => (deps.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
+	let quotaStop = false;
+	let next = 0;
+	let fatal = null;
+	const worker = async () => {
+		while (fatal === null && next < queue.length) {
+			const item = queue[next++];
+			const stored = saved.get(item.url);
+			let status;
+			let inspectedAt;
+			if (stored) {
+				status = stored.status;
+				inspectedAt = stored.inspectedAt;
+			} else {
+				if (quotaStop) continue;
+				try {
+					status = await deps.inspect(site, item.url);
+					inspectedAt = now();
+				} catch (error) {
+					if (isCode(error, ["RATE_LIMITED"])) quotaStop = true;
+					else if (isCode(error, [
+						"AUTH_EXPIRED",
+						"AUTH_REQUIRED",
+						"NOT_CONNECTED"
+					])) fatal = error;
+					else failed.push({
+						url: item.url,
+						error: error instanceof Error ? error.message : String(error)
+					});
+					continue;
+				}
+				try {
+					deps.savedInspections?.save(site, item.url, status);
+				} catch {}
+			}
+			statuses.set(item.url, status);
+			const live = await deps.liveCheck(item.url);
+			rows.push(indexingRow({
+				url: item.url,
+				status,
+				live,
+				inSitemap: item.sources.includes("sitemap"),
+				sitemap
+			}, item.sources, inspectedAt));
+		}
+	};
+	await Promise.all(Array.from({ length: CONCURRENCY }, worker));
+	if (fatal !== null) throw fatal;
+	const reused = rows.filter((row) => saved.has(row.url));
+	const oldest = reused.reduce((first, row) => first === null || row.inspected_at < first ? row.inspected_at : first, null);
+	return {
+		rows: sortRows(rows),
+		statuses,
+		known,
+		limit: cap,
+		inspected: rows.length,
+		fromSaved: reused.length,
+		oldestSaved: oldest,
+		failed: failed.sort((a, b) => byText(a.url, b.url)),
+		stoppedBy: quotaStop || quotaShort ? "quota" : known.urls.length > wanted.length ? "limit" : null,
+		quota
+	};
+}
+const n = (value) => value.toLocaleString("en-US");
+function liveCell(row) {
+	if (row.live_error) return `error: ${row.live_error}`;
+	if (!row.redirects) return String(row.status ?? "");
+	return `${row.redirects.replace(/ (permanent|temporary)/g, "")} > ${row.final_status ?? "loop"}`;
+}
+function indexingText(site, run, page, origin, askMore, now) {
+	const { known } = run;
+	const total = known.urls.length;
+	const notInspected = total - run.inspected - run.failed.length;
+	const sources = [
+		`lost-click pages ${n(known.lostClicks)}`,
+		`Search Console pages with impressions in the last 28 days ${n(known.searchConsole)}${known.searchConsoleCapped ? ", capped" : ""}`,
+		`sitemap ${n(known.sitemap.urls.length)} from ${plural$1(known.sitemap.files, "file")}${known.sitemap.partial ? ", partial" : ""}`
+	];
+	const lowerBound = known.sitemap.partial || known.searchConsoleCapped ? " at least" : "";
+	const asked = run.inspected - run.fromSaved;
+	const most = Math.min(total, MAX_INSPECT_LIMIT, run.quota ? run.inspected + run.quota.limit - run.quota.used - asked : MAX_INSPECT_LIMIT);
+	const days = run.oldestSaved ? Math.floor((now.getTime() - Date.parse(run.oldestSaved)) / 864e5) : 0;
+	const savedNote = run.fromSaved ? ` (${n(asked)} asked of Google now, ${n(run.fromSaved)} from saved results; the oldest was inspected ${run.oldestSaved?.slice(0, 16).replace("T", " ")} UTC, ${days === 0 ? "under a day" : plural$1(days, "day")} ago. Saved results are reused for 7 days)` : "";
+	const stop = run.stoppedBy === "quota" ? "The URL Inspection quota stopped it." : run.stoppedBy === "limit" ? `It stopped at ${n(run.limit)}, the number of inspections for this run${askMore && most > run.limit ? `; to inspect more, up to the quota left today: ${askMore(most)}` : ""}.` : "Every known URL has a result.";
+	const lines = [
+		`Google's indexing reasons for ${site}, from URL Inspection. Search Console's Page indexing report has no API, so known URLs are inspected one at a time, in a fixed order (lost-click pages, Search Console pages by clicks then impressions, sitemap URLs, then the rest), and checked live from here.`,
+		`Known URLs:${lowerBound} ${n(total)} (${sources.join("; ")}). Inspected ${n(run.inspected)} of ${n(total)}${savedNote}. ${stop}${notInspected > 0 ? ` The ${n(notInspected)} URLs not inspected have no result here, so this is not an all-clear for them.` : ""}${known.sitemap.notes.length ? ` Sitemap: ${known.sitemap.notes.join("; ")}.` : ""}`,
+		run.quota ? `URL Inspection quota: this machine had used ${n(run.quota.used)} of ${n(run.quota.limit)} today for this property before the run. Google also counts inspections from other tools.` : "URL Inspection quota: not counted on this server; Google stops inspections at 2,000 a day per property."
+	];
+	if (run.failed.length) lines.push(`URL Inspection failed for ${plural$1(run.failed.length, "URL")}: ${run.failed.slice(0, 5).map((item) => `${item.url} (${item.error})`).join("; ")}${run.failed.length > 5 ? "; and more" : ""}.`);
+	const groups = byReason(run.rows);
+	if (groups.length) lines.push(`By Google's reason, with labels from the rules below (not Google's):\n${table$1(groups, [
+		"reason",
+		"urls",
+		"fix",
+		"check",
+		"expected",
+		"indexed"
+	], null)}`);
+	const listed = run.rows.filter((row) => row.label !== "indexed");
+	const shown = page.summary ? listed.filter((row) => row.label === "fix" || row.label === "check") : listed;
+	const indexedCount = run.rows.length - listed.length;
+	const expectedCount = listed.length - shown.length;
+	const pageRows = shown.slice(page.offset, page.offset + page.size).map((row) => ({
+		reason: row.reason,
+		label: row.label,
+		url: row.url,
+		live: liveCell(row),
+		final_url: row.final_url === row.url ? "" : row.final_url,
+		in_sitemap: row.in_sitemap ? "yes" : "no",
+		last_crawl: row.last_crawl?.slice(0, 10) ?? "",
+		why: row.why
+	}));
+	const end = page.offset + pageRows.length;
+	const more = shown.length - end;
+	const others = page.summary ? [
+		more ? `${more} more labelled fix or check` : null,
+		expectedCount ? `${expectedCount} expected` : null,
+		indexedCount ? `${indexedCount} indexed with no fault found (in the full result)` : null
+	].filter(Boolean) : [];
+	if (page.summary && (more || expectedCount)) others.push(`every row but the indexed ones: ${page.more(0)}`);
+	lines.push(`${shown.length === 0 ? `No inspected URL is labelled ${page.summary ? "fix or check" : "fix, check or expected"}.` : `${page.summary ? "URLs labelled fix or check" : "URLs that are not indexed or show a fault"}, ${page.offset + 1} to ${end} of ${shown.length}:\n${table$1(pageRows, Object.keys(pageRows[0] ?? {}), origin, 400)}`}${others.length ? `\nNot listed here: ${others.join("; ")}.` : ""}`, `Labels: ${Object.entries(LABELS).map(([label, text]) => `${label}, ${text}`).join("; ")}. Rules: a same-host 302 or 307 is fix; a 404 or 410 that the sitemap or a referring page on this site points to is fix; a sitemap URL that redirects or that Google does not index is fix; a URL outside the sitemap (such as an http:// or host variant) that permanently redirects to a page declaring itself canonical is expected; a 401 with a WWW-Authenticate header is expected, and a 401 or 403 on a sign-in path is expected by heuristic; "Crawled - currently not indexed", "Discovered - currently not indexed" and a Google canonical that differs from the declared one are check. Referring pages are as of Google's last crawl. Live checks are server responses, so a browser-only HSTS "307 Internal Redirect" never shows here.`);
+	if (!page.summary && more) lines.push(`More rows: ${page.more(end)}.`);
+	return lines;
+}
+//#endregion
+//#region packages/core/src/commands/page-facts.ts
+const MAX_PAGES = 20;
+const TIMEOUT_MS$2 = 6e3;
+const MAX_BYTES$2 = 1e6;
+const clean = (value) => value?.trim().replace(/\s+/g, " ") || null;
+async function boundedText(response) {
+	if (!response.body) return "";
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	let text = "";
+	let total = 0;
+	while (total < MAX_BYTES$2) {
+		const { done, value } = await reader.read();
+		if (done) return text + decoder.decode();
+		total += value.byteLength;
+		text += decoder.decode(value, { stream: true });
+	}
+	await reader.cancel();
+	return text;
+}
+function headFacts(html, url) {
+	let title = "";
+	let h1 = "";
+	let inTitle = false;
+	let inH1 = false;
+	let titleDone = false;
+	let h1Done = false;
+	let description = null;
+	let canonical = null;
+	const robots = [];
+	const parser = new Parser({
+		onopentag(name, attributes) {
+			if (name === "title" && !titleDone) inTitle = true;
+			if (name === "h1" && !h1Done) inH1 = true;
+			if (name === "meta") {
+				const metaName = attributes.name?.toLowerCase();
+				if (metaName === "description" && description === null) description = attributes.content ?? null;
+				if (metaName === "robots" && attributes.content) robots.push(attributes.content);
+			}
+			if (name === "link" && canonical === null && attributes.rel?.toLowerCase().split(/\s+/).includes("canonical") && attributes.href) try {
+				canonical = new URL(attributes.href, url).toString();
+			} catch {
+				canonical = attributes.href;
+			}
+		},
+		ontext(text) {
+			if (inTitle) title += text;
+			if (inH1) h1 += text;
+		},
+		onclosetag(name) {
+			if (name === "title" && inTitle) {
+				inTitle = false;
+				titleDone = true;
+			}
+			if (name === "h1" && inH1) {
+				inH1 = false;
+				h1Done = true;
+			}
+		}
+	}, {
+		decodeEntities: true,
+		lowerCaseTags: true
+	});
+	parser.write(html);
+	parser.end();
+	return {
+		title: clean(title),
+		description: clean(description),
+		h1: clean(h1),
+		canonical,
+		robots: robots.length ? robots.join(", ") : null
 	};
 }
 async function facts(url) {
@@ -28689,63 +31579,548 @@ async function facts(url) {
 			await response.body?.cancel();
 			return out;
 		}
-		const head = headFacts(await boundedText(response), url);
-		Object.assign(out, head);
-		out.robots = [headerRobots, head.robots].filter(Boolean).join(", ") || null;
-	} catch (error) {
-		out.error = error instanceof Error ? error.message : "fetch failed";
-	}
-	return out;
-}
-function checkPages(urls) {
-	return Promise.all(urls.slice(0, MAX_PAGES).map(facts));
+		const head = headFacts(await boundedText(response), url);
+		Object.assign(out, head);
+		out.robots = [headerRobots, head.robots].filter(Boolean).join(", ") || null;
+	} catch (error) {
+		out.error = error instanceof Error ? error.message : "fetch failed";
+	}
+	return out;
+}
+function checkPages(urls) {
+	return Promise.all(urls.slice(0, MAX_PAGES).map(facts));
+}
+const MAX_HOPS = 5;
+const redirectKind = (status) => status === 301 || status === 308 ? "permanent" : status === 302 || status === 303 || status === 307 ? "temporary" : null;
+async function liveCheck(url) {
+	const first = await facts(url);
+	const hops = [];
+	const seen = /* @__PURE__ */ new Set([url]);
+	let last = first;
+	while (last.redirects_to && last.status !== null) {
+		const kind = redirectKind(last.status);
+		if (!kind) break;
+		const to = last.redirects_to;
+		hops.push({
+			from: last.url,
+			status: last.status,
+			to,
+			kind
+		});
+		if (seen.has(to) || hops.length > MAX_HOPS) return {
+			first,
+			hops,
+			last: null
+		};
+		seen.add(to);
+		last = await facts(to);
+	}
+	return {
+		first,
+		hops,
+		last
+	};
+}
+function temporaryRedirectNote(pages) {
+	const temporary = pages.filter((page) => (page.status === 302 || page.status === 307) && page.redirects_to !== null && new URL(page.redirects_to).host === new URL(page.url).host);
+	if (!temporary.length) return null;
+	return `Note: 302 and 307 are temporary redirects; a permanent move usually uses 301 or 308. Temporary redirects here: ${temporary.map((page) => `${page.url} (${page.status} to ${page.redirects_to})`).join("; ")}.`;
+}
+//#endregion
+//#region packages/core/src/commands/report.ts
+const SECTIONS = {
+	overview: "Site totals (clicks, impressions, CTR, position) against the previous period, by device, with the top pages and queries and their change, and Google Analytics sessions for the same dates from the property whose web stream matches the site.",
+	"quick-wins": "Query and page pairs at average positions 4 to 10 with a click-through rate below the site’s own curve for that position.",
+	"low-ctr": "Query and page pairs at average positions 1 to 4 with a click-through rate below the site’s own curve: titles and snippets to review with the person.",
+	"striking-distance": "Queries just outside the top positions, with impressions, for pages that already rank.",
+	"second-page": "Pages with an average position of 11 to 20 and their queries.",
+	"content-decay": "Query and page pairs that lost clicks against the previous period.",
+	cannibalization: "Queries where more than one page of the site gets impressions, with each page’s share.",
+	"traffic-drop": "Daily clicks and impressions checked for a sudden change that lasted, with the date it started (else the last 7 days against the days before), and Google updates within 3 days of that date. Overlap is timing only, not cause.",
+	"ai-queries": "Queries with the shape of AI conversations and agent searches (replies such as \"yes go on\", follow-ups, agent prompts, search operators, chat phrasing, ten or more words), with rewordings grouped into one question and its top page, impressions, clicks and position. A heuristic: Search Console does not mark AI Mode.",
+	bing: "Bing’s top queries from Bing Webmaster Tools with Google’s clicks, impressions and position for the same query beside them, and the same for pages."
+};
+const SECTION_IDS = Object.keys(SECTIONS);
+const PAGE_CHECKS = /* @__PURE__ */ new Set([
+	"quick-wins",
+	"low-ctr",
+	"striking-distance",
+	"second-page",
+	"content-decay",
+	"cannibalization"
+]);
+const DEFAULT_DAYS = {
+	overview: 28,
+	"quick-wins": 28,
+	"low-ctr": 28,
+	"striking-distance": 28,
+	"second-page": 28,
+	"content-decay": 28,
+	cannibalization: 28,
+	"traffic-drop": 90,
+	"ai-queries": 90,
+	bing: 28
+};
+function nextFor(section, call) {
+	const section_ = (id) => `section "${id}"`;
+	return {
+		overview: `Next: ${call("compare")} with a change date, or ${call("page")} for one page that moved.`,
+		"quick-wins": `Next: ${call("page")} for one page’s queries and live facts; ${section_("low-ctr")} for the top positions.`,
+		"low-ctr": `Next: ${call("page")} for one page; ${call("research")} serp to see who else ranks.`,
+		"striking-distance": `Next: ${section_("second-page")} to see the same pages by page; ${call("research")} keyword_metrics for search volume.`,
+		"second-page": `Next: ${call("page")} for one page’s queries and live facts.`,
+		"content-decay": `Next: ${call("index")} for pages that lost most of their clicks; ${call("page")} to see which queries moved.`,
+		cannibalization: `Next: ${call("page")} on each competing URL to see Google’s chosen canonical.`,
+		"traffic-drop": `Next: ${call("compare")} with the date the drop started, for the pages and queries that moved; ${call("index")} for pages that lost almost all their clicks and their index status.`,
+		"ai-queries": `Next: ${call("page")} for a page that gets many of these questions, to see whether it answers them; ${call("research")} ai_answers with the site as target checks whether AI answers cite it for the top 10 askable questions here (about $0.12 of DataForSEO credit), so show the person those questions and ask first.`,
+		bing: `Next: ${call("data", { source: "bing" })} for every Bing row; ${call("page")} for one page.`
+	}[section];
+}
+async function siteOverview(read, site, range, before, pageContains) {
+	const get = (dimensions, window, maxRows = 1e3) => read(site, {
+		...window,
+		dimensions,
+		type: "web",
+		dataState: "final",
+		maxRows,
+		...pageContains ? { dimensionFilterGroups: [{
+			groupType: "and",
+			filters: [{
+				dimension: "page",
+				operator: "contains",
+				expression: pageContains
+			}]
+		}] } : {}
+	});
+	const [total, totalBefore, device, deviceBefore, pages, pagesBefore, queries, queriesBefore] = await Promise.all([
+		get([], range),
+		get([], before),
+		get(["device"], range),
+		get(["device"], before),
+		get(["page"], range, 5e3),
+		get(["page"], before, 5e3),
+		get(["query"], range, 5e3),
+		get(["query"], before, 5e3)
+	]);
+	const row = (r) => r ?? {
+		clicks: 0,
+		impressions: 0,
+		ctr: 0,
+		position: 0
+	};
+	const now = row(total.rows[0]);
+	const then = row(totalBefore.rows[0]);
+	const compare = (current, earlier, name, limit) => {
+		const old = new Map(earlier.map((r) => [r.keys[0], r]));
+		const seen = new Set(current.map((r) => r.keys[0]));
+		const rows = current.map((r) => {
+			const earlierRow = old.get(r.keys[0]);
+			return {
+				[name]: r.keys[0],
+				clicks: r.clicks,
+				previousClicks: earlierRow?.clicks ?? 0,
+				clicksChange: r.clicks - (earlierRow?.clicks ?? 0),
+				impressions: r.impressions,
+				previousImpressions: earlierRow?.impressions ?? 0,
+				impressionsChange: r.impressions - (earlierRow?.impressions ?? 0),
+				position: r.position
+			};
+		});
+		for (const r of earlier) {
+			if (seen.has(r.keys[0])) continue;
+			rows.push({
+				[name]: r.keys[0],
+				clicks: 0,
+				previousClicks: r.clicks,
+				clicksChange: -r.clicks,
+				impressions: 0,
+				previousImpressions: r.impressions,
+				impressionsChange: -r.impressions,
+				position: 0
+			});
+		}
+		const by = (key, sign) => [...rows].sort((a, b) => sign * (Number(b[key]) - Number(a[key]))).filter((r) => sign * Number(r[key]) > 0).slice(0, limit);
+		return {
+			top: rows.slice(0, limit),
+			biggestLosses: by("clicksChange", -1),
+			biggestGains: by("clicksChange", 1),
+			biggestImpressionLosses: by("impressionsChange", -1)
+		};
+	};
+	const devices = new Map(deviceBefore.rows.map((r) => [r.keys[0], r]));
+	return {
+		range,
+		comparisonRange: before,
+		...pageContains ? { pageContains } : {},
+		summary: {
+			clicks: now.clicks,
+			previousClicks: then.clicks,
+			clicksChangePct: pct(now.clicks, then.clicks),
+			impressions: now.impressions,
+			previousImpressions: then.impressions,
+			impressionsChangePct: pct(now.impressions, then.impressions),
+			ctr: Math.round(now.ctr * 1e4) / 1e4,
+			previousCtr: Math.round(then.ctr * 1e4) / 1e4,
+			position: Math.round(now.position * 10) / 10,
+			previousPosition: Math.round(then.position * 10) / 10
+		},
+		devices: device.rows.map((r) => ({
+			device: r.keys[0],
+			clicks: r.clicks,
+			previousClicks: devices.get(r.keys[0])?.clicks ?? 0,
+			impressions: r.impressions,
+			position: r.position
+		})),
+		pages: compare(pages.rows, pagesBefore.rows, "page", 15),
+		queries: compare(queries.rows, queriesBefore.rows, "query", 15),
+		caveats: ["Totals come from Search Console with no dimension, so they include queries that Search Console hides for privacy.", "Page and query lists cover the top 5,000 rows in each period."]
+	};
+}
+function overviewText(report, heading, origin, rowsPerList) {
+	const range = report.range;
+	const before = report.comparisonRange;
+	const t = report.summary;
+	const change = (value) => value === void 0 || value === null ? "n/a" : `${value > 0 ? "+" : ""}${value}%`;
+	const section = (name, key) => {
+		const group = report[key === "page" ? "pages" : "queries"] ?? {};
+		const columns = [
+			key,
+			"clicks",
+			"previousClicks",
+			"clicksChange",
+			"impressions",
+			"impressionsChange",
+			"position"
+		];
+		const part = (title, rows) => rows.length ? `${title}:\n${table$1(rows.slice(0, rowsPerList), columns, origin)}` : "";
+		return [
+			rowsPerList >= 10 ? part(`Top ${name} by clicks`, group.top ?? []) : "",
+			part(`Biggest ${name} click losses`, group.biggestLosses ?? []) || `No ${name} lost clicks.`,
+			part(`Biggest ${name} impression losses`, group.biggestImpressionLosses ?? []),
+			part(`Biggest ${name} click gains`, group.biggestGains ?? [])
+		].filter(Boolean).join("\n\n");
+	};
+	return [
+		`${heading}, ${range.startDate} to ${range.endDate} against ${before.startDate} to ${before.endDate}${report.pageContains ? `, pages whose URL contains "${report.pageContains}"` : ""}.`,
+		`Totals: clicks ${t.clicks} (was ${t.previousClicks}, ${change(t.clicksChangePct)}), impressions ${t.impressions} (was ${t.previousImpressions}, ${change(t.impressionsChangePct)}), CTR ${t.ctr} (was ${t.previousCtr}), average position ${t.position} (was ${t.previousPosition}).`,
+		`Devices:\n${table$1(report.devices, [
+			"device",
+			"clicks",
+			"previousClicks",
+			"impressions",
+			"position"
+		], null)}`,
+		section("pages", "page"),
+		section("queries", "query"),
+		`Limits:\n${report.caveats.map((line) => `- ${line}`).join("\n")}`
+	].join("\n\n");
+}
+function once(make) {
+	let made;
+	return () => {
+		made ??= make();
+		return made;
+	};
+}
+async function enginesLine(overview, bing) {
+	const summary = overview.summary;
+	try {
+		return enginesText(summary, await bingTotals(await bing(), overview.range, overview.comparisonRange));
+	} catch (error) {
+		return `Bing: could not be read. ${error instanceof Error ? error.message : String(error)}`;
+	}
+}
+async function bingLead(overview, bing, origin, rowsPerList) {
+	const range = overview.range;
+	const before = overview.comparisonRange;
+	const google = overview.summary.clicks;
+	try {
+		const source = await bing();
+		if (!source.call) return null;
+		const totals = await bingTotals(source, range, before);
+		if ("missing" in totals || totals.current.clicks <= google) return null;
+		const report = await bingOverview(source, range, before);
+		return {
+			text: `## Bing\n${bingOverviewText(report, `Bing sends more clicks than Google here, so here is Bing's overview of ${totals.site}`, origin, rowsPerList)}`,
+			data: report
+		};
+	} catch {
+		return null;
+	}
+}
+async function build(read, site, section, range, now, bing) {
+	const dependencies = {
+		searchAnalytics: read,
+		now
+	};
+	const common = {
+		site,
+		limit: 100,
+		includeBrand: false,
+		...range
+	};
+	const run = {
+		overview: () => siteOverview(read, site, range, earlierRange(range)),
+		"quick-wins": () => quickWinsReportWith({
+			...common,
+			verifyContent: false
+		}, dependencies),
+		"low-ctr": () => ctrUnderperformersReportWith(common, dependencies),
+		"striking-distance": () => strikingDistanceWith({
+			...common,
+			verifyContent: false
+		}, dependencies),
+		"second-page": () => secondPageWith({
+			...common,
+			verifyContent: false
+		}, dependencies),
+		"content-decay": () => decayingReportWith({
+			...common,
+			comparison: "previous-period"
+		}, dependencies),
+		cannibalization: async () => {
+			const result = await cannibalReportWith(common, dependencies);
+			const items = result.items ?? [];
+			return {
+				...result,
+				items: items.map((item) => {
+					const pages = item.pages ?? [];
+					return {
+						...item,
+						urls: pages.map((page) => `${page.url} (${Math.round(page.impressionShare * 100)}%)`).join(" ; "),
+						topPage: item.suggestedOwnerUrl
+					};
+				})
+			};
+		},
+		"traffic-drop": async () => {
+			const result = await trafficAnomalyWith({
+				site,
+				...range,
+				recentDays: 7
+			}, dependencies);
+			const window = changeWindow(result.anomalies);
+			return {
+				...result,
+				updateWindow: window && {
+					...window,
+					paddingDays: 3
+				},
+				googleUpdates: await googleUpdates(window)
+			};
+		},
+		"ai-queries": () => aiQueriesReport({
+			site,
+			...range
+		}, read),
+		bing: async () => bingSection(await bing(), read, site, range)
+	}[section];
+	return factsOnly(await run());
+}
+function brandNote(report) {
+	const brand = report.brand;
+	if (!brand?.terms) return null;
+	return `Brand terms left out: ${brand.terms.join(", ") || "none"}${brand.excluded?.length ? `. Not treated as brand: ${brand.excluded.map((item) => item.term).join(", ")}` : ""}.`;
+}
+function reportUrls(rows, origin) {
+	const found = [];
+	const visit = (value, key = "") => {
+		if (found.length >= 20) return;
+		if (typeof value === "string") {
+			if (/^(url|page|finalUrl|targetUrl)$/i.test(key)) {
+				const url = value.startsWith("/") ? `${origin}${value}` : value;
+				if (/^https?:\/\//.test(url) && !found.includes(url)) found.push(url);
+			}
+			return;
+		}
+		if (Array.isArray(value)) for (const item of value) visit(item, key);
+		else if (value && typeof value === "object") for (const [child, item] of Object.entries(value)) visit(item, child);
+	};
+	for (const row of rows) visit(row);
+	return found;
 }
-const MAX_HOPS = 5;
-const redirectKind = (status) => status === 301 || status === 308 ? "permanent" : status === 302 || status === 303 || status === 307 ? "temporary" : null;
-async function liveCheck(url) {
-	const first = await facts(url);
-	const hops = [];
-	const seen = /* @__PURE__ */ new Set([url]);
-	let last = first;
-	while (last.redirects_to && last.status !== null) {
-		const kind = redirectKind(last.status);
-		if (!kind) break;
-		const to = last.redirects_to;
-		hops.push({
-			from: last.url,
-			status: last.status,
-			to,
-			kind
-		});
-		if (seen.has(to) || hops.length > MAX_HOPS) return {
-			first,
-			hops,
-			last: null
+function pageFactsTable(checked, origin) {
+	const rows = table$1(checked, [
+		"url",
+		"status",
+		"redirects_to",
+		"title",
+		"description",
+		"h1",
+		"canonical",
+		"robots",
+		...checked.some((page) => page.error) ? ["error"] : []
+	], origin, 320);
+	const note = temporaryRedirectNote(checked);
+	return note ? `${rows}\n${note}` : rows;
+}
+const PAGE_SIZE = 50;
+async function allSections(input, deps) {
+	const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+	const read = sharedReader(deps.searchAnalytics);
+	const origin = originOf(input.site);
+	const bing = once(() => bingFor(deps, input.site));
+	const ids = SECTION_IDS.filter((id) => id !== "bing" || deps.bing);
+	const range = dateWindow(input, DEFAULT_DAYS.overview);
+	const analytics = analyticsBeside(deps.analytics, input.site, range, earlierRange(range));
+	const [overview, ...rest] = await Promise.all(ids.map((id) => build(read, input.site, id, dateWindow(input, DEFAULT_DAYS[id]), now, bing).catch((error) => error instanceof Error ? error : new Error(String(error)))));
+	if (!overview || overview instanceof Error) throw overview ?? /* @__PURE__ */ new Error("The overview did not run.");
+	const parts = [overviewText(overview, `Report on ${input.site}`, origin, 5)];
+	parts.push(deps.bing ? await enginesLine(overview, bing) : NO_BING_HERE);
+	const bingFirst = deps.bing ? await bingLead(overview, bing, origin, 5) : null;
+	if (bingFirst) parts.push(bingFirst.text);
+	const ga = await analytics;
+	if (ga) parts.push(ga.text);
+	const audit = deps.audit ? auditPreview(await deps.audit.snapshot(input.site)) : null;
+	const brand = rest.find((run) => !(run instanceof Error) && brandNote(run) !== null);
+	if (brand) parts.push(brandNote(brand));
+	const sections = {};
+	ids.slice(1).forEach((id, index) => {
+		const run = rest[index];
+		if (!run || run instanceof Error) {
+			const message = run?.message ?? "did not run";
+			parts.push(`## ${id}\nNot available: ${message}`);
+			sections[id] = { error: message };
+			return;
+		}
+		const shown = preview(run, origin, 3);
+		sections[id] = { total: shown.total };
+		parts.push([
+			`## ${id}: ${shown.total} ${shown.total === 1 ? "row" : "rows"}`,
+			SECTIONS[id],
+			shown.text,
+			id === "traffic-drop" ? listOfUpdates(run.googleUpdates, run.updateWindow) : null
+		].filter(Boolean).join("\n"));
+	});
+	if (deps.audit) {
+		parts.push(`## ${AUDIT_SECTION}\n${audit ?? "This site is not in the weekly site audit."}`);
+		sections[AUDIT_SECTION] = { line: audit };
+	}
+	const names = deps.audit ? [...ids, AUDIT_SECTION] : ids;
+	parts.push(`More: ${deps.call("report", {
+		site: input.site,
+		section: "<section>"
+	})} for its rows (${names.join(", ")}). Page sections also check their top 20 URLs live and merge same-site redirects.`);
+	return {
+		text: `${parts.join("\n\n")}\n\n${FACTS_ONLY}`,
+		data: {
+			site: input.site,
+			overview,
+			...ga ? { analytics: ga.data } : {},
+			...bingFirst ? { bingOverview: bingFirst.data } : {},
+			sections
+		}
+	};
+}
+async function oneSection(input, deps) {
+	const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+	const { site, section } = input;
+	const detail = input.detail ?? "summary";
+	const range = dateWindow(input, DEFAULT_DAYS[section]);
+	const origin = originOf(site);
+	const bing = once(() => bingFor(deps, site));
+	let report = await build(sharedReader(deps.searchAnalytics), site, section, range, now, bing);
+	const next = nextFor(section, deps.call);
+	if (section === "overview") {
+		const ga = await analyticsBeside(deps.analytics, site, range, earlierRange(range));
+		if (ga) report.analytics = ga.data;
+		const bingFirst = deps.bing ? await bingLead(report, bing, origin, 10) : null;
+		if (bingFirst) report.bingOverview = bingFirst.data;
+		if (detail !== "full") return {
+			text: [
+				overviewText(report, `overview of ${site}`, origin, 10),
+				deps.bing ? await enginesLine(report, bing) : NO_BING_HERE,
+				bingFirst?.text,
+				ga?.text,
+				`More: ${deps.call("report", {
+					site,
+					section,
+					detail: "full"
+				})} for every row.`,
+				next,
+				FACTS_ONLY
+			].filter(Boolean).join("\n\n"),
+			data: report
 		};
-		seen.add(to);
-		last = await facts(to);
 	}
+	let checked = [];
+	const merged = [];
+	if (PAGE_CHECKS.has(section)) {
+		const list = Object.values(report).find((value) => Array.isArray(value) && value.length > 0);
+		checked = await deps.checkPages(reportUrls(report.items ?? list ?? [], origin));
+		const redirects = /* @__PURE__ */ new Map();
+		for (const page of checked) {
+			if (!page.redirects_to) continue;
+			if (new URL(page.redirects_to).host !== new URL(page.url).host) continue;
+			redirects.set(page.url, page.redirects_to.replace(/#.*$/, ""));
+			merged.push(`${page.url} → ${page.redirects_to}`);
+		}
+		if (redirects.size) report = await build(sharedReader(deps.searchAnalytics, redirects), site, section, range, now, bing);
+		report.pageChecks = checked;
+	}
+	const notes = [];
+	const brand = brandNote(report);
+	if (brand) notes.push(brand);
+	const updates = listOfUpdates(report.googleUpdates, report.updateWindow);
+	if (updates) notes.push(updates);
+	if (checked.length) notes.push(`Live page checks (${checked.length} URLs, fetched now, no redirects followed):\n${pageFactsTable(checked, origin)}`);
+	if (merged.length) notes.push(`Redirect sources merged into their targets, so each pair counts as one page here: ${merged.join("; ")}.`);
+	const before = earlierRange(range);
+	const shown = presentReport({
+		report,
+		headline: [`${section} on ${site}.`, typeof report.verdict === "string" ? report.verdict : ""].filter(Boolean).join(" "),
+		label: section,
+		range: section === "content-decay" ? `${range.startDate} to ${range.endDate} against ${before.startDate} to ${before.endDate}` : `${range.startDate} to ${range.endDate}`,
+		notes,
+		origin,
+		detail,
+		offset: input.offset ?? 0,
+		limit: PAGE_SIZE,
+		more: (level, offset) => deps.call("report", {
+			site,
+			section,
+			detail: level,
+			offset
+		})
+	});
+	const facts = section === "bing" ? FACTS_ONLY.replace("Search Console", "Search Console and Bing") : FACTS_ONLY;
 	return {
-		first,
-		hops,
-		last
+		text: `${shown.text}\n\n${next}\n\n${facts}`,
+		data: detail === "full" ? report : shown.data
+	};
+}
+function runReport(input, deps) {
+	if (input.section === "weekly-audit") {
+		const audit = deps.audit;
+		if (!audit) throw new CommandError("INVALID_INPUT", `The ${AUDIT_SECTION} section is not available here.`);
+		return audit.snapshot(input.site).then((snapshot) => runAuditReport(input, snapshot, deps.call));
+	}
+	return input.section ? oneSection({
+		...input,
+		section: input.section
+	}, deps) : allSections(input, deps);
+}
+async function runBingReport(input, deps) {
+	const range = dateWindow(input, DEFAULT_DAYS.overview);
+	const before = earlierRange(range);
+	const source = await bingFor(deps, input.site);
+	if (!source.call) throw new CommandError("NOT_CONNECTED", source.missing);
+	const [report, ga] = await Promise.all([bingOverview(source, range, before), analyticsBeside(deps.analytics, source.site, range, before)]);
+	if (ga) report.analytics = ga.data;
+	return {
+		text: [
+			bingOverviewText(report, `Bing report on ${source.site}. No Search Console property covers this site, so this report uses Bing`, originOf(source.site), 10),
+			ga?.text,
+			`More: ${deps.call("data", {
+				source: "bing",
+				site: input.site,
+				dimensions: "page"
+			})} for every Bing page, or the same with query.`,
+			FACTS_ONLY.replace("Search Console", "Bing Webmaster Tools")
+		].filter(Boolean).join("\n\n"),
+		data: report
 	};
 }
-//#endregion
-//#region packages/core/src/commands/report.ts
-const SECTIONS = {
-	overview: "Site totals (clicks, impressions, CTR, position) against the previous period, by device, with the top pages and queries and their change, and Google Analytics sessions for the same dates from the property whose web stream matches the site.",
-	"quick-wins": "Query and page pairs at average positions 4 to 10 with a click-through rate below the site’s own curve for that position.",
-	"low-ctr": "Query and page pairs at average positions 1 to 4 with a click-through rate below the site’s own curve: titles and snippets to review with the person.",
-	"striking-distance": "Queries just outside the top positions, with impressions, for pages that already rank.",
-	"second-page": "Pages with an average position of 11 to 20 and their queries.",
-	"content-decay": "Query and page pairs that lost clicks against the previous period.",
-	cannibalization: "Queries where more than one page of the site gets impressions, with each page’s share.",
-	"traffic-drop": "Daily clicks and impressions checked for a sudden change that lasted, with the date it started (else the last 7 days against the days before), and Google updates within 3 days of that date. Overlap is timing only, not cause.",
-	"ai-queries": "Queries with the shape of AI conversations and agent searches (replies such as \"yes go on\", follow-ups, agent prompts, search operators, chat phrasing, ten or more words), with rewordings grouped into one question and its top page, impressions, clicks and position. A heuristic: Search Console does not mark AI Mode.",
-	bing: "Bing’s top queries from Bing Webmaster Tools with Google’s clicks, impressions and position for the same query beside them, and the same for pages."
-};
-const SECTION_IDS = Object.keys(SECTIONS);
 //#endregion
 //#region packages/core/src/commands/research.ts
 const RESEARCH_ACTIONS = [
@@ -28758,6 +32133,212 @@ const RESEARCH_ACTIONS = [
 ];
 const RESEARCH_PROVIDERS = ["dataforseo", "ahrefs"];
 const RESEARCH_HELP = `keyword_metrics (keywords: volume, difficulty, CPC), ranked_keywords (target: keywords a domain or URL ranks for), serp (keywords, up to 5: the ranking pages), competitors (target: domains that share keywords), backlinks (target: referring domains), ai_answers (DataForSEO only; target: the site. It takes the site’s top 10 chat-style and long questions from Search Console’s AI-shaped queries itself, then asks ChatGPT search, Google AI Mode and Google AI Overviews each one and says whether the answer cites or mentions the site. DataForSEO’s live prices are $0.012 a question, so up to about $0.12 a run: tell the person before running it). Rows with a domain, and the target, get a free Ahrefs domain_rating column. Numbers are provider estimates, not Search Console data.`;
+const GENERIC_PLATFORMS = [
+	"youtube.com",
+	"facebook.com",
+	"wikipedia.org",
+	"reddit.com",
+	"quora.com",
+	"instagram.com",
+	"linkedin.com",
+	"x.com",
+	"twitter.com",
+	"pinterest.com",
+	"tiktok.com",
+	"amazon.com"
+];
+const within = (domain, parent) => domain === parent || domain.endsWith(`.${parent}`);
+function realCompetitors(rows, target) {
+	const self = bareDomain(target);
+	const domainOf = (row) => bareDomain(String(row.domain ?? row.competitor_domain ?? ""));
+	const isSelf = (domain) => self !== "" && within(domain, self);
+	const isPlatform = (domain) => GENERIC_PLATFORMS.some((name) => within(domain, name));
+	const domains = rows.map(domainOf);
+	const own = domains.filter(isSelf);
+	const platforms = domains.filter((d) => !isSelf(d) && isPlatform(d));
+	const gone = own.length + platforms.length;
+	if (!gone) return {
+		rows,
+		note: null
+	};
+	const reasons = [own.length ? `the target itself (${own.join(", ")})` : "", platforms.length ? `generic platforms that share keywords with most sites (${platforms.join(", ")})` : ""].filter(Boolean);
+	return {
+		rows: rows.filter((row) => {
+			const domain = domainOf(row);
+			return !isSelf(domain) && !isPlatform(domain);
+		}),
+		note: `Left out ${gone} ${gone === 1 ? "row" : "rows"}: ${reasons.join(" and ")}. The fixed platform list is ${GENERIC_PLATFORMS.join(", ")}.`
+	};
+}
+async function runResearch(input, keys, options) {
+	const country = input.country ?? "us";
+	const target = input.target ?? "";
+	const offset = input.offset ?? 0;
+	const language = input.provider === "dataforseo" ? dataForSeoLanguage(country) : null;
+	if (input.action === "ai_answers") throw new CommandError("INVALID_INPUT", "ai_answers runs on its own.");
+	const { rows: found, costUsd, partial } = await research(input.provider, keys, {
+		action: input.action,
+		keywords: input.keywords ?? [],
+		target,
+		country,
+		limit: Math.min(1e3, Math.max(100, offset + 50))
+	});
+	const { rows, note } = input.action === "competitors" ? realCompetitors(found, target) : {
+		rows: found,
+		note: null
+	};
+	const drKey = keys.get("x-ahrefs-key") ?? options.drKey;
+	const rated = await withDomainRating(rows, drKey);
+	const targetDr = target ? (await domainRatings([target], drKey)).get(bareDomain(target)) : void 0;
+	const hasTargetDr = targetDr !== void 0 && targetDr !== null;
+	return {
+		text: rowsText({
+			title: `${input.provider} ${input.action}${target ? ` for ${target}` : ""}, ${country}${language ? `, language ${language}` : ""}.`,
+			rows: rated.rows,
+			offset,
+			limit: 50,
+			detail: input.detail ?? "summary",
+			notes: [
+				`${input.provider} estimates, in the provider’s own units.`,
+				...costUsd !== null ? [`DataForSEO cost: $${costUsd}.`] : [],
+				...partial ? ["Partial: DataForSEO could not fetch some pages of results, so rows may be missing."] : [],
+				...note ? [note] : [],
+				...hasTargetDr ? [`${bareDomain(target)} domain_rating: ${targetDr}.`] : [],
+				...rated.added || hasTargetDr ? [DR_ATTRIBUTION] : []
+			],
+			more: options.call
+		}),
+		data: {
+			provider: input.provider,
+			action: input.action,
+			target: target || null,
+			country,
+			language,
+			targetDomainRating: hasTargetDr ? targetDr : null,
+			attribution: rated.added || hasTargetDr ? DR_ATTRIBUTION : null,
+			leftOut: note,
+			costUsd,
+			partial,
+			total: rated.rows.length,
+			offset,
+			rows: rated.rows.slice(offset, offset + 50)
+		}
+	};
+}
+//#endregion
+//#region packages/core/src/commands/sitemap-urls.ts
+const MAX_FILES = 20;
+const MAX_URLS = 5e4;
+const MAX_BYTES$1 = 2e7;
+const TIMEOUT_MS$1 = 1e4;
+async function boundedBytes(body) {
+	if (!body) return /* @__PURE__ */ new Uint8Array();
+	const reader = body.getReader();
+	const chunks = [];
+	let total = 0;
+	while (true) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		total += value.byteLength;
+		if (total > MAX_BYTES$1) {
+			await reader.cancel();
+			return null;
+		}
+		chunks.push(value);
+	}
+	const bytes = new Uint8Array(total);
+	let offset = 0;
+	for (const chunk of chunks) {
+		bytes.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return bytes;
+}
+async function get(url) {
+	const response = await fetch(url, {
+		headers: { "user-agent": SEO_CRAWLER_USER_AGENT },
+		signal: AbortSignal.timeout(TIMEOUT_MS$1)
+	});
+	if (!response.ok) {
+		await response.body?.cancel();
+		throw new Error(`answered ${response.status}`);
+	}
+	let bytes = await boundedBytes(response.body);
+	if (bytes && bytes[0] === 31 && bytes[1] === 139) bytes = await boundedBytes(new Response(bytes).body?.pipeThrough(new DecompressionStream("gzip")) ?? null);
+	if (!bytes) throw new Error(`is larger than ${MAX_BYTES$1} bytes`);
+	return new TextDecoder().decode(bytes);
+}
+const ENTITIES = {
+	amp: "&",
+	lt: "<",
+	gt: ">",
+	quot: "\"",
+	apos: "'"
+};
+function locs(xml) {
+	return [...xml.matchAll(/<loc>\s*(?:<!\[CDATA\[)?([\s\S]*?)(?:\]\]>)?\s*<\/loc>/gi)].map((match) => (match[1] ?? "").trim().replace(/&(amp|lt|gt|quot|apos);/g, (_, name) => ENTITIES[name] ?? ""));
+}
+const inside = (site, url) => {
+	try {
+		return assertUrlMatchesGscProperty(site, url);
+	} catch {
+		return null;
+	}
+};
+async function sitemapUrls(site) {
+	const origin = new URL(originOf(site)).origin;
+	const notes = [];
+	const declared = [...(await get(`${origin}/robots.txt`).catch(() => "")).matchAll(/^\s*sitemap:\s*(\S+)/gim)].map((match) => match[1] ?? "").filter(Boolean);
+	const queue = declared.length ? declared : [`${origin}/sitemap.xml`];
+	const seenFiles = /* @__PURE__ */ new Set();
+	const urls = /* @__PURE__ */ new Set();
+	let files = 0;
+	let partial = false;
+	while (queue.length) {
+		const file = queue.shift();
+		if (seenFiles.has(file)) continue;
+		seenFiles.add(file);
+		if (files >= MAX_FILES) {
+			partial = true;
+			notes.push(`stopped at ${MAX_FILES} sitemap files`);
+			break;
+		}
+		files += 1;
+		let xml;
+		try {
+			xml = await get(file);
+		} catch (error) {
+			if (!declared.length && files === 1) {
+				notes.push(`robots.txt names no sitemap and ${file} ${error instanceof Error ? error.message : "could not be read"}`);
+				continue;
+			}
+			partial = true;
+			notes.push(`${file} ${error instanceof Error ? error.message : "could not be read"}`);
+			continue;
+		}
+		if (/<sitemapindex[\s>]/i.test(xml)) {
+			queue.push(...locs(xml));
+			continue;
+		}
+		for (const loc of locs(xml)) {
+			const url = inside(site, loc);
+			if (!url) continue;
+			if (urls.size >= MAX_URLS) {
+				partial = true;
+				notes.push(`stopped at ${MAX_URLS.toLocaleString("en-US")} URLs`);
+				queue.length = 0;
+				break;
+			}
+			urls.add(url);
+		}
+	}
+	return {
+		urls: [...urls],
+		files,
+		partial,
+		notes: [...new Set(notes)]
+	};
+}
 //#endregion
 //#region packages/core/src/commands/site.ts
 function indexStatusFrom(result) {
@@ -28778,8 +32359,320 @@ function indexStatusFrom(result) {
 		sitemaps: list(status.sitemap)
 	};
 }
-const LOST_PAGES_RULE = `Pages that had at least 3 clicks in the previous 28 days and kept ${.2 * 100}% or less of them in the last 28 days, with a live check of the top 20 and Google’s index status for the top 10 and the home page.`;
+async function runPage(input, deps) {
+	const range = dateWindow(input, 28);
+	const before = earlierRange(range);
+	const query = (window) => deps.searchAnalytics(input.site, {
+		...window,
+		dimensions: ["query"],
+		type: "web",
+		maxRows: 5e3,
+		dimensionFilterGroups: [{
+			groupType: "and",
+			filters: [{
+				dimension: "page",
+				operator: "equals",
+				expression: input.url
+			}]
+		}]
+	});
+	const full = input.detail === "full";
+	const [live, indexed, sitemap, now, then, markdown] = await Promise.all([
+		deps.liveCheck(input.url),
+		deps.inspect(input.site, input.url).catch(() => null),
+		sitemapUrls(input.site),
+		query(range),
+		query(before),
+		full && deps.pageMarkdown ? deps.pageMarkdown(input.url).catch((error) => ({ error: error instanceof Error ? error.message : String(error) })) : null
+	]);
+	const facts = live.first;
+	const reason = indexed ? indexingRow({
+		url: input.url,
+		status: indexed,
+		live,
+		inSitemap: sitemap.urls.includes(input.url),
+		sitemap: new Set(sitemap.urls)
+	}, [], (deps.now?.() ?? /* @__PURE__ */ new Date()).toISOString()) : null;
+	const old = new Map(then.rows.map((row) => [row.keys[0], row]));
+	const seen = /* @__PURE__ */ new Set();
+	const rows = now.rows.map((row) => {
+		seen.add(row.keys[0] ?? "");
+		const earlier = old.get(row.keys[0]);
+		return {
+			query: row.keys[0],
+			clicks: row.clicks,
+			previous_clicks: earlier?.clicks ?? 0,
+			clicks_change: row.clicks - (earlier?.clicks ?? 0),
+			impressions: row.impressions,
+			ctr: row.ctr,
+			position: row.position,
+			previous_position: earlier?.position ?? null
+		};
+	});
+	for (const row of then.rows) {
+		if (seen.has(row.keys[0] ?? "")) continue;
+		rows.push({
+			query: row.keys[0],
+			clicks: 0,
+			previous_clicks: row.clicks,
+			clicks_change: -row.clicks,
+			impressions: 0,
+			ctr: 0,
+			position: null,
+			previous_position: row.position
+		});
+	}
+	rows.sort((a, b) => Number(b.clicks) - Number(a.clicks) || Number(b.impressions) - Number(a.impressions));
+	const sum = (list, key) => list.reduce((total, row) => total + row[key], 0);
+	const offset = input.offset ?? 0;
+	return {
+		text: [
+			rowsText({
+				title: `${input.url} in ${input.site}, ${range.startDate} to ${range.endDate} against ${before.startDate} to ${before.endDate}.`,
+				notes: [
+					`Live page (fetched now):\n${pageFactsTable([facts], null)}${live.hops.length ? `\nRedirects: ${live.hops.map((hop) => `${hop.status} to ${hop.to}`).join(", ")}${live.last ? `, which returns ${live.last.status ?? live.last.error}` : ", then loop or pass 5 hops"}.` : ""}`,
+					indexed ? `Google index status:\n${table$1([indexed], Object.keys(indexed), null)}` : "Google index status: not available for this URL.",
+					...reason ? [`Google's reason: ${reason.reason}. Label: ${reason.label}. ${reason.why} (Labels are rules over this evidence, not Google's; ${deps.call("index")} explains them.)`] : [],
+					`Query totals: clicks ${sum(now.rows, "clicks")} (was ${sum(then.rows, "clicks")}), impressions ${sum(now.rows, "impressions")} (was ${sum(then.rows, "impressions")}). Search Console hides rare queries, so these can be lower than the page total.`,
+					deps.pageMarkdown ? `Main content as Markdown: ${deps.call("page", {
+						url: input.url,
+						detail: "full"
+					})}.` : `Main content as Markdown: only in the CLI and the local MCP server, with \`npx -y seo page --url ${input.url} --detail full\`.`
+				],
+				rows,
+				offset,
+				limit: 50,
+				detail: input.detail ?? "summary",
+				more: (next) => deps.call("page", {
+					url: input.url,
+					detail: "rows",
+					offset: next
+				})
+			}),
+			...full ? [markdownText(markdown, input.url)] : [],
+			`Next: ${deps.call("research")} serp with the top query to see who else ranks.`,
+			FACTS_ONLY
+		].join("\n\n"),
+		data: {
+			url: input.url,
+			range,
+			comparisonRange: before,
+			page: facts,
+			index: indexed,
+			reason,
+			totalQueries: rows.length,
+			queries: rows.slice(offset, offset + 50),
+			...full ? { markdown } : {}
+		}
+	};
+}
+function markdownText(markdown, url) {
+	if (!markdown) return `Main content as Markdown: not on this server; it runs in the CLI and the local MCP server. ${CLI_LINK} Then run \`npx -y seo page --url ${url} --detail full\`.`;
+	if ("error" in markdown) return `Main content as Markdown: the page could not be read (${markdown.error}).`;
+	if (!markdown.markdown) return "Main content as Markdown: the page has no main content to read.";
+	return `Main content as Markdown (live page${markdown.truncated ? `, cut to ${markdown.markdown.length.toLocaleString("en-US")} of ${markdown.characters.toLocaleString("en-US")} characters` : ""}):\n\n${markdown.markdown}`;
+}
+async function runCompare(input, deps) {
+	if (!/^\d{4}-\d{2}-\d{2}$/.test(input.date)) throw new CommandError("INVALID_INPUT", "The date must be YYYY-MM-DD.");
+	const last = latestFinalGscDate(deps.now?.() ?? /* @__PURE__ */ new Date());
+	const daysAfter = Math.round((Date.parse(last) - Date.parse(input.date)) / 864e5) + 1;
+	if (daysAfter < 3) throw new CommandError("INVALID_INPUT", `Search Console has final data to ${last}. Use a date at least 3 days before that.`);
+	const days = Math.min(28, daysAfter);
+	const after = {
+		startDate: input.date,
+		endDate: shiftIsoDate(input.date, days - 1)
+	};
+	const before = {
+		startDate: shiftIsoDate(input.date, -days),
+		endDate: shiftIsoDate(input.date, -1)
+	};
+	const [report, updates, analytics] = await Promise.all([
+		siteOverview(sharedReader(deps.searchAnalytics), input.site, after, before, input.pages),
+		googleUpdates({
+			start: before.startDate,
+			end: after.endDate
+		}),
+		analyticsBeside(deps.analytics, input.site, after, before, input.pages)
+	]);
+	return {
+		text: [
+			overviewText(report, `Compare on ${input.site}: ${days} days after ${input.date}`, originOf(input.site), 10),
+			analytics?.text,
+			listOfUpdates(updates),
+			`Next: ${deps.call("page")} for a page that moved.`,
+			FACTS_ONLY
+		].filter(Boolean).join("\n\n"),
+		data: {
+			...report,
+			...analytics ? { analytics: analytics.data } : {},
+			googleUpdates: updates
+		}
+	};
+}
+const LOST_SHARE = .2;
+const MIN_LOST = 3;
+const CHECKED = 20;
+const INSPECTED = 10;
+const SITE_WIDE_MIN = 5;
+const PAGE_ROWS = 25e3;
+function indexSummary(inspected, home) {
+	const known = inspected.filter((item) => item?.verdict != null);
+	const indexed = known.filter((item) => item.verdict === "PASS").length;
+	const coverage = /* @__PURE__ */ new Map();
+	for (const item of known) {
+		if (item.verdict === "PASS") continue;
+		const state = item.coverage ?? item.verdict ?? "unknown";
+		coverage.set(state, (coverage.get(state) ?? 0) + 1);
+	}
+	const notIndexed = known.length - indexed;
+	const homeIndexed = home?.status?.verdict ? home.status.verdict === "PASS" : null;
+	const siteWide = notIndexed >= SITE_WIDE_MIN && notIndexed * 2 > known.length && homeIndexed;
+	const byCoverage = [...coverage].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).map(([state, count]) => ({
+		state,
+		count
+	}));
+	return {
+		text: (known.length ? [`Index status of the ${known.length} inspected pages: ${indexed} indexed, ${notIndexed} not indexed${byCoverage.length ? ` (${byCoverage.map((item) => `${item.count} ${item.state}`).join("; ")})` : ""}.${home && homeIndexed !== null ? ` Home page ${home.url}: ${homeIndexed ? "indexed" : `not indexed (${home.status?.coverage ?? home.status?.verdict})`}.` : ""}`, siteWide ? `Site-wide pattern: ${notIndexed} of ${known.length} inspected pages are not in Google's index, but the home page is. This points to the whole site, not single pages. It does not show the cause.` : null] : []).filter(Boolean).join("\n"),
+		data: {
+			inspected: known.length,
+			indexed,
+			notIndexed,
+			byCoverage,
+			homePage: home && homeIndexed !== null ? {
+				url: home.url,
+				indexed: homeIndexed
+			} : null,
+			siteWide: Boolean(siteWide)
+		}
+	};
+}
+const LOST_PAGES_RULE = `Pages that had at least ${MIN_LOST} clicks in the previous 28 days and kept ${LOST_SHARE * 100}% or less of them in the last 28 days, with a live check of the top ${CHECKED} and Google’s index status for the top ${INSPECTED} and the home page.`;
 const INDEXING_RULE = `Google’s indexing reasons for 100 known URLs a run in a fixed order (lost-click pages, Search Console pages by clicks then impressions, sitemap URLs, then the rest), each checked live and labelled fix, check, expected or indexed from the evidence, sorted by reason then URL.`;
+async function runLostPages(input, deps) {
+	const range = dateWindow(input, 28);
+	const before = earlierRange(range);
+	const read = (window) => deps.searchAnalytics(input.site, {
+		...window,
+		dimensions: ["page"],
+		type: "web",
+		maxRows: PAGE_ROWS
+	});
+	const [now, then, sitemap] = await Promise.all([
+		read(range),
+		read(before),
+		sitemapUrls(input.site)
+	]);
+	const current = new Map(now.rows.map((row) => [row.keys[0], row.clicks]));
+	const lost = then.rows.filter((row) => row.clicks >= MIN_LOST && !row.keys[0]?.includes("#")).map((row) => ({
+		url: row.keys[0] ?? "",
+		previous_clicks: row.clicks,
+		clicks: current.get(row.keys[0]) ?? 0
+	})).filter((row) => row.clicks <= row.previous_clicks * LOST_SHARE).sort((a, b) => b.previous_clicks - b.clicks - (a.previous_clicks - a.clicks) || a.url.localeCompare(b.url));
+	const top = lost.slice(0, CHECKED);
+	const first = top[0]?.url ?? sitemap.urls[0] ?? now.rows[0]?.keys[0];
+	const homeUrl = first ? `${new URL(first).origin}/` : null;
+	const known = knownUrls({
+		lost: lost.map((row) => row.url),
+		home: homeUrl,
+		sitemap,
+		pages: now.rows.map((row) => ({
+			url: row.keys[0] ?? "",
+			clicks: row.clicks,
+			impressions: row.impressions
+		})),
+		pagesCapped: now.rows.length >= PAGE_ROWS
+	});
+	const [facts, run] = await Promise.all([deps.checkPages(top.map((row) => row.url)), inspectKnown(input.site, known, deps, input.maxUrls)]);
+	const status = (url) => url ? run.statuses.get(url) ?? null : null;
+	const summary = indexSummary(top.slice(0, INSPECTED).filter((row) => row.url !== homeUrl).map((row) => status(row.url)), top.length && homeUrl ? {
+		url: homeUrl,
+		status: status(homeUrl)
+	} : null);
+	const rows = top.map((row, index) => {
+		const indexed = index < INSPECTED ? status(row.url) : null;
+		return {
+			...row,
+			status: facts[index]?.status ?? null,
+			redirects_to: facts[index]?.redirects_to ?? null,
+			robots: facts[index]?.robots ?? null,
+			canonical: facts[index]?.canonical ?? null,
+			verdict: indexed?.verdict ?? null,
+			coverage: indexed?.coverage ?? null,
+			google_canonical: indexed?.google_canonical ?? null
+		};
+	});
+	const detail = input.detail ?? "summary";
+	const offset = input.offset ?? 0;
+	const origin = originOf(input.site);
+	const firstFix = run.rows.find((row) => row.label === "fix");
+	const reasons = indexingText(input.site, run, {
+		summary: detail === "summary",
+		offset,
+		size: detail === "summary" ? 25 : 50,
+		more: (next) => deps.call("index", {
+			site: input.site,
+			max_urls: input.maxUrls,
+			detail: "rows",
+			offset: next
+		})
+	}, origin, deps.inspectionQuota ? (count) => deps.call("index", {
+		site: input.site,
+		max_urls: count
+	}) : null, deps.now?.() ?? /* @__PURE__ */ new Date());
+	const lostText = [
+		`Pages that lost their clicks on ${input.site}: ${range.startDate} to ${range.endDate} against ${before.startDate} to ${before.endDate}.`,
+		`${lost.length} pages kept ${LOST_SHARE * 100}% or less of at least ${MIN_LOST} clicks${lost.length > CHECKED ? `; the top ${CHECKED} by clicks lost are shown` : ""}.`,
+		rows.length ? table$1(rows, Object.keys(rows[0] ?? {}), origin) : "No pages lost their clicks.",
+		summary.text,
+		"Live checks are fetched now with no redirects followed. Index status is from URL Inspection.",
+		temporaryRedirectNote(rows)
+	];
+	const indexing = {
+		rule: INDEXING_RULE,
+		known: {
+			total: known.urls.length,
+			sitemap: sitemap.urls.length,
+			sitemapFiles: sitemap.files,
+			sitemapPartial: sitemap.partial,
+			searchConsole: known.searchConsole,
+			searchConsoleCapped: known.searchConsoleCapped,
+			lostClicks: known.lostClicks
+		},
+		limit: run.limit,
+		inspected: run.inspected,
+		fromSaved: run.fromSaved,
+		oldestSaved: run.oldestSaved,
+		failed: run.failed,
+		stoppedBy: run.stoppedBy,
+		quota: run.quota,
+		byReason: byReason(run.rows),
+		rows: run.rows
+	};
+	return {
+		text: [...detail === "full" ? [`Google's indexing reasons for ${input.site}, every inspected URL as JSON, sorted by reason then URL:`, JSON.stringify(indexing)] : [
+			...detail === "summary" ? lostText : [],
+			...reasons,
+			`To see what changed, keep this run's full result (${deps.call("index", {
+				site: input.site,
+				max_urls: input.maxUrls,
+				detail: "full"
+			})}) and compare it with the next run by url and reason. Inspect the same number each week: the order is fixed, so the same first URLs come back. Where results are saved (the CLI and the local MCP), a URL inspected in the last 7 days is reused; any other URL is inspected again and uses URL Inspection quota.`,
+			`Next: ${firstFix ? deps.call("page", { url: firstFix.url }) : deps.call("page")} for one URL, including a URL from a Search Console email that is not in this set; ${deps.call("report", {
+				site: input.site,
+				section: "content-decay"
+			})} for pages that lost part of their clicks.`
+		], FACTS_ONLY].filter(Boolean).join("\n\n"),
+		data: {
+			range,
+			comparisonRange: before,
+			rule: LOST_PAGES_RULE,
+			lostPages: lost.length,
+			index: summary.data,
+			pages: rows,
+			indexing
+		}
+	};
+}
 //#endregion
 //#region packages/core/src/commands/tools.ts
 const site = z.string().min(1).describe("Search Console property or site, such as sc-domain:example.com, https://example.com/ or example.com.");
@@ -28801,44 +32694,249 @@ const DATA_SOURCES = [
 	"bing",
 	"clicky"
 ];
-z.object({}), `${Object.entries(SECTIONS).map(([id, text]) => `- ${id}: ${text}`).join("\n")}`, z.object({
-	site,
-	section: z.enum(SECTION_IDS).optional().describe("Optional. Leave it out first; then ask for one section."),
-	...dates,
-	...detail
-}), z.object({
-	url: z.url(),
-	...dates,
-	...detail
-}), z.object({
-	site,
-	date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("YYYY-MM-DD: the first day after the change."),
-	pages: z.string().min(1).optional().describe("Optional URL text, such as /blog/.")
-}), `${INDEXING_RULE}${LOST_PAGES_RULE}`, z.object({
-	site,
-	...dates,
-	...detail
-}), z.object({
-	site,
-	...dates,
-	max_urls: z.number().int().min(1).max(MAX_INSPECT_LIMIT).optional().describe(`URLs to inspect with Google, 100 by default, up to the URL Inspection quota left today.`),
-	...detail
-}), `${RESEARCH_HELP}`, z.object({
-	provider: z.enum(RESEARCH_PROVIDERS),
-	action: z.enum(RESEARCH_ACTIONS),
-	keywords: z.array(z.string().min(1)).max(100).default([]),
-	target: z.string().default("").describe("Domain or URL."),
-	country: z.string().regex(/^[a-z]{2}$/).default("us").describe("Two-letter country code."),
-	...detail
-}), z.object({
-	source: z.enum(DATA_SOURCES).default("search_console"),
-	site: z.string().min(1).describe("search_console and bing: the property or site. google_analytics: numeric property id from seo_sites. clicky: the site or its Clicky site ID."),
-	dimensions: z.array(z.enum(DIMENSIONS)).max(4).default(["query"]).describe("search_console; bing uses the first, query or page."),
-	page: z.string().min(1).optional().describe("search_console only: URL text, such as /blog/."),
-	query: z.string().min(1).optional().describe("search_console only: query text."),
-	...dates,
-	...detail
-});
+function tool(spec) {
+	return spec;
+}
+const SHARED_TOOLS = [
+	tool({
+		name: "seo_sites",
+		command: "data",
+		title: "List sites",
+		description: "Lists the Search Console and Google Analytics properties the connected Google accounts can read, the Bing Webmaster site for each, and which research keys are set. Call it first.",
+		input: z.object({}),
+		run: async (surface) => runSites({
+			accounts: await surface.accounts(),
+			keys: await surface.keys(),
+			clicky: clickySites(await surface.keys()).map(clickyLabel),
+			signIn: surface.signIn,
+			bing: surface.deps.bing ? await surface.deps.bing() : void 0,
+			connect: surface.connect
+		})
+	}),
+	tool({
+		name: "seo_report",
+		command: "report",
+		title: "Search Console report",
+		description: `The main report for a Search Console property. Without a section it returns the overview plus each section's row count and top rows. With a section it returns that section's rows; page sections also check their top 20 URLs live. Sections:\n${Object.entries(SECTIONS).map(([id, text]) => `- ${id}: ${text}`).join("\n")}`,
+		input: z.object({
+			site,
+			section: z.enum(SECTION_IDS).optional().describe("Optional. Leave it out first; then ask for one section."),
+			...dates,
+			...detail
+		}),
+		run: async (surface, input) => {
+			const resolved = await surface.resolveSite(input.site).catch((error) => error instanceof Error ? error : new Error(String(error)));
+			if (resolved instanceof Error && !input.section && surface.deps.bing) return runBingReport({
+				site: input.site,
+				startDate: input.start_date,
+				endDate: input.end_date
+			}, surface.deps).catch(() => {
+				throw resolved;
+			});
+			if (resolved instanceof Error && input.section !== "bing") throw resolved;
+			return runReport({
+				site: resolved instanceof Error ? input.site : resolved,
+				section: input.section,
+				startDate: input.start_date,
+				endDate: input.end_date,
+				detail: input.detail,
+				offset: input.offset
+			}, surface.deps);
+		}
+	}),
+	tool({
+		name: "seo_page",
+		command: "page",
+		title: "One page",
+		description: "Everything for one URL: live page facts (status, redirect, title, description, H1, canonical, robots), Google’s index status from URL Inspection, and the page’s Search Console queries against the previous period.",
+		input: z.object({
+			url: z.url(),
+			...dates,
+			...detail
+		}),
+		run: async (surface, input) => runPage({
+			site: await surface.resolveSite(input.url),
+			url: input.url,
+			startDate: input.start_date,
+			endDate: input.end_date,
+			detail: input.detail,
+			offset: input.offset
+		}, surface.deps)
+	}),
+	tool({
+		name: "seo_compare",
+		command: "compare",
+		title: "Before and after a date",
+		description: "Compares equal periods before and after a date, such as a site change or a Google update: totals, devices, and the pages and queries that moved, Google Analytics sessions from the property whose web stream matches the site, and Google updates in the window. Optional pages narrows it to URLs that contain that text, such as /blog/.",
+		input: z.object({
+			site,
+			date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("YYYY-MM-DD: the first day after the change."),
+			pages: z.string().min(1).optional().describe("Optional URL text, such as /blog/.")
+		}),
+		run: async (surface, input) => runCompare({
+			site: await surface.resolveSite(input.site),
+			date: input.date,
+			pages: input.pages
+		}, surface.deps)
+	}),
+	tool({
+		name: "seo_index",
+		command: "index",
+		title: "Google indexing reasons and pages that lost their clicks",
+		description: `${INDEXING_RULE} Use it for a first baseline and then weekly: keep the full result and compare by URL and reason to find new reasons. Also: ${LOST_PAGES_RULE}`,
+		input: z.object({
+			site,
+			...dates,
+			...detail
+		}),
+		localInput: z.object({
+			site,
+			...dates,
+			max_urls: z.number().int().min(1).max(MAX_INSPECT_LIMIT).optional().describe(`URLs to inspect with Google, 100 by default, up to the URL Inspection quota left today.`),
+			...detail
+		}),
+		run: async (surface, input) => runLostPages({
+			site: await surface.resolveSite(input.site),
+			startDate: input.start_date,
+			endDate: input.end_date,
+			detail: input.detail,
+			offset: input.offset,
+			maxUrls: input.max_urls
+		}, surface.deps)
+	}),
+	tool({
+		name: "seo_research",
+		command: "research",
+		title: "Keyword, competitor, backlink and AI answer data",
+		description: `Data from the person’s own DataForSEO or Ahrefs account, which costs them credits. It uses the key the person saved on their seoskill.dev account (or on this machine for the CLI). Actions: ${RESEARCH_HELP}`,
+		input: z.object({
+			provider: z.enum(RESEARCH_PROVIDERS),
+			action: z.enum(RESEARCH_ACTIONS),
+			keywords: z.array(z.string().min(1)).max(100).default([]),
+			target: z.string().default("").describe("Domain or URL."),
+			country: z.string().regex(/^[a-z]{2}$/).default("us").describe("Two-letter country code."),
+			...detail
+		}),
+		run: async (surface, input) => {
+			const more = (offset) => `seo_research with the same input, detail "rows", offset ${offset}`;
+			if (input.action === "ai_answers") {
+				if (input.provider !== "dataforseo") throw new CommandError("INVALID_INPUT", "ai_answers uses dataforseo.");
+				return runAiAnswers({
+					site: await surface.resolveSite(input.target),
+					country: input.country,
+					detail: input.detail,
+					offset: input.offset
+				}, await surface.keys(), surface.deps, more);
+			}
+			return runResearch(input, await surface.keys(), {
+				drKey: surface.drKey,
+				call: more
+			});
+		}
+	}),
+	tool({
+		name: "seo_data",
+		command: "data",
+		title: "Raw rows",
+		description: `Raw rows for questions the report does not answer. search_console (default): rows for any dimensions, each with the previous period and the change; page and query narrow to rows whose URL or query contains that text. google_analytics: landing pages for visits from search, with Google Analytics’ own metric names. bing: Bing Webmaster query or page rows (first dimension) for the same site, by week. clicky: landing-page visits, traffic sources and search engines from a Clicky site the person saved (site is its domain or Clicky site ID; at most 31 days).`,
+		input: z.object({
+			source: z.enum(DATA_SOURCES).default("search_console"),
+			site: z.string().min(1).describe("search_console and bing: the property or site. google_analytics: numeric property id from seo_sites. clicky: the site or its Clicky site ID."),
+			dimensions: z.array(z.enum(DIMENSIONS)).max(4).default(["query"]).describe("search_console; bing uses the first, query or page."),
+			page: z.string().min(1).optional().describe("search_console only: URL text, such as /blog/."),
+			query: z.string().min(1).optional().describe("search_console only: query text."),
+			...dates,
+			...detail
+		}),
+		run: async (surface, input) => {
+			if (input.source === "clicky") return runClickyRows({
+				site: input.site,
+				startDate: input.start_date,
+				endDate: input.end_date,
+				detail: input.detail,
+				offset: input.offset
+			}, await surface.keys(), {
+				connect: surface.connect,
+				call: (offset) => `seo_data with source "clicky", site "${input.site}", detail "rows", offset ${offset}`,
+				refresh: surface.refreshClicky
+			});
+			if (input.source === "bing") return runBingRows({
+				site: input.site,
+				dimension: input.dimensions[0] === "page" ? "page" : "query",
+				startDate: input.start_date,
+				endDate: input.end_date,
+				detail: input.detail,
+				offset: input.offset
+			}, surface.deps);
+			if (input.source === "google_analytics") return runAnalyticsRows({
+				property: input.site,
+				startDate: input.start_date,
+				endDate: input.end_date,
+				detail: input.detail,
+				offset: input.offset
+			}, await analyticsSignIn(await surface.accounts(), input.site, surface.signIn), {
+				signIn: surface.signIn,
+				call: (offset) => `seo_data with source "google_analytics", site "${input.site}", detail "rows", offset ${offset}`
+			});
+			return runRows({
+				site: await surface.resolveSite(input.site),
+				dimensions: input.dimensions,
+				filters: [...input.page ? [{
+					dimension: "page",
+					operator: "contains",
+					expression: input.page
+				}] : [], ...input.query ? [{
+					dimension: "query",
+					operator: "contains",
+					expression: input.query
+				}] : []],
+				startDate: input.start_date,
+				endDate: input.end_date,
+				detail: input.detail,
+				offset: input.offset
+			}, surface.deps);
+		}
+	})
+];
+function indexFromStore(shared) {
+	const paged = "detail" in shared.input.shape;
+	return {
+		...shared,
+		description: `${shared.description} For a site in the weekly site audit beta it answers at once from the URL Inspection results this server keeps for the site, checked in the background each day, and says how many URLs are covered, how many are queued and the time left.`,
+		run: async (surface, parsed) => {
+			const input = parsed;
+			const audit = surface.deps.audit;
+			if (!audit) return shared.run(surface, parsed);
+			const site = await surface.resolveSite(input.site);
+			const detail = input.detail ?? "summary";
+			const offset = detail === "rows" ? input.offset ?? 0 : 0;
+			const limit = detail === "rows" ? 50 : 20;
+			let checks = await audit.checks(site, offset, limit);
+			if (!checks) {
+				if (await audit.add(site) === "full") {
+					const result = await shared.run(surface, parsed);
+					return {
+						text: `${result.text}\n\n${site} is not in the weekly site audit, and this account already audits the most sites the beta allows, so this ran the usual way. Remove a site under Beta on the account page to keep its checks here.`,
+						data: result.data
+					};
+				}
+				checks = await audit.checks(site, offset, limit);
+				if (!checks) throw new Error(`The audit of ${site} did not start.`);
+			}
+			return runAuditChecks({
+				site,
+				detail,
+				offset,
+				paged
+			}, checks, surface.deps.call);
+		}
+	};
+}
+SHARED_TOOLS.map((shared) => shared.name === "seo_index" ? indexFromStore(shared) : shared.name === "seo_report" ? {
+	...shared,
+	description: `${shared.description}\n- ${AUDIT_SECTION}: ${AUDIT_SECTION_TEXT}`,
+	input: shared.input.extend({ section: z.enum([...SECTION_IDS, AUDIT_SECTION]).optional().describe("Optional. Leave it out first; then ask for one section.") })
+} : shared);
 //#endregion
 //#region packages/core/src/gsc/client/inspection-cache.ts
 const INSPECTION_FRESH_MS = 7 * 864e5;