@gscdump/analysis 1.4.0 → 1.4.1

package/dist/report/format.mjs

@@ -0,0 +1,45 @@
+const SEVERITY_GLYPH = {
+	info: "i",
+	low: "·",
+	medium: "!",
+	high: "!!"
+};
+function formatReport(report, opts = {}) {
+	const lines = [];
+	lines.push(`# ${report.id} — ${report.site}`);
+	lines.push(`window: ${report.window.start} → ${report.window.end} (${report.window.days}d)`);
+	if (report.window.comparison) lines.push(`compare: ${report.window.comparison.start} → ${report.window.comparison.end}`);
+	if (report.meta.degraded) lines.push(`! degraded: ${report.meta.steps.filter((s) => s.status === "error").map((s) => s.key).join(", ")}`);
+	lines.push("");
+	if (report.sections.length === 0) {
+		lines.push("(no sections)");
+		return lines.join("\n");
+	}
+	for (const section of report.sections) lines.push(...renderSection(section, opts.maxFindingsPerSection));
+	return lines.join("\n");
+}
+function renderSection(section, cap) {
+	const lines = [];
+	const glyph = SEVERITY_GLYPH[section.severity] ?? "";
+	lines.push(`## ${glyph} ${section.title}${section.coverage === "partial" ? " (partial)" : ""}`);
+	if (section.summary.magnitudeLabel) lines.push(`   ${section.summary.magnitudeLabel}`);
+	const findings = cap ? section.findings.slice(0, cap) : section.findings;
+	for (const f of findings) {
+		const metricsStr = Object.entries(f.metrics).map(([k, v]) => `${k}=${formatNumber(v)}`).join(" ");
+		lines.push(`   - [${f.entity.kind}] ${f.entity.value} ${metricsStr}${f.why ? ` — ${f.why}` : ""}`);
+	}
+	if (section.truncated && section.truncated.kept < section.truncated.total) lines.push(`   … +${section.truncated.total - section.truncated.kept} more`);
+	for (const a of section.actions) {
+		const target = a.target ? ` ${a.target.kind}=${a.target.value}` : "";
+		lines.push(`   → ${a.kind}${target}: ${a.rationale}`);
+		if (a.cliHint) lines.push(`     $ ${a.cliHint}`);
+	}
+	lines.push("");
+	return lines;
+}
+function formatNumber(n) {
+	if (!Number.isFinite(n)) return String(n);
+	if (Number.isInteger(n)) return String(n);
+	return n.toFixed(2);
+}
+export { formatReport };

package/dist/report/index.d.mts

@@ -1,2 +1,5 @@
-import { DryRunReportResult, FormatReportOptions, REPORTS, ResolveTargetInput, ResolveTargetKind, ResolveTargetResult, RunReportOptions, defaultReportRegistry, dryRunReport, formatReport, resolveTarget, runReport, runReportResult } from "../_chunks/index.mjs";
+import { FormatReportOptions, formatReport } from "./format.mjs";
+import { REPORTS, defaultReportRegistry } from "./registry.mjs";
+import { ResolveTargetInput, ResolveTargetKind, ResolveTargetResult, resolveTarget } from "./resolve-target.mjs";
+import { DryRunReportResult, RunReportOptions, dryRunReport, runReport, runReportResult } from "./runtime.mjs";
 export { type DryRunReportResult, type FormatReportOptions, REPORTS, type ResolveTargetInput, type ResolveTargetKind, type ResolveTargetResult, type RunReportOptions, defaultReportRegistry, dryRunReport, formatReport, resolveTarget, runReport, runReportResult };

package/dist/report/index.mjs

@@ -1,2 +1,5 @@
-import { REPORTS, defaultReportRegistry, dryRunReport, formatReport, resolveTarget, runReport, runReportResult } from "../_chunks/report.mjs";
+import { formatReport } from "./format.mjs";
+import { resolveTarget } from "./resolve-target.mjs";
+import { REPORTS, defaultReportRegistry } from "./registry.mjs";
+import { dryRunReport, runReport, runReportResult } from "./runtime.mjs";
 export { REPORTS, defaultReportRegistry, dryRunReport, formatReport, resolveTarget, runReport, runReportResult };

package/dist/report/registry.d.mts

@@ -0,0 +1,4 @@
+import { DefinedReport, ReportParams } from "@gscdump/engine/report";
+declare const REPORTS: readonly DefinedReport<ReportParams>[];
+declare const defaultReportRegistry: import("@gscdump/engine/report").ReportRegistry;
+export { REPORTS, defaultReportRegistry };

