@gscdump/analysis 0.4.0

package/dist/default-registry.mjs

@@ -0,0 +1,1957 @@
+import { SQL_ANALYZERS } from "@gscdump/engine-duckdb-node";
+import { enumeratePartitions } from "@gscdump/engine/planner";
+import { METRIC_EXPR } from "@gscdump/engine/sql-fragments";
+import { between, date, gsc, page, query } from "gscdump/query";
+import { daysAgo } from "gscdump";
+function createAnalyzerRegistry(init = {}) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const a of init.rows ?? []) {
+		const entry = byId.get(a.id) ?? {};
+		entry.rows = a;
+		byId.set(a.id, entry);
+	}
+	for (const a of init.sql ?? []) {
+		const entry = byId.get(a.id) ?? {};
+		entry.sql = a;
+		byId.set(a.id, entry);
+	}
+	const listAnalyzerIds = () => [...byId.keys()].sort();
+	const getAnalyzerVariants = (id) => byId.get(id);
+	const resolveAnalyzer = (id, sourceSupportsSql) => {
+		const variants = byId.get(id);
+		if (!variants) return void 0;
+		if (sourceSupportsSql) return variants.sql ?? variants.rows;
+		return variants.rows;
+	};
+	const listAnalyzersFor = (sourceSupportsSql) => {
+		const out = [];
+		for (const id of listAnalyzerIds()) {
+			const a = resolveAnalyzer(id, sourceSupportsSql);
+			if (a) out.push(a);
+		}
+		return out;
+	};
+	const listAnalyzerIdsFor = (source) => {
+		const sourceSupportsSql = typeof source.executeSql === "function";
+		const out = [];
+		for (const id of listAnalyzerIds()) if (resolveAnalyzer(id, sourceSupportsSql)) out.push(id);
+		return out;
+	};
+	return {
+		listAnalyzerIds,
+		getAnalyzerVariants,
+		resolveAnalyzer,
+		listAnalyzersFor,
+		listAnalyzerIdsFor
+	};
+}
+const DEFAULT_LIMIT$1 = 25e3;
+function keywordsQueryState(period, limit = DEFAULT_LIMIT$1) {
+	return gsc.select(query, page).where(between(date, period.startDate, period.endDate)).limit(limit).getState();
+}
+function pagesQueryState(period, limit = DEFAULT_LIMIT$1) {
+	return gsc.select(page).where(between(date, period.startDate, period.endDate)).limit(limit).getState();
+}
+function datesQueryState(period, limit = DEFAULT_LIMIT$1) {
+	return gsc.select(date).where(between(date, period.startDate, period.endDate)).limit(limit).getState();
+}
+const DEFAULT_SQL_REQUIRES = ["executeSql", "partitionedParquet"];
+function defineAnalyzer(opts) {
+	const { id, reduce, reduceSql, reduceRows, buildSql, buildRows, sqlRequires = DEFAULT_SQL_REQUIRES, rowsRequires = [] } = opts;
+	const sqlReducer = reduceSql ?? reduce;
+	const rowsReducer = reduceRows ?? reduce;
+	if (buildSql && !sqlReducer) throw new Error(`defineAnalyzer(${id}): buildSql requires reduce or reduceSql`);
+	if (buildRows && !rowsReducer) throw new Error(`defineAnalyzer(${id}): buildRows requires reduce or reduceRows`);
+	const wrap = (fn) => (rows, params, ctx) => {
+		return fn(Array.isArray(rows) ? rows : pickSingle(rows) ?? rows, params, ctx);
+	};
+	return {
+		id,
+		sql: buildSql && sqlReducer ? {
+			id,
+			requires: sqlRequires,
+			build(params) {
+				const spec = buildSql(params);
+				return {
+					kind: "sql",
+					sql: spec.sql,
+					params: spec.params,
+					current: spec.current,
+					previous: spec.previous,
+					extraFiles: spec.extraFiles,
+					extraQueries: spec.extraQueries,
+					requiresAttachedTables: spec.requiresAttachedTables
+				};
+			},
+			reduce(rows, ctx) {
+				const { results, meta } = wrap(sqlReducer)(rows, ctx.params, { extras: ctx.extras });
+				return {
+					results,
+					meta
+				};
+			}
+		} : void 0,
+		rows: buildRows && rowsReducer ? {
+			id,
+			requires: rowsRequires,
+			build(params) {
+				const queries = buildRows(params);
+				return {
+					kind: "rows",
+					queries: Object.fromEntries(Object.entries(queries).map(([k, state]) => [k, { state }]))
+				};
+			},
+			reduce(rows, ctx) {
+				const { results, meta } = wrap(rowsReducer)(rows, ctx.params, {});
+				return {
+					results,
+					meta
+				};
+			}
+		} : void 0
+	};
+}
+function pickSingle(rows) {
+	const keys = Object.keys(rows);
+	return keys.length === 1 ? rows[keys[0]] : void 0;
+}
+function defaultEndDate() {
+	return daysAgo(3);
+}
+function defaultStartDate() {
+	return daysAgo(31);
+}
+function periodOf(params) {
+	return {
+		startDate: params.startDate || defaultStartDate(),
+		endDate: params.endDate || defaultEndDate()
+	};
+}
+function comparisonOf(params) {
+	if (!params.prevStartDate || !params.prevEndDate) throw new Error(`${params.type} analysis requires prevStartDate and prevEndDate`);
+	return {
+		current: periodOf(params),
+		previous: {
+			startDate: params.prevStartDate,
+			endDate: params.prevEndDate
+		}
+	};
+}
+function num(v) {
+	if (typeof v === "number") return v;
+	if (typeof v === "bigint") return Number(v);
+	if (v == null) return 0;
+	return Number(v);
+}
+function buildPeriodMap(rows, key, value, filter) {
+	const out = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		if (filter && !filter(row)) continue;
+		out.set(key(row), value(row));
+	}
+	return out;
+}
+function createSorter(getValue, defaultMetric, defaultOrder = "desc") {
+	return (items, sortBy = defaultMetric, sortOrder = defaultOrder) => {
+		const mult = sortOrder === "desc" ? -1 : 1;
+		return [...items].sort((a, b) => (getValue(a, sortBy) - getValue(b, sortBy)) * mult);
+	};
+}
+function createMetricSorter(defaultMetric, orderByMetric) {
+	return (items, sortBy = defaultMetric) => {
+		const mult = orderByMetric[sortBy] === "desc" ? -1 : 1;
+		return [...items].sort((a, b) => (a[sortBy] - b[sortBy]) * mult);
+	};
+}
+function escapeRegexAlt(s) {
+	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function str$6(v) {
+	return v == null ? "" : String(v);
+}
+function analyzeBrandSegmentation(keywords, options) {
+	const { brandTerms, minImpressions = 10 } = options;
+	const lowerBrandTerms = brandTerms.map((t) => t.toLowerCase());
+	const brand = [];
+	const nonBrand = [];
+	for (const row of keywords) {
+		if (num(row.impressions) < minImpressions) continue;
+		if (lowerBrandTerms.some((term) => row.query.toLowerCase().includes(term))) brand.push(row);
+		else nonBrand.push(row);
+	}
+	const brandClicks = brand.reduce((sum, k) => sum + num(k.clicks), 0);
+	const nonBrandClicks = nonBrand.reduce((sum, k) => sum + num(k.clicks), 0);
+	const totalClicks = brandClicks + nonBrandClicks;
+	return {
+		brand,
+		nonBrand,
+		summary: {
+			brandClicks,
+			nonBrandClicks,
+			brandShare: totalClicks > 0 ? brandClicks / totalClicks : 0,
+			brandImpressions: brand.reduce((sum, k) => sum + num(k.impressions), 0),
+			nonBrandImpressions: nonBrand.reduce((sum, k) => sum + num(k.impressions), 0)
+		}
+	};
+}
+const brandAnalyzer = defineAnalyzer({
+	id: "brand",
+	buildSql(params) {
+		if (!params.brandTerms?.length) throw new Error("Brand analysis requires brandTerms");
+		const { startDate, endDate } = periodOf(params);
+		const minImpressions = params.minImpressions ?? 10;
+		const limit = params.limit ?? 1e4;
+		const regex = `(${params.brandTerms.map((t) => escapeRegexAlt(t.toLowerCase())).join("|")})`;
+		return {
+			sql: `
+    WITH agg AS (
+      SELECT
+        query,
+        url AS page,
+        ${METRIC_EXPR.clicks} AS clicks,
+        ${METRIC_EXPR.impressions} AS impressions,
+        ${METRIC_EXPR.ctr} AS ctr,
+        ${METRIC_EXPR.position} AS position
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ?
+      GROUP BY query, url
+      HAVING SUM(impressions) >= ?
+    )
+    SELECT
+      query, page, clicks, impressions, ctr, position,
+      CASE WHEN regexp_matches(LOWER(query), ?) THEN 'brand' ELSE 'non-brand' END AS segment
+    FROM agg
+    ORDER BY clicks DESC
+    LIMIT ${Number(limit)}
+  `,
+			params: [
+				startDate,
+				endDate,
+				minImpressions,
+				regex
+			],
+			current: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows) {
+		const normalized = (Array.isArray(rows) ? rows : []).map((r) => ({
+			query: str$6(r.query),
+			page: r.page == null ? void 0 : str$6(r.page),
+			clicks: num(r.clicks),
+			impressions: num(r.impressions),
+			ctr: num(r.ctr),
+			position: num(r.position),
+			segment: str$6(r.segment)
+		}));
+		let brandClicks = 0;
+		let nonBrandClicks = 0;
+		let brandImpressions = 0;
+		let nonBrandImpressions = 0;
+		for (const r of normalized) if (r.segment === "brand") {
+			brandClicks += r.clicks;
+			brandImpressions += r.impressions;
+		} else {
+			nonBrandClicks += r.clicks;
+			nonBrandImpressions += r.impressions;
+		}
+		const totalClicks = brandClicks + nonBrandClicks;
+		return {
+			results: normalized,
+			meta: {
+				total: normalized.length,
+				summary: {
+					brandClicks,
+					nonBrandClicks,
+					brandShare: totalClicks > 0 ? brandClicks / totalClicks : 0,
+					brandImpressions,
+					nonBrandImpressions
+				}
+			}
+		};
+	},
+	buildRows(params) {
+		return { keywords: keywordsQueryState(periodOf(params), params.limit) };
+	},
+	reduceRows(rows, params) {
+		if (!params.brandTerms?.length) throw new Error("Brand analysis requires brandTerms");
+		const result = analyzeBrandSegmentation(Array.isArray(rows) ? rows : [], {
+			brandTerms: params.brandTerms,
+			minImpressions: params.minImpressions
+		});
+		return {
+			results: [...result.brand.map((r) => ({
+				...r,
+				segment: "brand"
+			})), ...result.nonBrand.map((r) => ({
+				...r,
+				segment: "non-brand"
+			}))],
+			meta: { summary: result.summary }
+		};
+	}
+});
+const sortRowResults$1 = createSorter((item, metric) => {
+	switch (metric) {
+		case "clicks": return item.totalClicks;
+		case "impressions": return item.totalImpressions;
+		case "positionSpread": return item.positionSpread;
+		case "pageCount": return item.pages.length;
+	}
+}, "clicks");
+function str$5(v) {
+	return v == null ? "" : String(v);
+}
+function parseJsonList$4(v) {
+	if (Array.isArray(v)) return v;
+	if (typeof v === "string" && v.length > 0) {
+		const parsed = JSON.parse(v);
+		return Array.isArray(parsed) ? parsed : [];
+	}
+	return [];
+}
+function analyzeCannibalization(rows, options = {}) {
+	const { minImpressions = 10, maxPositionSpread = 10, minPages = 2, sortBy = "clicks", sortOrder = "desc" } = options;
+	const queryMap = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		if (row.impressions < minImpressions) continue;
+		const pages = queryMap.get(row.query) || [];
+		pages.push({
+			page: row.page,
+			clicks: row.clicks,
+			impressions: row.impressions,
+			ctr: row.ctr,
+			position: row.position
+		});
+		queryMap.set(row.query, pages);
+	}
+	const results = [];
+	for (const [query, pages] of queryMap) {
+		if (pages.length < minPages) continue;
+		pages.sort((a, b) => b.clicks - a.clicks);
+		const positions = pages.map((p) => p.position);
+		const positionSpread = Math.max(...positions) - Math.min(...positions);
+		if (positionSpread > maxPositionSpread) continue;
+		results.push({
+			query,
+			pages,
+			totalClicks: pages.reduce((sum, p) => sum + p.clicks, 0),
+			totalImpressions: pages.reduce((sum, p) => sum + p.impressions, 0),
+			positionSpread
+		});
+	}
+	return sortRowResults$1(results, sortBy, sortOrder);
+}
+const cannibalizationAnalyzer = defineAnalyzer({
+	id: "cannibalization",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf(params);
+		const minImpressions = params.minImpressions ?? 50;
+		const minCompetitors = 2;
+		const minQueryImpressions = (params.minImpressions ?? 50) * 2;
+		const limit = params.limit ?? 200;
+		return {
+			sql: `
+      WITH agg AS (
+        SELECT
+          query,
+          url,
+          ${METRIC_EXPR.clicks} AS clicks,
+          ${METRIC_EXPR.impressions} AS impressions,
+          ${METRIC_EXPR.ctr} AS ctr,
+          ${METRIC_EXPR.position} AS position
+        FROM read_parquet({{FILES}}, union_by_name = true)
+        WHERE date >= ? AND date <= ?
+          AND query IS NOT NULL AND query <> ''
+          AND url IS NOT NULL AND url <> ''
+        GROUP BY query, url
+        HAVING SUM(impressions) >= ?
+      ),
+      query_totals AS (
+        SELECT
+          query,
+          SUM(impressions) AS total_impressions,
+          SUM(clicks) AS total_clicks,
+          COUNT(*) AS competitor_count
+        FROM agg
+        GROUP BY query
+        HAVING COUNT(*) >= ? AND SUM(impressions) >= ?
+      ),
+      ranked AS (
+        SELECT
+          a.query,
+          a.url,
+          a.clicks,
+          a.impressions,
+          a.ctr,
+          a.position,
+          a.impressions / NULLIF(t.total_impressions, 0) AS share,
+          ROW_NUMBER() OVER (
+            PARTITION BY a.query
+            ORDER BY a.impressions DESC, a.clicks DESC, a.url ASC
+          ) AS rnk
+        FROM agg a
+        JOIN query_totals t USING (query)
+      ),
+      leader AS (
+        SELECT query, url AS leader_url, ctr AS leader_ctr, position AS leader_position
+        FROM ranked WHERE rnk = 1
+      ),
+      events AS (
+        SELECT
+          r.query,
+          any_value(l.leader_url) AS leader_url,
+          any_value(l.leader_ctr) AS leader_ctr,
+          any_value(l.leader_position) AS leader_position,
+          SUM(POWER(r.share * 100.0, 2)) AS hhi,
+          SUM(CASE
+            WHEN r.rnk > 1 AND l.leader_ctr > r.ctr
+              THEN (l.leader_ctr - r.ctr) * r.impressions
+            ELSE 0.0
+          END) AS stolen_clicks,
+          to_json(list({
+            'url': r.url,
+            'clicks': r.clicks,
+            'impressions': r.impressions,
+            'ctr': r.ctr,
+            'position': r.position,
+            'share': r.share,
+            'rank': r.rnk
+          } ORDER BY r.rnk)) AS competitors
+        FROM ranked r
+        JOIN leader l USING (query)
+        GROUP BY r.query
+      )
+      SELECT
+        e.query AS keyword,
+        t.total_impressions AS totalImpressions,
+        t.total_clicks AS totalClicks,
+        t.competitor_count AS competitorCount,
+        e.leader_url AS leaderUrl,
+        e.leader_ctr AS leaderCtr,
+        e.leader_position AS leaderPosition,
+        e.hhi AS hhi,
+        GREATEST(0.0, 1.0 - e.hhi / 10000.0) AS fragmentation,
+        e.stolen_clicks AS stolenClicks,
+        e.competitors AS competitors,
+        CAST(ROUND(LEAST(100.0,
+          100.0 * POWER(
+            GREATEST(1.0 - e.hhi / 10000.0, 0.0)
+              * LEAST(e.stolen_clicks / GREATEST(t.total_clicks + e.stolen_clicks, 1.0), 1.0)
+              * LEAST(LOG10(GREATEST(t.total_impressions, 10.0)) / 5.0, 1.0),
+            1.0 / 3.0
+          )
+        )) AS DOUBLE) AS severity
+      FROM events e
+      JOIN query_totals t USING (query)
+      ORDER BY severity DESC, stolenClicks DESC
+      LIMIT ${Number(limit)}
+    `,
+			params: [
+				startDate,
+				endDate,
+				minImpressions,
+				minCompetitors,
+				minQueryImpressions
+			],
+			current: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows) {
+		const events = (Array.isArray(rows) ? rows : []).map((r) => ({
+			keyword: str$5(r.keyword),
+			totalImpressions: num(r.totalImpressions),
+			totalClicks: num(r.totalClicks),
+			competitorCount: num(r.competitorCount),
+			leaderUrl: str$5(r.leaderUrl),
+			leaderCtr: num(r.leaderCtr),
+			leaderPosition: num(r.leaderPosition),
+			hhi: num(r.hhi),
+			fragmentation: num(r.fragmentation),
+			stolenClicks: num(r.stolenClicks),
+			severity: num(r.severity),
+			competitors: parseJsonList$4(r.competitors).map((c) => ({
+				url: str$5(c.url),
+				clicks: num(c.clicks),
+				impressions: num(c.impressions),
+				ctr: num(c.ctr),
+				position: num(c.position),
+				share: num(c.share),
+				rank: num(c.rank)
+			}))
+		}));
+		const nodeAgg = /* @__PURE__ */ new Map();
+		const edgeAgg = /* @__PURE__ */ new Map();
+		for (const ev of events) {
+			for (const c of ev.competitors) {
+				const n = nodeAgg.get(c.url) ?? {
+					impressions: 0,
+					clicks: 0,
+					queries: /* @__PURE__ */ new Set()
+				};
+				n.impressions += c.impressions;
+				n.clicks += c.clicks;
+				n.queries.add(ev.keyword);
+				nodeAgg.set(c.url, n);
+			}
+			for (let i = 0; i < ev.competitors.length; i++) for (let j = i + 1; j < ev.competitors.length; j++) {
+				const a = ev.competitors[i];
+				const b = ev.competitors[j];
+				const [src, tgt] = a.url < b.url ? [a.url, b.url] : [b.url, a.url];
+				const key = `${src}
${tgt}`;
+				const weight = Math.min(a.impressions, b.impressions);
+				const edge = edgeAgg.get(key) ?? {
+					source: src,
+					target: tgt,
+					weight: 0,
+					queries: 0
+				};
+				edge.weight += weight;
+				edge.queries += 1;
+				edgeAgg.set(key, edge);
+			}
+		}
+		const nodes = [...nodeAgg.entries()].map(([url, n]) => ({
+			url,
+			impressions: n.impressions,
+			clicks: n.clicks,
+			queryCount: n.queries.size
+		}));
+		const edges = [...edgeAgg.values()];
+		const avgFragmentation = events.length > 0 ? events.reduce((s, e) => s + e.fragmentation, 0) / events.length : 0;
+		const totalStolenClicks = events.reduce((s, e) => s + e.stolenClicks, 0);
+		return {
+			results: events,
+			meta: {
+				total: events.length,
+				totalStolenClicks,
+				avgFragmentation,
+				graph: {
+					nodes,
+					edges
+				}
+			}
+		};
+	},
+	buildRows(params) {
+		return { rows: keywordsQueryState(periodOf(params), params.limit) };
+	},
+	reduceRows(rows, params) {
+		const results = analyzeCannibalization(Array.isArray(rows) ? rows : [], {
+			minImpressions: params.minImpressions,
+			maxPositionSpread: params.maxPositionSpread,
+			minPages: params.minPages
+		});
+		return {
+			results,
+			meta: { total: results.length }
+		};
+	}
+});
+const INTENT_PREFIXES_REGEX = "^(how to|what is|what are|why is|why do|where to|when to|best|top|vs|versus|compare|review|buy|cheap|free|near me)(\\s|$)";
+const INTENT_PREFIXES = [
+	"how to",
+	"what is",
+	"what are",
+	"why is",
+	"why do",
+	"where to",
+	"when to",
+	"best",
+	"top",
+	"vs",
+	"versus",
+	"compare",
+	"review",
+	"buy",
+	"cheap",
+	"free",
+	"near me"
+];
+const WHITESPACE_RE = /\s+/;
+function str$4(v) {
+	return v == null ? "" : String(v);
+}
+function parseJsonList$3(v) {
+	if (Array.isArray(v)) return v;
+	if (typeof v === "string" && v.length > 0) {
+		const parsed = JSON.parse(v);
+		return Array.isArray(parsed) ? parsed : [];
+	}
+	return [];
+}
+function extractIntentPrefix(keyword) {
+	const lower = keyword.toLowerCase();
+	for (const prefix of INTENT_PREFIXES) if (lower.startsWith(`${prefix} `) || lower.startsWith(prefix)) return prefix;
+	return null;
+}
+function extractWordPrefix(keyword, wordCount = 2) {
+	const words = keyword.toLowerCase().split(WHITESPACE_RE).filter(Boolean);
+	if (words.length < wordCount + 1) return null;
+	return words.slice(0, wordCount).join(" ");
+}
+function analyzeClustering(keywords, options = {}) {
+	const { minClusterSize = 2, minImpressions = 10, clusterBy = "both" } = options;
+	const filtered = keywords.filter((k) => num(k.impressions) >= minImpressions);
+	const clusterMap = /* @__PURE__ */ new Map();
+	const clusteredKeywords = /* @__PURE__ */ new Set();
+	if (clusterBy === "intent" || clusterBy === "both") for (const kw of filtered) {
+		const intent = extractIntentPrefix(kw.query);
+		if (intent) {
+			const existing = clusterMap.get(intent);
+			if (existing) existing.keywords.push(kw);
+			else clusterMap.set(intent, {
+				type: "intent",
+				keywords: [kw]
+			});
+			clusteredKeywords.add(kw.query);
+		}
+	}
+	if (clusterBy === "prefix" || clusterBy === "both") {
+		const unclustered = filtered.filter((kw) => !clusteredKeywords.has(kw.query));
+		const prefixMap = /* @__PURE__ */ new Map();
+		for (const kw of unclustered) {
+			const prefix = extractWordPrefix(kw.query);
+			if (prefix) {
+				const existing = prefixMap.get(prefix);
+				if (existing) existing.push(kw);
+				else prefixMap.set(prefix, [kw]);
+			}
+		}
+		for (const [prefix, kws] of prefixMap) if (kws.length >= minClusterSize) {
+			clusterMap.set(prefix, {
+				type: "prefix",
+				keywords: kws
+			});
+			kws.forEach((kw) => clusteredKeywords.add(kw.query));
+		}
+	}
+	const clusters = [];
+	for (const [name, data] of clusterMap) {
+		if (data.keywords.length < minClusterSize) continue;
+		const totalClicks = data.keywords.reduce((sum, k) => sum + num(k.clicks), 0);
+		const totalImpressions = data.keywords.reduce((sum, k) => sum + num(k.impressions), 0);
+		const avgPosition = data.keywords.reduce((sum, k) => sum + num(k.position), 0) / data.keywords.length;
+		clusters.push({
+			clusterName: name,
+			clusterType: data.type,
+			keywords: data.keywords,
+			totalClicks,
+			totalImpressions,
+			avgPosition,
+			keywordCount: data.keywords.length
+		});
+	}
+	clusters.sort((a, b) => b.totalClicks - a.totalClicks);
+	return {
+		clusters,
+		unclustered: filtered.filter((kw) => !clusteredKeywords.has(kw.query))
+	};
+}
+const clusteringAnalyzer = defineAnalyzer({
+	id: "clustering",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf(params);
+		const minImpressions = params.minImpressions ?? 10;
+		const minClusterSize = params.minClusterSize ?? 2;
+		const clusterBy = params.clusterBy ?? "both";
+		const doIntent = clusterBy === "intent" || clusterBy === "both";
+		const doPrefix = clusterBy === "prefix" || clusterBy === "both";
+		const intentExpr = doIntent ? `NULLIF(regexp_extract(LOWER(query), '${INTENT_PREFIXES_REGEX}', 1), '')` : `CAST(NULL AS VARCHAR)`;
+		const prefixExpr = doPrefix ? `CASE WHEN len(regexp_split_to_array(LOWER(query), '\\s+')) >= 3
+          THEN array_to_string(list_slice(regexp_split_to_array(LOWER(query), '\\s+'), 1, 2), ' ')
+          ELSE CAST(NULL AS VARCHAR) END` : `CAST(NULL AS VARCHAR)`;
+		return {
+			sql: `
+      WITH agg AS (
+        SELECT
+          query,
+          ${METRIC_EXPR.clicks} AS clicks,
+          ${METRIC_EXPR.impressions} AS impressions,
+          ${METRIC_EXPR.ctr} AS ctr,
+          ${METRIC_EXPR.position} AS position
+        FROM read_parquet({{FILES}}, union_by_name = true)
+        WHERE date >= ? AND date <= ?
+        GROUP BY query
+        HAVING SUM(impressions) >= ?
+      ),
+      classified AS (
+        SELECT
+          query, clicks, impressions, ctr, position,
+          ${intentExpr} AS intent_prefix,
+          ${prefixExpr} AS word_prefix
+        FROM agg
+      ),
+      keyed AS (
+        SELECT
+          query, clicks, impressions, ctr, position,
+          COALESCE(intent_prefix, word_prefix) AS cluster_name,
+          CASE WHEN intent_prefix IS NOT NULL THEN 'intent' ELSE 'prefix' END AS cluster_type
+        FROM classified
+        WHERE COALESCE(intent_prefix, word_prefix) IS NOT NULL
+      )
+      SELECT
+        cluster_name AS clusterName,
+        any_value(cluster_type) AS clusterType,
+        CAST(COUNT(*) AS DOUBLE) AS keywordCount,
+        ${METRIC_EXPR.clicks} AS totalClicks,
+        ${METRIC_EXPR.impressions} AS totalImpressions,
+        AVG(position) AS avgPosition,
+        to_json(list({ 'query': query, 'clicks': clicks, 'impressions': impressions, 'ctr': ctr, 'position': position })) AS keywords
+      FROM keyed
+      GROUP BY cluster_name
+      HAVING COUNT(*) >= ?
+      ORDER BY totalClicks DESC
+    `,
+			params: [
+				startDate,
+				endDate,
+				minImpressions,
+				minClusterSize
+			],
+			current: {
+				table: "keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows) {
+		const clusters = (Array.isArray(rows) ? rows : []).map((r) => ({
+			clusterName: str$4(r.clusterName),
+			clusterType: str$4(r.clusterType),
+			keywordCount: num(r.keywordCount),
+			totalClicks: num(r.totalClicks),
+			totalImpressions: num(r.totalImpressions),
+			avgPosition: num(r.avgPosition),
+			keywords: parseJsonList$3(r.keywords).map((k) => ({
+				query: str$4(k.query),
+				clicks: num(k.clicks),
+				impressions: num(k.impressions),
+				ctr: num(k.ctr),
+				position: num(k.position)
+			}))
+		}));
+		return {
+			results: clusters,
+			meta: {
+				total: clusters.length,
+				totalClusters: clusters.length
+			}
+		};
+	},
+	buildRows(params) {
+		return { keywords: keywordsQueryState(periodOf(params), params.limit) };
+	},
+	reduceRows(rows, params) {
+		const result = analyzeClustering(Array.isArray(rows) ? rows : [], {
+			clusterBy: params.clusterBy,
+			minClusterSize: params.minClusterSize,
+			minImpressions: params.minImpressions
+		});
+		return {
+			results: result.clusters,
+			meta: { totalClusters: result.clusters.length }
+		};
+	}
+});
+function str$3(v) {
+	return v == null ? "" : String(v);
+}
+function parseJsonList$2(v) {
+	if (Array.isArray(v)) return v;
+	if (typeof v === "string" && v.length > 0) {
+		const parsed = JSON.parse(v);
+		return Array.isArray(parsed) ? parsed : [];
+	}
+	return [];
+}
+function calculateGini(values) {
+	if (values.length === 0) return 0;
+	const sorted = [...values].sort((a, b) => a - b);
+	const n = sorted.length;
+	const sum = sorted.reduce((a, b) => a + b, 0);
+	if (sum === 0) return 0;
+	let weightedSum = 0;
+	for (let i = 0; i < n; i++) weightedSum += (2 * (i + 1) - n - 1) * sorted[i];
+	return weightedSum / (n * sum);
+}
+function calculateHHI(shares) {
+	return shares.reduce((sum, share) => sum + (share * 100) ** 2, 0);
+}
+function analyzeConcentration(items, options = {}) {
+	const { topN = 10 } = options;
+	if (items.length === 0) return {
+		giniCoefficient: 0,
+		hhi: 0,
+		topNConcentration: 0,
+		topNItems: [],
+		totalItems: 0,
+		totalClicks: 0,
+		riskLevel: "low"
+	};
+	const sorted = [...items].sort((a, b) => b.clicks - a.clicks);
+	const totalClicks = sorted.reduce((sum, item) => sum + item.clicks, 0);
+	const clickValues = sorted.map((i) => i.clicks);
+	const shares = totalClicks > 0 ? sorted.map((i) => i.clicks / totalClicks) : [];
+	const giniCoefficient = calculateGini(clickValues);
+	const hhi = calculateHHI(shares);
+	const topNItems = sorted.slice(0, topN).map((item) => ({
+		key: item.key,
+		clicks: item.clicks,
+		share: totalClicks > 0 ? item.clicks / totalClicks : 0
+	}));
+	const topNClicks = topNItems.reduce((sum, item) => sum + item.clicks, 0);
+	const topNConcentration = totalClicks > 0 ? topNClicks / totalClicks : 0;
+	let riskLevel = "low";
+	if (hhi > 2500) riskLevel = "high";
+	else if (hhi > 1500) riskLevel = "medium";
+	return {
+		giniCoefficient,
+		hhi,
+		topNConcentration,
+		topNItems,
+		totalItems: items.length,
+		totalClicks,
+		riskLevel
+	};
+}
+function analyzePageConcentration(pages, options) {
+	return analyzeConcentration(pages.map((p) => ({
+		key: p.page,
+		clicks: num(p.clicks)
+	})), options);
+}
+function analyzeKeywordConcentration(keywords, options) {
+	return analyzeConcentration(keywords.map((k) => ({
+		key: k.query,
+		clicks: num(k.clicks)
+	})), options);
+}
+const concentrationAnalyzer = defineAnalyzer({
+	id: "concentration",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf(params);
+		const dim = params.dimension || "pages";
+		const topN = params.topN ?? 10;
+		const table = dim === "keywords" ? "keywords" : "pages";
+		const keyCol = dim === "keywords" ? "query" : "url";
+		return {
+			sql: `
+    WITH items AS (
+      SELECT
+        ${keyCol} AS key,
+        ${METRIC_EXPR.clicks} AS clicks
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ?
+      GROUP BY ${keyCol}
+      HAVING SUM(clicks) > 0
+    ),
+    totals AS (
+      SELECT SUM(clicks) AS total_clicks, COUNT(*) AS total_items FROM items
+    ),
+    ranked AS (
+      SELECT
+        i.key, i.clicks,
+        i.clicks / NULLIF(t.total_clicks, 0) AS share,
+        ROW_NUMBER() OVER (ORDER BY i.clicks DESC, i.key ASC) AS rnk_desc,
+        ROW_NUMBER() OVER (ORDER BY i.clicks ASC, i.key ASC) AS rnk_asc,
+        t.total_clicks AS tclicks,
+        t.total_items AS titems
+      FROM items i, totals t
+    ),
+    gini_num AS (
+      SELECT SUM((2.0 * rnk_asc - titems - 1) * clicks) AS weighted_sum FROM ranked
+    ),
+    hhi_calc AS (
+      SELECT SUM(POWER(share * 100, 2)) AS hhi FROM ranked
+    ),
+    top_list AS (
+      SELECT
+        list({ 'key': key, 'clicks': clicks, 'share': share } ORDER BY clicks DESC, key ASC) AS items,
+        SUM(clicks) AS top_clicks
+      FROM ranked WHERE rnk_desc <= ?
+    )
+    SELECT
+      COALESCE(
+        (SELECT weighted_sum FROM gini_num)
+          / NULLIF((SELECT total_items FROM totals) * (SELECT total_clicks FROM totals), 0),
+        0.0
+      ) AS giniCoefficient,
+      COALESCE((SELECT hhi FROM hhi_calc), 0.0) AS hhi,
+      COALESCE(
+        CAST((SELECT top_clicks FROM top_list) AS DOUBLE)
+          / NULLIF((SELECT total_clicks FROM totals), 0),
+        0.0
+      ) AS topNConcentration,
+      COALESCE((SELECT to_json(items) FROM top_list), '[]') AS topNItems,
+      COALESCE((SELECT total_items FROM totals), 0) AS totalItems,
+      COALESCE((SELECT total_clicks FROM totals), 0.0) AS totalClicks,
+      CASE
+        WHEN COALESCE((SELECT hhi FROM hhi_calc), 0.0) > 2500 THEN 'high'
+        WHEN COALESCE((SELECT hhi FROM hhi_calc), 0.0) > 1500 THEN 'medium'
+        ELSE 'low'
+      END AS riskLevel
+  `,
+			params: [
+				startDate,
+				endDate,
+				topN
+			],
+			current: {
+				table,
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const r = (Array.isArray(rows) ? rows : [])[0] ?? {};
+		const topRaw = parseJsonList$2(r.topNItems);
+		return {
+			results: [{
+				giniCoefficient: num(r.giniCoefficient),
+				hhi: num(r.hhi),
+				topNConcentration: num(r.topNConcentration),
+				topNItems: topRaw.map((t) => ({
+					key: str$3(t.key),
+					clicks: num(t.clicks),
+					share: num(t.share)
+				})),
+				totalItems: num(r.totalItems),
+				totalClicks: num(r.totalClicks),
+				riskLevel: str$3(r.riskLevel)
+			}],
+			meta: {
+				total: 1,
+				dimension: params.dimension || "pages"
+			}
+		};
+	},
+	buildRows(params) {
+		const dim = params.dimension || "pages";
+		const period = periodOf(params);
+		const out = {};
+		if (dim === "pages") out.pages = pagesQueryState(period, params.limit);
+		else out.keywords = keywordsQueryState(period, params.limit);
+		return out;
+	},
+	reduceRows(rows, params) {
+		const dim = params.dimension || "pages";
+		const arr = Array.isArray(rows) ? rows : rows[dim] ?? [];
+		return {
+			results: [dim === "pages" ? analyzePageConcentration(arr, { topN: params.topN }) : analyzeKeywordConcentration(arr, { topN: params.topN })],
+			meta: { dimension: dim }
+		};
+	}
+});
+const sortResults$1 = createMetricSorter("lostClicks", {
+	lostClicks: "desc",
+	declinePercent: "desc",
+	currentClicks: "asc"
+});
+function str$2(v) {
+	return v == null ? "" : String(v);
+}
+function parseJsonList$1(v) {
+	if (Array.isArray(v)) return v;
+	if (typeof v === "string" && v.length > 0) {
+		const parsed = JSON.parse(v);
+		return Array.isArray(parsed) ? parsed : [];
+	}
+	return [];
+}
+function analyzeDecay(input, options = {}) {
+	const { minPreviousClicks = 50, threshold = .2, sortBy = "lostClicks" } = options;
+	const currentMap = buildPeriodMap(input.current, (r) => r.page, (r) => ({
+		clicks: num(r.clicks),
+		position: num(r.position)
+	}));
+	const previousMap = buildPeriodMap(input.previous, (r) => r.page, (r) => ({
+		clicks: num(r.clicks),
+		position: num(r.position)
+	}), (r) => num(r.clicks) >= minPreviousClicks);
+	const results = [];
+	for (const [page, prev] of previousMap) {
+		const curr = currentMap.get(page) || {
+			clicks: 0,
+			position: 0
+		};
+		const lostClicks = prev.clicks - curr.clicks;
+		const declinePercent = prev.clicks > 0 ? lostClicks / prev.clicks : 0;
+		if (declinePercent >= threshold && lostClicks > 0) results.push({
+			page,
+			currentClicks: curr.clicks,
+			previousClicks: prev.clicks,
+			lostClicks,
+			declinePercent,
+			currentPosition: curr.position,
+			previousPosition: prev.position,
+			positionDrop: curr.position - prev.position
+		});
+	}
+	return sortResults$1(results, sortBy);
+}
+const decayAnalyzer = defineAnalyzer({
+	id: "decay",
+	buildSql(params) {
+		const { current: cur, previous: prev } = comparisonOf(params);
+		const minPreviousClicks = params.minPreviousClicks ?? 50;
+		const threshold = params.threshold ?? .2;
+		const limit = params.limit ?? 2e3;
+		return {
+			sql: `
+      WITH cur AS (
+        SELECT
+          url,
+          ${METRIC_EXPR.clicks} AS clicks,
+          ${METRIC_EXPR.position} AS position
+        FROM read_parquet({{FILES}}, union_by_name = true)
+        WHERE date >= ? AND date <= ?
+        GROUP BY url
+      ),
+      prev AS (
+        SELECT
+          url,
+          ${METRIC_EXPR.clicks} AS clicks,
+          ${METRIC_EXPR.position} AS position
+        FROM read_parquet({{FILES_PREV}}, union_by_name = true)
+        WHERE date >= ? AND date <= ?
+        GROUP BY url
+        HAVING SUM(clicks) >= ?
+      ),
+      weekly AS (
+        SELECT url, date_trunc('week', CAST(date AS DATE)) AS week,
+          ${METRIC_EXPR.clicks} AS clicks,
+          ${METRIC_EXPR.impressions} AS impressions
+        FROM (
+          SELECT url, date, clicks, impressions
+          FROM read_parquet({{FILES}}, union_by_name = true)
+          WHERE date >= ? AND date <= ?
+          UNION ALL
+          SELECT url, date, clicks, impressions
+          FROM read_parquet({{FILES_PREV}}, union_by_name = true)
+          WHERE date >= ? AND date <= ?
+        )
+        GROUP BY url, week
+      ),
+      series_by_url AS (
+        SELECT url, to_json(list({
+          'week': strftime(week, '%Y-%m-%d'),
+          'clicks': clicks,
+          'impressions': impressions
+        } ORDER BY week)) AS seriesJson
+        FROM weekly GROUP BY url
+      ),
+      joined AS (
+        SELECT
+          p.url AS page,
+          COALESCE(c.clicks, 0.0) AS currentClicks,
+          p.clicks AS previousClicks,
+          (p.clicks - COALESCE(c.clicks, 0.0)) AS lostClicks,
+          (p.clicks - COALESCE(c.clicks, 0.0)) / NULLIF(p.clicks, 0) AS declinePercent,
+          COALESCE(c.position, 0.0) AS currentPosition,
+          p.position AS previousPosition,
+          (COALESCE(c.position, 0.0) - p.position) AS positionDrop,
+          s.seriesJson
+        FROM prev p
+        LEFT JOIN cur c ON p.url = c.url
+        LEFT JOIN series_by_url s ON p.url = s.url
+      )
+      SELECT *
+      FROM joined
+      WHERE declinePercent >= ? AND lostClicks > 0
+      ORDER BY lostClicks DESC
+      LIMIT ${Number(limit)}
+    `,
+			params: [
+				cur.startDate,
+				cur.endDate,
+				prev.startDate,
+				prev.endDate,
+				minPreviousClicks,
+				cur.startDate,
+				cur.endDate,
+				prev.startDate,
+				prev.endDate,
+				threshold
+			],
+			current: {
+				table: "pages",
+				partitions: enumeratePartitions(cur.startDate, cur.endDate)
+			},
+			previous: {
+				table: "pages",
+				partitions: enumeratePartitions(prev.startDate, prev.endDate)
+			}
+		};
+	},
+	reduceSql(rows) {
+		const arr = Array.isArray(rows) ? rows : [];
+		return {
+			results: arr.map((r) => ({
+				page: str$2(r.page),
+				currentClicks: num(r.currentClicks),
+				previousClicks: num(r.previousClicks),
+				lostClicks: num(r.lostClicks),
+				declinePercent: num(r.declinePercent),
+				currentPosition: num(r.currentPosition),
+				previousPosition: num(r.previousPosition),
+				positionDrop: num(r.positionDrop),
+				series: parseJsonList$1(r.seriesJson).map((s) => ({
+					week: str$2(s.week),
+					clicks: num(s.clicks),
+					impressions: num(s.impressions)
+				}))
+			})),
+			meta: { total: arr.length }
+		};
+	},
+	buildRows(params) {
+		const { current, previous } = comparisonOf(params);
+		return {
+			current: pagesQueryState(current, params.limit),
+			previous: pagesQueryState(previous, params.limit)
+		};
+	},
+	reduceRows(rows, params) {
+		const map = rows && !Array.isArray(rows) ? rows : {
+			current: [],
+			previous: []
+		};
+		const results = analyzeDecay({
+			current: map.current ?? [],
+			previous: map.previous ?? []
+		}, {
+			minPreviousClicks: params.minPreviousClicks,
+			threshold: params.threshold
+		});
+		return {
+			results,
+			meta: { total: results.length }
+		};
+	}
+});
+function percentDifference(current, previous) {
+	if (previous === 0) return current > 0 ? 100 : 0;
+	return (current - previous) / previous * 100;
+}
+function str$1(v) {
+	return v == null ? "" : String(v);
+}
+function parseJsonList(v) {
+	if (Array.isArray(v)) return v;
+	if (typeof v === "string" && v.length > 0) {
+		const parsed = JSON.parse(v);
+		return Array.isArray(parsed) ? parsed : [];
+	}
+	return [];
+}
+function analyzeMovers(input, options = {}) {
+	const { changeThreshold = .2, minImpressions = 50, sortBy = "clicksChange" } = options;
+	const normFactor = input.normalizationFactor ?? 1;
+	const baselineMap = buildPeriodMap(input.previous, (r) => r.query, (r) => ({
+		clicks: num(r.clicks) / normFactor,
+		impressions: num(r.impressions) / normFactor,
+		position: num(r.position),
+		page: r.page ?? null
+	}));
+	const pageMap = /* @__PURE__ */ new Map();
+	for (const row of input.current) if (!pageMap.has(row.query) && row.page) pageMap.set(row.query, row.page);
+	for (const row of input.previous) if (!pageMap.has(row.query) && row.page) pageMap.set(row.query, row.page);
+	const rising = [];
+	const declining = [];
+	const stable = [];
+	for (const row of input.current) {
+		const impressions = num(row.impressions);
+		const clicks = num(row.clicks);
+		const position = num(row.position);
+		if (impressions < minImpressions) continue;
+		const baseline = baselineMap.get(row.query) || {
+			clicks: 0,
+			impressions: 0,
+			position: 0,
+			page: null
+		};
+		const clicksChangePercent = percentDifference(clicks, baseline.clicks);
+		const impressionsChangePercent = percentDifference(impressions, baseline.impressions);
+		const data = {
+			keyword: row.query,
+			page: pageMap.get(row.query) ?? null,
+			recentClicks: clicks,
+			recentImpressions: impressions,
+			recentPosition: position,
+			baselineClicks: Math.round(baseline.clicks),
+			baselineImpressions: Math.round(baseline.impressions),
+			baselinePosition: baseline.position,
+			clicksChange: clicks - Math.round(baseline.clicks),
+			clicksChangePercent,
+			impressionsChangePercent,
+			positionChange: position - baseline.position
+		};
+		const absChange = Math.abs(clicksChangePercent / 100);
+		if (clicksChangePercent > 0 && absChange >= changeThreshold) rising.push(data);
+		else if (clicksChangePercent < 0 && absChange >= changeThreshold) declining.push(data);
+		else stable.push(data);
+	}
+	const sortFn = (a, b) => {
+		switch (sortBy) {
+			case "clicks": return b.recentClicks - a.recentClicks;
+			case "impressions": return b.recentImpressions - a.recentImpressions;
+			case "clicksChange": return Math.abs(b.clicksChangePercent) - Math.abs(a.clicksChangePercent);
+			case "impressionsChange": return Math.abs(b.impressionsChangePercent) - Math.abs(a.impressionsChangePercent);
+			case "positionChange": return Math.abs(b.positionChange) - Math.abs(a.positionChange);
+			default: return Math.abs(b.clicksChangePercent) - Math.abs(a.clicksChangePercent);
+		}
+	};
+	rising.sort(sortFn);
+	declining.sort(sortFn);
+	stable.sort((a, b) => b.recentClicks - a.recentClicks);
+	return {
+		rising,
+		declining,
+		stable
+	};
+}
+const moversAnalyzer = defineAnalyzer({
+	id: "movers",
+	buildSql(params) {
+		const { current: cur, previous: prev } = comparisonOf(params);
+		const minImpressions = params.minImpressions ?? 50;
+		const changeThreshold = params.changeThreshold ?? .2;
+		const limit = params.limit ?? 2e3;
+		return {
+			sql: `
+      WITH cur AS (
+        SELECT
+          query, url,
+          ${METRIC_EXPR.clicks} AS clicks,
+          ${METRIC_EXPR.impressions} AS impressions,
+          ${METRIC_EXPR.position} AS position
+        FROM read_parquet({{FILES}}, union_by_name = true)
+        WHERE date >= ? AND date <= ?
+        GROUP BY query, url
+      ),
+      prev AS (
+        SELECT
+          query, url,
+          ${METRIC_EXPR.clicks} AS clicks,
+          ${METRIC_EXPR.impressions} AS impressions,
+          ${METRIC_EXPR.position} AS position
+        FROM read_parquet({{FILES_PREV}}, union_by_name = true)
+        WHERE date >= ? AND date <= ?
+        GROUP BY query, url
+      ),
+      weekly AS (
+        SELECT query, url, date_trunc('week', CAST(date AS DATE)) AS week,
+          ${METRIC_EXPR.clicks} AS clicks,
+          ${METRIC_EXPR.impressions} AS impressions
+        FROM (
+          SELECT query, url, date, clicks, impressions
+          FROM read_parquet({{FILES}}, union_by_name = true)
+          WHERE date >= ? AND date <= ?
+          UNION ALL
+          SELECT query, url, date, clicks, impressions
+          FROM read_parquet({{FILES_PREV}}, union_by_name = true)
+          WHERE date >= ? AND date <= ?
+        )
+        GROUP BY query, url, week
+      ),
+      series_by_entity AS (
+        SELECT query, url, to_json(list({
+          'week': strftime(week, '%Y-%m-%d'),
+          'clicks': clicks,
+          'impressions': impressions
+        } ORDER BY week)) AS seriesJson
+        FROM weekly GROUP BY query, url
+      ),
+      joined AS (
+        SELECT
+          c.query AS keyword,
+          c.url AS page,
+          c.clicks AS recentClicks,
+          c.impressions AS recentImpressions,
+          c.position AS recentPosition,
+          COALESCE(p.clicks, 0.0) AS baselineClicks,
+          COALESCE(p.impressions, 0.0) AS baselineImpressions,
+          COALESCE(p.position, 0.0) AS baselinePosition,
+          (c.clicks - COALESCE(p.clicks, 0.0)) AS clicksChange,
+          CASE
+            WHEN COALESCE(p.clicks, 0.0) = 0 THEN CASE WHEN c.clicks > 0 THEN 100.0 ELSE 0.0 END
+            ELSE (c.clicks - p.clicks) * 100.0 / p.clicks
+          END AS clicksChangePercent,
+          CASE
+            WHEN COALESCE(p.impressions, 0.0) = 0 THEN CASE WHEN c.impressions > 0 THEN 100.0 ELSE 0.0 END
+            ELSE (c.impressions - p.impressions) * 100.0 / p.impressions
+          END AS impressionsChangePercent,
+          (c.position - COALESCE(p.position, 0.0)) AS positionChange,
+          s.seriesJson
+        FROM cur c
+        LEFT JOIN prev p ON c.query = p.query AND c.url = p.url
+        LEFT JOIN series_by_entity s ON c.query = s.query AND c.url = s.url
+        WHERE c.impressions >= ?
+      )
+      SELECT *,
+        CASE
+          WHEN clicksChangePercent > 0 AND ABS(clicksChangePercent) / 100.0 >= ? THEN 'rising'
+          WHEN clicksChangePercent < 0 AND ABS(clicksChangePercent) / 100.0 >= ? THEN 'declining'
+          ELSE 'stable'
+        END AS direction
+      FROM joined
+      ORDER BY ABS(clicksChangePercent) DESC
+      LIMIT ${Number(limit)}
+    `,
+			params: [
+				cur.startDate,
+				cur.endDate,
+				prev.startDate,
+				prev.endDate,
+				cur.startDate,
+				cur.endDate,
+				prev.startDate,
+				prev.endDate,
+				minImpressions,
+				changeThreshold,
+				changeThreshold
+			],
+			current: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(cur.startDate, cur.endDate)
+			},
+			previous: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(prev.startDate, prev.endDate)
+			}
+		};
+	},
+	reduceSql(rows) {
+		const normalized = (Array.isArray(rows) ? rows : []).map((r) => ({
+			keyword: str$1(r.keyword),
+			page: r.page == null ? null : str$1(r.page),
+			recentClicks: num(r.recentClicks),
+			recentImpressions: num(r.recentImpressions),
+			recentPosition: num(r.recentPosition),
+			baselineClicks: Math.round(num(r.baselineClicks)),
+			baselineImpressions: Math.round(num(r.baselineImpressions)),
+			baselinePosition: num(r.baselinePosition),
+			clicksChange: num(r.clicksChange),
+			clicksChangePercent: num(r.clicksChangePercent),
+			impressionsChangePercent: num(r.impressionsChangePercent),
+			positionChange: num(r.positionChange),
+			direction: str$1(r.direction),
+			series: parseJsonList(r.seriesJson).map((s) => ({
+				week: str$1(s.week),
+				clicks: num(s.clicks),
+				impressions: num(s.impressions)
+			}))
+		}));
+		const rising = normalized.filter((r) => r.direction === "rising");
+		const declining = normalized.filter((r) => r.direction === "declining");
+		const stable = normalized.filter((r) => r.direction === "stable");
+		const combined = [...rising, ...declining];
+		return {
+			results: combined,
+			meta: {
+				total: combined.length,
+				rising: rising.length,
+				declining: declining.length,
+				stable: stable.length
+			}
+		};
+	},
+	buildRows(params) {
+		const { current, previous } = comparisonOf(params);
+		return {
+			current: keywordsQueryState(current, params.limit),
+			previous: keywordsQueryState(previous, params.limit)
+		};
+	},
+	reduceRows(rows, params) {
+		const map = rows && !Array.isArray(rows) ? rows : {
+			current: [],
+			previous: []
+		};
+		const result = analyzeMovers({
+			current: map.current ?? [],
+			previous: map.previous ?? []
+		}, {
+			changeThreshold: params.changeThreshold,
+			minImpressions: params.minImpressions
+		});
+		return {
+			results: [...result.rising.map((r) => ({
+				...r,
+				direction: "rising"
+			})), ...result.declining.map((r) => ({
+				...r,
+				direction: "declining"
+			}))],
+			meta: {
+				rising: result.rising.length,
+				declining: result.declining.length
+			}
+		};
+	}
+});
+const DEFAULT_LIMIT = 1e3;
+const MAX_LIMIT = 5e4;
+function clampLimit(limit, fallback = DEFAULT_LIMIT) {
+	const n = Number(limit ?? fallback);
+	if (!Number.isFinite(n) || n <= 0) return fallback;
+	return Math.min(n, MAX_LIMIT);
+}
+function clampOffset(offset) {
+	const n = Number(offset ?? 0);
+	if (!Number.isFinite(n) || n < 0) return 0;
+	return Math.floor(n);
+}
+function paginateClause(input) {
+	const l = clampLimit(input.limit);
+	const o = clampOffset(input.offset);
+	return o > 0 ? `LIMIT ${l} OFFSET ${o}` : `LIMIT ${l}`;
+}
+function paginateInMemory(rows, input) {
+	const l = clampLimit(input.limit, rows.length);
+	const o = clampOffset(input.offset);
+	return rows.slice(o, o + l);
+}
+const EXPECTED_CTR_BY_POSITION = {
+	1: .3,
+	2: .15,
+	3: .1,
+	4: .07,
+	5: .05,
+	6: .04,
+	7: .03,
+	8: .025,
+	9: .02,
+	10: .015
+};
+function getExpectedCtr(position) {
+	return EXPECTED_CTR_BY_POSITION[Math.round(Math.max(1, Math.min(position, 10)))] || .01;
+}
+function calculatePositionScore(position) {
+	if (position <= 3) return .2;
+	if (position > 50) return .1;
+	const distance = Math.abs(position - 11);
+	return Math.max(0, 1 - distance / 15);
+}
+function calculateImpressionScore(impressions) {
+	if (impressions <= 0) return 0;
+	return Math.min(Math.log10(impressions) / 5, 1);
+}
+function calculateCtrGapScore(actualCtr, position) {
+	const expectedCtr = getExpectedCtr(position);
+	if (actualCtr >= expectedCtr) return 0;
+	const gap = expectedCtr - actualCtr;
+	return Math.min(gap / expectedCtr, 1);
+}
+const sortResults = createMetricSorter("opportunityScore", {
+	opportunityScore: "desc",
+	potentialClicks: "desc",
+	impressions: "desc",
+	position: "asc"
+});
+const opportunityAnalyzer = defineAnalyzer({
+	id: "opportunity",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf(params);
+		const minImpressions = params.minImpressions ?? 100;
+		const w1 = 1;
+		const w2 = 1;
+		const w3 = 1;
+		const totalW = w1 + w2 + w3;
+		const limit = params.limit ?? 1e3;
+		return {
+			sql: `
+    WITH agg AS (
+      SELECT
+        query AS keyword,
+        url AS page,
+        ${METRIC_EXPR.clicks} AS clicks,
+        ${METRIC_EXPR.impressions} AS impressions,
+        ${METRIC_EXPR.ctr} AS ctr,
+        ${METRIC_EXPR.position} AS position
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ?
+      GROUP BY query, url
+      HAVING SUM(impressions) >= ?
+    ),
+    scored AS (
+      SELECT
+        keyword, page, clicks, impressions, ctr, position,
+        CASE
+          WHEN position <= 3 THEN 0.2
+          WHEN position > 50 THEN 0.1
+          ELSE GREATEST(0.0, 1.0 - ABS(position - 11.0) / 15.0)
+        END AS positionScore,
+        CASE WHEN impressions <= 0 THEN 0.0 ELSE LEAST(LOG10(impressions) / 5.0, 1.0) END AS impressionScore,
+        CASE CAST(ROUND(GREATEST(LEAST(position, 10.0), 1.0)) AS INTEGER)
+          WHEN 1 THEN 0.30
+          WHEN 2 THEN 0.15
+          WHEN 3 THEN 0.10
+          WHEN 4 THEN 0.07
+          WHEN 5 THEN 0.05
+          WHEN 6 THEN 0.04
+          WHEN 7 THEN 0.03
+          WHEN 8 THEN 0.025
+          WHEN 9 THEN 0.02
+          WHEN 10 THEN 0.015
+          ELSE 0.01
+        END AS expectedCtr
+      FROM agg
+    ),
+    gapped AS (
+      SELECT
+        *,
+        CASE WHEN ctr >= expectedCtr THEN 0.0 ELSE LEAST((expectedCtr - ctr) / expectedCtr, 1.0) END AS ctrGapScore
+      FROM scored
+    )
+    SELECT
+      keyword, page, clicks, impressions, ctr, position,
+      CAST(ROUND(POWER(
+        POWER(positionScore, ${w1}) * POWER(impressionScore, ${w2}) * POWER(ctrGapScore, ${w3}),
+        1.0 / ${totalW}
+      ) * 100) AS DOUBLE) AS opportunityScore,
+      CAST(ROUND(impressions * (
+        CASE CAST(ROUND(GREATEST(LEAST(position, 3.0), 1.0)) AS INTEGER)
+          WHEN 1 THEN 0.30
+          WHEN 2 THEN 0.15
+          WHEN 3 THEN 0.10
+          ELSE 0.10
+        END
+      )) AS DOUBLE) AS potentialClicks,
+      positionScore, impressionScore, ctrGapScore
+    FROM gapped
+    ORDER BY opportunityScore DESC
+    ${paginateClause({
+				limit,
+				offset: params.offset
+			})}
+  `,
+			params: [
+				startDate,
+				endDate,
+				minImpressions
+			],
+			current: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows) {
+		const arr = Array.isArray(rows) ? rows : [];
+		return {
+			results: arr.map((r) => ({
+				keyword: r.keyword == null ? "" : String(r.keyword),
+				page: r.page == null ? null : String(r.page),
+				clicks: num(r.clicks),
+				impressions: num(r.impressions),
+				ctr: num(r.ctr),
+				position: num(r.position),
+				opportunityScore: num(r.opportunityScore),
+				potentialClicks: num(r.potentialClicks),
+				factors: {
+					positionScore: num(r.positionScore),
+					impressionScore: num(r.impressionScore),
+					ctrGapScore: num(r.ctrGapScore)
+				}
+			})),
+			meta: { total: arr.length }
+		};
+	},
+	buildRows(params) {
+		return { keywords: keywordsQueryState(periodOf(params), params.limit) };
+	},
+	reduceRows(rows, params) {
+		const keywords = (Array.isArray(rows) ? rows : []) ?? [];
+		const minImpressions = params.minImpressions ?? 100;
+		const positionWeight = 1;
+		const impressionsWeight = 1;
+		const ctrGapWeight = 1;
+		const sortBy = "opportunityScore";
+		const results = [];
+		for (const row of keywords) {
+			const impressions = num(row.impressions);
+			const position = num(row.position);
+			const ctr = num(row.ctr);
+			const clicks = num(row.clicks);
+			if (impressions < minImpressions) continue;
+			const positionScore = calculatePositionScore(position);
+			const impressionScore = calculateImpressionScore(impressions);
+			const ctrGapScore = calculateCtrGapScore(ctr, position);
+			const geometricMean = (positionScore ** positionWeight * impressionScore ** impressionsWeight * ctrGapScore ** ctrGapWeight) ** (1 / (positionWeight + impressionsWeight + ctrGapWeight));
+			const opportunityScore = Math.round(geometricMean * 100);
+			const targetCtr = getExpectedCtr(Math.min(3, position));
+			const potentialClicks = Math.round(impressions * targetCtr);
+			results.push({
+				keyword: row.query,
+				page: row.page ?? null,
+				clicks,
+				impressions,
+				ctr,
+				position,
+				opportunityScore,
+				potentialClicks,
+				factors: {
+					positionScore,
+					impressionScore,
+					ctrGapScore
+				}
+			});
+		}
+		const sorted = sortResults(results, sortBy);
+		const paged = paginateInMemory(sorted, {
+			limit: params.limit,
+			offset: params.offset
+		});
+		return {
+			results: paged,
+			meta: {
+				total: sorted.length,
+				returned: paged.length
+			}
+		};
+	}
+});
+function str(v) {
+	return v == null ? "" : String(v);
+}
+function bool(v) {
+	return v === true || v === 1 || v === "true";
+}
+function calculateCV(values) {
+	if (values.length === 0) return 0;
+	const mean = values.reduce((a, b) => a + b, 0) / values.length;
+	if (mean === 0) return 0;
+	const variance = values.reduce((sum, v) => sum + (v - mean) ** 2, 0) / values.length;
+	return Math.min(Math.sqrt(variance) / mean, 1);
+}
+function analyzeSeasonality(dates, options = {}) {
+	const { metric = "clicks" } = options;
+	if (dates.length === 0) return {
+		hasSeasonality: false,
+		strength: 0,
+		peakMonths: [],
+		troughMonths: [],
+		monthlyBreakdown: [],
+		insufficientData: true
+	};
+	const monthlyMap = /* @__PURE__ */ new Map();
+	for (const row of dates) {
+		const month = row.date.substring(0, 7);
+		const value = metric === "clicks" ? row.clicks : row.impressions;
+		monthlyMap.set(month, (monthlyMap.get(month) || 0) + value);
+	}
+	const months = Array.from(monthlyMap.keys()).sort();
+	const values = months.map((m) => monthlyMap.get(m) || 0);
+	const insufficientData = months.length < 12;
+	const totalValue = values.reduce((a, b) => a + b, 0);
+	const avgValue = values.length > 0 ? totalValue / values.length : 0;
+	const monthlyBreakdown = months.map((month, i) => {
+		const value = values[i] ?? 0;
+		const vsAverage = avgValue > 0 ? value / avgValue : 0;
+		return {
+			month,
+			value,
+			vsAverage,
+			isPeak: vsAverage > 1.5,
+			isTrough: vsAverage < .5
+		};
+	});
+	const peakMonths = [...new Set(monthlyBreakdown.filter((m) => m.isPeak).map((m) => m.month.substring(5, 7)))];
+	const troughMonths = [...new Set(monthlyBreakdown.filter((m) => m.isTrough).map((m) => m.month.substring(5, 7)))];
+	const strength = calculateCV(values);
+	return {
+		hasSeasonality: peakMonths.length > 0 || troughMonths.length > 0 || strength > .3,
+		strength,
+		peakMonths,
+		troughMonths,
+		monthlyBreakdown,
+		insufficientData
+	};
+}
+const seasonalityAnalyzer = defineAnalyzer({
+	id: "seasonality",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf(params);
+		return {
+			sql: `
+      WITH monthly AS (
+        SELECT
+          strftime(date, '%Y-%m') AS month,
+          CAST(SUM(${params.metric === "impressions" ? "impressions" : "clicks"}) AS DOUBLE) AS value
+        FROM read_parquet({{FILES}}, union_by_name = true)
+        WHERE date >= ? AND date <= ?
+        GROUP BY month
+      ),
+      stats AS (
+        SELECT
+          AVG(value) AS avg_val,
+          COALESCE(STDDEV_POP(value), 0.0) AS std_val,
+          CAST(COUNT(*) AS DOUBLE) AS month_count
+        FROM monthly
+      )
+      SELECT
+        m.month AS month,
+        m.value AS value,
+        CASE WHEN s.avg_val > 0 THEN m.value / s.avg_val ELSE 0.0 END AS vsAverage,
+        (s.avg_val > 0 AND m.value / s.avg_val > 1.5) AS isPeak,
+        (s.avg_val > 0 AND m.value / s.avg_val < 0.5) AS isTrough,
+        CASE WHEN s.avg_val > 0 THEN LEAST(s.std_val / s.avg_val, 1.0) ELSE 0.0 END AS strength,
+        s.month_count AS monthCount
+      FROM monthly m, stats s
+      ORDER BY m.month
+    `,
+			params: [startDate, endDate],
+			current: {
+				table: "pages",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const breakdown = arr.map((r) => ({
+			month: str(r.month),
+			value: num(r.value),
+			vsAverage: num(r.vsAverage),
+			isPeak: bool(r.isPeak),
+			isTrough: bool(r.isTrough)
+		}));
+		const first = arr[0];
+		const strength = first ? num(first.strength) : 0;
+		const monthCount = first ? num(first.monthCount) : 0;
+		const peakMonths = [...new Set(breakdown.filter((m) => m.isPeak).map((m) => m.month.substring(5, 7)))];
+		const troughMonths = [...new Set(breakdown.filter((m) => m.isTrough).map((m) => m.month.substring(5, 7)))];
+		const hasSeasonality = peakMonths.length > 0 || troughMonths.length > 0 || strength > .3;
+		const insufficientData = monthCount < 12;
+		return {
+			results: breakdown,
+			meta: {
+				total: breakdown.length,
+				hasSeasonality,
+				strength,
+				peakMonths,
+				troughMonths,
+				insufficientData
+			}
+		};
+	},
+	buildRows(params) {
+		return { dates: datesQueryState(periodOf(params), params.limit) };
+	},
+	reduceRows(rows, params) {
+		const result = analyzeSeasonality(Array.isArray(rows) ? rows : [], { metric: params.metric });
+		return {
+			results: result.monthlyBreakdown,
+			meta: { strength: result.strength }
+		};
+	}
+});
+const DEFAULT_ROW_LIMIT$1 = 25e3;
+const strikingDistanceAnalyzer = defineAnalyzer({
+	id: "striking-distance",
+	reduce(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const minPosition = params.minPosition ?? 4;
+		const maxPosition = params.maxPosition ?? 20;
+		const minImpressions = params.minImpressions ?? 100;
+		const maxCtr = params.maxCtr ?? .05;
+		const limit = params.limit ?? 1e3;
+		const results = [];
+		for (const row of arr) {
+			const position = num(row.position);
+			const impressions = num(row.impressions);
+			const ctr = num(row.ctr);
+			const clicks = num(row.clicks);
+			if (position < minPosition || position > maxPosition) continue;
+			if (impressions < minImpressions) continue;
+			if (ctr > maxCtr) continue;
+			results.push({
+				keyword: String(row.query ?? ""),
+				page: row.page == null ? null : String(row.page),
+				clicks,
+				impressions,
+				ctr,
+				position,
+				potentialClicks: Math.round(impressions * .15)
+			});
+		}
+		results.sort((a, b) => b.potentialClicks - a.potentialClicks);
+		const paged = paginateInMemory(results, {
+			limit,
+			offset: params.offset
+		});
+		return {
+			results: paged,
+			meta: {
+				total: results.length,
+				returned: paged.length
+			}
+		};
+	},
+	buildSql(params) {
+		const { startDate, endDate } = periodOf(params);
+		return {
+			sql: `
+    SELECT
+      query,
+      url AS page,
+      CAST(SUM(clicks) AS DOUBLE) AS clicks,
+      CAST(SUM(impressions) AS DOUBLE) AS impressions,
+      CAST(SUM(clicks) AS DOUBLE) / NULLIF(SUM(impressions), 0) AS ctr,
+      SUM(sum_position) / NULLIF(SUM(impressions), 0) + 1 AS position
+    FROM read_parquet({{FILES}}, union_by_name = true)
+    WHERE date >= ? AND date <= ?
+    GROUP BY query, url
+  `,
+			params: [startDate, endDate],
+			current: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	buildRows(params) {
+		return { keywords: keywordsQueryState(periodOf(params), params.limit ?? DEFAULT_ROW_LIMIT$1) };
+	}
+});
+const DEFAULT_ROW_LIMIT = 25e3;
+const sortRowResults = createSorter((item) => item.impressions, "impressions");
+const zeroClickAnalyzer = defineAnalyzer({
+	id: "zero-click",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf(params);
+		const minImpressions = params.minImpressions ?? 1e3;
+		const maxCtr = params.maxCtr ?? .03;
+		const maxPosition = params.maxPosition ?? 10;
+		const limit = params.limit ?? 1e3;
+		return {
+			sql: `
+      WITH agg AS (
+        SELECT
+          query,
+          url AS page,
+          ${METRIC_EXPR.clicks} AS clicks,
+          ${METRIC_EXPR.impressions} AS impressions,
+          ${METRIC_EXPR.ctr} AS ctr,
+          ${METRIC_EXPR.position} AS position
+        FROM read_parquet({{FILES}}, union_by_name = true)
+        WHERE date >= ? AND date <= ?
+        GROUP BY query, url
+        HAVING SUM(impressions) >= ?
+      )
+      SELECT
+        query, page, clicks, impressions, ctr, position,
+        CAST(GREATEST(0, ROUND(impressions * (
+          CASE
+            WHEN position <= 1 THEN 0.30
+            WHEN position <= 3 THEN 0.15
+            WHEN position <= 5 THEN 0.08
+            ELSE 0.04
+          END
+        )) - clicks) AS DOUBLE) AS missedClicks
+      FROM agg
+      WHERE position <= ? AND ctr < ?
+      ORDER BY impressions DESC
+      ${paginateClause({
+				limit,
+				offset: params.offset
+			})}
+    `,
+			params: [
+				startDate,
+				endDate,
+				minImpressions,
+				maxPosition,
+				maxCtr
+			],
+			current: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const minImpressions = params.minImpressions ?? 1e3;
+		const maxCtr = params.maxCtr ?? .03;
+		const maxPosition = params.maxPosition ?? 10;
+		return {
+			results: arr.map((r) => ({
+				query: r.query == null ? "" : String(r.query),
+				page: r.page == null ? "" : String(r.page),
+				clicks: num(r.clicks),
+				impressions: num(r.impressions),
+				ctr: num(r.ctr),
+				position: num(r.position),
+				missedClicks: num(r.missedClicks)
+			})),
+			meta: {
+				total: arr.length,
+				minImpressions,
+				maxCtr,
+				maxPosition
+			}
+		};
+	},
+	buildRows(params) {
+		const period = periodOf(params);
+		const limit = params.limit ?? DEFAULT_ROW_LIMIT;
+		return { rows: gsc.select(query, page).where(between(date, period.startDate, period.endDate)).limit(limit).getState() };
+	},
+	reduceRows(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const minImpressions = params.minImpressions ?? 1e3;
+		const maxCtr = params.maxCtr ?? .03;
+		const maxPosition = params.maxPosition ?? 10;
+		const queryMap = /* @__PURE__ */ new Map();
+		for (const row of arr) {
+			if (row.impressions < minImpressions) continue;
+			if (row.position > maxPosition) continue;
+			if (row.ctr > maxCtr) continue;
+			const existing = queryMap.get(row.query);
+			if (!existing || row.position < existing.position) queryMap.set(row.query, {
+				query: row.query,
+				page: row.page,
+				clicks: row.clicks,
+				impressions: row.impressions,
+				ctr: row.ctr,
+				position: row.position
+			});
+		}
+		const results = sortRowResults(Array.from(queryMap.values()), "impressions", "desc");
+		const paged = paginateInMemory(results, {
+			limit: params.limit,
+			offset: params.offset
+		});
+		return {
+			results: paged,
+			meta: {
+				total: results.length,
+				returned: paged.length
+			}
+		};
+	}
+});
+const defaultAnalyzerRegistry = createAnalyzerRegistry({
+	rows: [
+		strikingDistanceAnalyzer.rows,
+		opportunityAnalyzer.rows,
+		brandAnalyzer.rows,
+		concentrationAnalyzer.rows,
+		clusteringAnalyzer.rows,
+		seasonalityAnalyzer.rows,
+		moversAnalyzer.rows,
+		decayAnalyzer.rows,
+		cannibalizationAnalyzer.rows,
+		zeroClickAnalyzer.rows
+	],
+	sql: SQL_ANALYZERS
+});
+export { defaultAnalyzerRegistry };