package/dist/report/registry.mjs

@@ -0,0 +1,26 @@
+import { brandReport } from "./reports/brand.mjs";
+import { growthReport } from "./reports/growth.mjs";
+import { healthReport } from "./reports/health.mjs";
+import { moversReport } from "./reports/movers.mjs";
+import { opportunitiesReport } from "./reports/opportunities.mjs";
+import { prePublishReport } from "./reports/pre-publish.mjs";
+import { priorityReport } from "./reports/priority.mjs";
+import { risksReport } from "./reports/risks.mjs";
+import { triageReport } from "./reports/triage.mjs";
+import { createReportRegistry } from "@gscdump/engine/report";
+const REPORTS = [
+	brandReport,
+	growthReport,
+	healthReport,
+	moversReport,
+	opportunitiesReport,
+	prePublishReport,
+	priorityReport,
+	risksReport,
+	triageReport
+];
+const defaultReportRegistry = createReportRegistry({
+	reports: REPORTS,
+	version: "0"
+});
+export { REPORTS, defaultReportRegistry };

package/dist/report/reports/brand.mjs

@@ -0,0 +1,104 @@
+import { requireReportParam } from "../require.mjs";
+import { reportRows, sectionArtifact, sectionCoverage } from "../sections.mjs";
+import { defineReport } from "@gscdump/engine/report";
+const DEFAULT_MAX = 5;
+const brandReport = defineReport({
+	id: "brand",
+	description: "Brand vs non-brand share, top brand keywords, and site-wide keyword concentration.",
+	defaultPeriod: "last-28d",
+	defaultComparison: "none",
+	argsSpec: {
+		"brand-terms": {
+			type: "string",
+			description: "Comma-separated brand terms",
+			required: true
+		},
+		"max-findings": {
+			type: "number",
+			description: "Cap findings per section",
+			default: DEFAULT_MAX
+		}
+	},
+	plan: (params, window) => {
+		const brandTerms = requireReportParam("brand", "brand-terms", params.brandTerms, "brand report requires --brand-terms <comma,separated,list>").split(",").map((t) => t.trim()).filter(Boolean);
+		const dates = {
+			startDate: window.start,
+			endDate: window.end
+		};
+		return [{
+			key: "brand",
+			type: "brand",
+			params: {
+				...dates,
+				brandTerms,
+				limit: 200
+			},
+			required: true
+		}, {
+			key: "concentration",
+			type: "concentration",
+			params: {
+				...dates,
+				dimension: "keywords",
+				limit: 50
+			}
+		}];
+	},
+	reduce: (results, ctx) => {
+		const max = ctx.params.maxFindings ?? DEFAULT_MAX;
+		return { sections: [buildBrandSplitSection(results.brand, max), buildConcentrationSection(results.concentration, max)] };
+	}
+});
+function buildBrandSplitSection(res, max) {
+	const rows = reportRows(res);
+	const summary = res?.meta?.summary;
+	const findings = rows.filter((r) => r.segment === "brand").sort((a, b) => b.clicks - a.clicks).slice(0, max).map((r) => ({
+		entity: {
+			kind: "query",
+			value: r.query
+		},
+		metrics: {
+			clicks: r.clicks,
+			impressions: r.impressions,
+			ctr: r.ctr,
+			position: r.position
+		},
+		why: r.page ? `on ${r.page}` : void 0
+	}));
+	const brandShare = summary?.brandShare ?? 0;
+	return {
+		id: "brand-split",
+		title: "Brand vs non-brand",
+		severity: "info",
+		summary: { magnitudeLabel: summary ? `brand share ${(brandShare * 100).toFixed(1)}% (${summary.brandClicks} brand vs ${summary.nonBrandClicks} non-brand clicks)` : "no summary available" },
+		findings,
+		coverage: sectionCoverage(res),
+		actions: [],
+		artifact: sectionArtifact(res, "brand")
+	};
+}
+function buildConcentrationSection(res, max) {
+	const head = reportRows(res)[0];
+	const findings = (head?.topNItems ?? []).slice(0, max).map((it) => ({
+		entity: {
+			kind: "query",
+			value: it.key
+		},
+		metrics: {
+			clicks: it.clicks,
+			share: it.share
+		}
+	}));
+	const severity = head?.riskLevel === "high" ? "high" : head?.riskLevel === "medium" ? "medium" : "low";
+	return {
+		id: "concentration",
+		title: "Keyword concentration (site-wide)",
+		severity: head ? severity : "info",
+		summary: head ? { magnitudeLabel: `HHI ${head.hhi.toFixed(0)} (${head.riskLevel}); top-N share ${(head.topNConcentration * 100).toFixed(1)}%` } : {},
+		findings,
+		coverage: sectionCoverage(res),
+		actions: [],
+		artifact: sectionArtifact(res, "concentration", { dimension: "keywords" })
+	};
+}
+export { brandReport };

package/dist/report/reports/growth.mjs

@@ -0,0 +1,144 @@
+import { reportRows, sectionArtifact, sectionCoverage, truncation } from "../sections.mjs";
+import { defineReport } from "@gscdump/engine/report";
+const DEFAULT_MAX = 5;
+const growthReport = defineReport({
+	id: "growth",
+	description: "Strategic growth signals: content velocity, keyword breadth, intent atlas, and long-tail shape over a long window (default 90d / YoY).",
+	defaultPeriod: "last-90d",
+	defaultComparison: "yoy",
+	argsSpec: { "max-findings": {
+		type: "number",
+		description: "Cap findings per section (long-tail only)",
+		default: DEFAULT_MAX
+	} },
+	plan: (_params, window) => {
+		const dates = {
+			startDate: window.start,
+			endDate: window.end
+		};
+		return [
+			{
+				key: "content-velocity",
+				type: "content-velocity",
+				params: {
+					...dates,
+					days: window.days,
+					limit: 200
+				}
+			},
+			{
+				key: "keyword-breadth",
+				type: "keyword-breadth",
+				params: {
+					...dates,
+					limit: 50
+				}
+			},
+			{
+				key: "intent-atlas",
+				type: "intent-atlas",
+				params: {
+					...dates,
+					limit: 50
+				}
+			},
+			{
+				key: "long-tail",
+				type: "long-tail",
+				params: {
+					...dates,
+					limit: 100
+				}
+			}
+		];
+	},
+	reduce: (results, ctx) => {
+		const max = ctx.params.maxFindings ?? DEFAULT_MAX;
+		return { sections: [
+			buildContentVelocity(results["content-velocity"]),
+			buildKeywordBreadth(results["keyword-breadth"]),
+			buildIntentAtlas(results["intent-atlas"]),
+			buildLongTail(results["long-tail"], max)
+		] };
+	}
+});
+function buildContentVelocity(res) {
+	const rows = reportRows(res);
+	const totalNew = rows.reduce((s, r) => s + r.newKeywords, 0);
+	const avgPerWeek = rows.length > 0 ? totalNew / rows.length : 0;
+	return {
+		id: "content-velocity",
+		title: "Content velocity",
+		severity: "info",
+		summary: { magnitudeLabel: `${totalNew} new keywords across ${rows.length} weeks (avg ${avgPerWeek.toFixed(1)}/wk)` },
+		findings: [],
+		coverage: sectionCoverage(res),
+		actions: [],
+		artifact: sectionArtifact(res, "content-velocity")
+	};
+}
+function buildKeywordBreadth(res) {
+	const rows = reportRows(res);
+	const totalPages = rows.reduce((s, r) => s + r.pageCount, 0);
+	const top = rows[0];
+	return {
+		id: "keyword-breadth",
+		title: "Keyword breadth",
+		severity: "info",
+		summary: { magnitudeLabel: top ? `${totalPages} pages; modal bucket "${top.bucket}" (${top.pageCount} pages)` : "no data" },
+		findings: [],
+		coverage: sectionCoverage(res),
+		actions: [],
+		artifact: sectionArtifact(res, "keyword-breadth")
+	};
+}
+function buildIntentAtlas(res) {
+	const rows = reportRows(res);
+	return {
+		id: "intent-atlas",
+		title: "Intent atlas",
+		severity: "info",
+		summary: { magnitudeLabel: `${rows.length} clusters covering ${rows.reduce((s, r) => s + r.keywordCount, 0)} keywords` },
+		findings: [],
+		coverage: sectionCoverage(res),
+		actions: [],
+		artifact: sectionArtifact(res, "intent-atlas")
+	};
+}
+function buildLongTail(res, max) {
+	const rows = reportRows(res).sort((a, b) => {
+		const rank = {
+			"head-heavy": 0,
+			"balanced": 1,
+			"flat-tail": 2
+		};
+		const dr = rank[a.fingerprint] - rank[b.fingerprint];
+		return dr !== 0 ? dr : b.headShare - a.headShare;
+	});
+	const kept = rows.slice(0, max);
+	const findings = kept.map((r) => ({
+		entity: {
+			kind: "page",
+			value: r.page
+		},
+		metrics: {
+			queryCount: r.queryCount,
+			impressions: r.totalImpressions,
+			headShare: r.headShare
+		},
+		why: `${r.fingerprint} (${(r.headShare * 100).toFixed(0)}% head share)`
+	}));
+	const headHeavy = rows.filter((r) => r.fingerprint === "head-heavy").length;
+	return {
+		id: "long-tail",
+		title: "Long-tail shape",
+		severity: headHeavy > rows.length / 3 ? "medium" : "info",
+		summary: { magnitudeLabel: `${rows.length} pages analysed; ${headHeavy} head-heavy` },
+		findings,
+		truncated: truncation(rows.length, kept.length),
+		coverage: sectionCoverage(res),
+		actions: [],
+		artifact: sectionArtifact(res, "long-tail")
+	};
+}
+export { growthReport };

package/dist/report/reports/health.mjs

@@ -0,0 +1,141 @@
+import { reportRows, sectionArtifact, sectionCoverage, truncation } from "../sections.mjs";
+import { defineReport } from "@gscdump/engine/report";
+const DEFAULT_MAX = 5;
+const healthReport = defineReport({
+	id: "health",
+	description: "CTR anomalies, change-points, and position-volatility hot spots in the recent window.",
+	defaultPeriod: "last-28d",
+	defaultComparison: "none",
+	argsSpec: { "max-findings": {
+		type: "number",
+		description: "Cap findings per section",
+		default: DEFAULT_MAX
+	} },
+	plan: (_params, window) => {
+		const dates = {
+			startDate: window.start,
+			endDate: window.end
+		};
+		return [
+			{
+				key: "ctr-anomaly",
+				type: "ctr-anomaly",
+				params: {
+					...dates,
+					limit: 100
+				},
+				required: true
+			},
+			{
+				key: "change-point",
+				type: "change-point",
+				params: {
+					...dates,
+					limit: 100
+				}
+			},
+			{
+				key: "position-volatility",
+				type: "position-volatility",
+				params: {
+					...dates,
+					limit: 100
+				}
+			}
+		];
+	},
+	reduce: (results, ctx) => {
+		const max = ctx.params.maxFindings ?? DEFAULT_MAX;
+		return { sections: [
+			buildCtrAnomalySection(results["ctr-anomaly"], max),
+			buildChangePointSection(results["change-point"], max),
+			buildPositionVolatilitySection(results["position-volatility"], max)
+		] };
+	}
+});
+function buildCtrAnomalySection(res, max) {
+	const rows = reportRows(res).filter((r) => r.breachDaysDown > 0).sort((a, b) => b.clicksLost - a.clicksLost);
+	const kept = rows.slice(0, max);
+	const totalLost = kept.reduce((s, r) => s + r.clicksLost, 0);
+	const findings = kept.map((r) => ({
+		entity: {
+			kind: "query",
+			value: r.keyword
+		},
+		metrics: {
+			clicksLost: r.clicksLost,
+			breachDays: r.breachDaysDown,
+			severity: r.severity,
+			baselineCtr: r.baselineCtr
+		},
+		why: r.page ? `on ${r.page}` : void 0
+	}));
+	return {
+		id: "ctr-anomaly",
+		title: "CTR anomalies",
+		severity: totalLost >= 100 ? "high" : totalLost >= 25 ? "medium" : kept.length ? "low" : "info",
+		summary: {
+			delta: -totalLost,
+			direction: totalLost > 0 ? "down" : "flat",
+			magnitudeLabel: `${Math.round(totalLost)} clicks lost vs baseline`
+		},
+		findings,
+		truncated: truncation(rows.length, kept.length),
+		coverage: sectionCoverage(res),
+		actions: [],
+		artifact: sectionArtifact(res, "ctr-anomaly")
+	};
+}
+function buildChangePointSection(res, max) {
+	const rows = reportRows(res).filter((r) => r.direction === "worsened").sort((a, b) => b.llr - a.llr);
+	const kept = rows.slice(0, max);
+	const findings = kept.map((r) => ({
+		entity: {
+			kind: "query",
+			value: r.keyword
+		},
+		metrics: {
+			llr: r.llr,
+			delta: r.delta
+		},
+		why: `worsened on ${r.changeDate}${r.page ? ` (${r.page})` : ""}`
+	}));
+	return {
+		id: "change-point",
+		title: "Change-points (worsening)",
+		severity: kept.length ? "medium" : "info",
+		summary: { magnitudeLabel: `${kept.length} worsening segments` },
+		findings,
+		truncated: truncation(rows.length, kept.length),
+		coverage: sectionCoverage(res),
+		actions: [],
+		artifact: sectionArtifact(res, "change-point")
+	};
+}
+function buildPositionVolatilitySection(res, max) {
+	const rows = reportRows(res).sort((a, b) => b.peakVolatility - a.peakVolatility);
+	const kept = rows.slice(0, max);
+	const findings = kept.map((r) => ({
+		entity: {
+			kind: "page",
+			value: r.page
+		},
+		metrics: {
+			avgVolatility: r.avgVolatility,
+			peakVolatility: r.peakVolatility,
+			impressions: r.totalImpressions
+		}
+	}));
+	return {
+		id: "position-volatility",
+		title: "Position volatility",
+		severity: kept.length ? "low" : "info",
+		summary: {},
+		findings,
+		truncated: truncation(rows.length, kept.length),
+		coverage: sectionCoverage(res),
+		actions: [],
+		artifact: sectionArtifact(res, "position-volatility")
+	};
+}
+export { healthReport };

package/dist/report/reports/movers.mjs

@@ -0,0 +1,203 @@
+import { requireComparisonWindow } from "../require.mjs";
+import { reportRows, sectionArtifact, sectionCoverage, truncation } from "../sections.mjs";
+import { defineReport } from "@gscdump/engine/report";
+const DEFAULT_MAX = 5;
+const DEFAULT_MIN_CHANGE = 5;
+const moversReport = defineReport({
+	id: "movers",
+	description: "Risers, decliners, and striking-distance opportunities over a current vs prior window.",
+	defaultPeriod: "last-7d",
+	defaultComparison: "prev-period",
+	argsSpec: {
+		"max-findings": {
+			type: "number",
+			description: "Cap findings per section",
+			default: DEFAULT_MAX
+		},
+		"min-clicks-change": {
+			type: "number",
+			description: "Min absolute click change",
+			default: DEFAULT_MIN_CHANGE
+		}
+	},
+	plan: (_params, window) => {
+		const comparison = requireComparisonWindow("movers", window, "movers report requires a comparison window — pass --vs prev-period");
+		const cur = {
+			startDate: window.start,
+			endDate: window.end
+		};
+		const prev = {
+			prevStartDate: comparison.start,
+			prevEndDate: comparison.end
+		};
+		return [
+			{
+				key: "movers",
+				type: "movers",
+				params: {
+					...cur,
+					...prev,
+					limit: 200
+				},
+				required: true
+			},
+			{
+				key: "decay",
+				type: "decay",
+				params: {
+					...cur,
+					...prev,
+					limit: 100
+				}
+			},
+			{
+				key: "striking",
+				type: "striking-distance",
+				params: {
+					...cur,
+					limit: 100
+				}
+			}
+		];
+	},
+	reduce: (results, ctx) => {
+		const max = ctx.params.maxFindings ?? DEFAULT_MAX;
+		const minChange = ctx.params.minClicksChange ?? DEFAULT_MIN_CHANGE;
+		const sections = [];
+		const moversRes = results.movers;
+		const decayRes = results.decay;
+		const strikingRes = results.striking;
+		sections.push(buildMoversSection(moversRes, "rising", max, minChange));
+		sections.push(buildDeclinersSection(moversRes, decayRes, max, minChange));
+		sections.push(buildStrikingSection(strikingRes, max));
+		return { sections };
+	}
+});
+function buildMoversSection(res, direction, max, minChange) {
+	const rows = reportRows(res).filter((r) => r.direction === direction && Math.abs(r.clicksChange) >= minChange).sort((a, b) => Math.abs(b.clicksChange) - Math.abs(a.clicksChange));
+	const total = rows.length;
+	const kept = rows.slice(0, max);
+	const findings = kept.map((r) => ({
+		entity: {
+			kind: "query",
+			value: r.keyword
+		},
+		metrics: {
+			clicks: r.recentClicks,
+			clicksChange: r.clicksChange,
+			clicksChangePercent: r.clicksChangePercent,
+			...r.positionChange != null ? { positionChange: r.positionChange } : {}
+		},
+		delta: {
+			metric: "clicks",
+			prior: r.baselineClicks,
+			current: r.recentClicks,
+			pct: r.clicksChangePercent
+		},
+		why: r.page ? `on ${r.page}` : void 0
+	}));
+	const totalDelta = kept.reduce((sum, r) => sum + r.clicksChange, 0);
+	return {
+		id: direction,
+		title: direction === "rising" ? "Rising queries" : "Declining queries",
+		severity: direction === "rising" ? "info" : "medium",
+		summary: {
+			delta: totalDelta,
+			direction: totalDelta > 0 ? "up" : totalDelta < 0 ? "down" : "flat"
+		},
+		findings,
+		truncated: truncation(total, kept.length),
+		coverage: sectionCoverage(res),
+		actions: [],
+		artifact: sectionArtifact(res, "movers")
+	};
+}
+function buildDeclinersSection(moversRes, decayRes, max, minChange) {
+	const decliningQueries = reportRows(moversRes).filter((r) => r.direction === "declining" && Math.abs(r.clicksChange) >= minChange).slice(0, max);
+	const lostPages = reportRows(decayRes).sort((a, b) => b.lostClicks - a.lostClicks).slice(0, max);
+	const findings = [...decliningQueries.map((r) => ({
+		entity: {
+			kind: "query",
+			value: r.keyword
+		},
+		metrics: {
+			clicks: r.recentClicks,
+			clicksChange: r.clicksChange
+		},
+		delta: {
+			metric: "clicks",
+			prior: r.baselineClicks,
+			current: r.recentClicks,
+			pct: r.clicksChangePercent
+		}
+	})), ...lostPages.map((r) => ({
+		entity: {
+			kind: "page",
+			value: r.page
+		},
+		metrics: {
+			clicks: r.currentClicks,
+			lostClicks: r.lostClicks,
+			declinePercent: r.declinePercent
+		},
+		delta: {
+			metric: "clicks",
+			prior: r.previousClicks,
+			current: r.currentClicks,
+			pct: -r.declinePercent * 100
+		},
+		why: "page-level decay"
+	}))];
+	const totalLost = decliningQueries.reduce((s, r) => s + Math.abs(r.clicksChange), 0) + lostPages.reduce((s, r) => s + r.lostClicks, 0);
+	return {
+		id: "decliners",
+		title: "Decliners",
+		severity: totalLost >= 100 ? "high" : totalLost >= 25 ? "medium" : "low",
+		summary: {
+			delta: -totalLost,
+			direction: totalLost > 0 ? "down" : "flat",
+			magnitudeLabel: `${Math.round(totalLost)} clicks lost`
+		},
+		findings,
+		coverage: decayRes && moversRes ? "full" : "partial",
+		actions: lostPages.slice(0, 1).map((r) => ({
+			kind: "analyzer",
+			target: {
+				kind: "page",
+				value: r.page
+			},
+			params: { type: "change-point" },
+			rationale: "Investigate the change-point on the worst-affected page",
+			cliHint: `gscdump analyze change-point --start <date> --end <date>`
+		}))
+	};
+}
+function buildStrikingSection(res, max) {
+	const rows = reportRows(res).sort((a, b) => b.potentialClicks - a.potentialClicks);
+	const kept = rows.slice(0, max);
+	const findings = kept.map((r) => ({
+		entity: {
+			kind: "query",
+			value: r.keyword
+		},
+		metrics: {
+			position: r.position,
+			impressions: r.impressions,
+			clicks: r.clicks,
+			potentialClicks: r.potentialClicks
+		},
+		why: r.page ? `currently on ${r.page}` : void 0
+	}));
+	return {
+		id: "striking-distance",
+		title: "Striking-distance opportunities",
+		severity: "low",
+		summary: { magnitudeLabel: `${kept.reduce((s, r) => s + r.potentialClicks, 0)} potential clicks` },
+		findings,
+		truncated: truncation(rows.length, kept.length),
+		coverage: sectionCoverage(res),
+		actions: [],
+		artifact: sectionArtifact(res, "striking-distance")
+	};
+}
+export { moversReport };