@gscdump/analysis 0.6.3 → 0.7.5

package/dist/default-registry.mjs

@@ -1,50 +1,11 @@
-import { SQL_ANALYZERS } from "@gscdump/engine-duckdb-node";
+import { createAnalyzerRegistry, defineAnalyzer } from "@gscdump/engine/analyzer";
+import { num } from "@gscdump/engine/analysis-types";
+import { comparisonOf, defaultEndDate, padTimeseries, periodOf } from "@gscdump/engine/period";
 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
-	};
-}
+import { between, date, extractDateRange, gsc, page, query } from "gscdump/query";
+import { MS_PER_DAY, daysAgo, toIsoDate } from "gscdump";
+import { buildExtrasQueries, buildTotalsSql, mergeExtras, pgResolverAdapter, resolveComparisonSQL, resolveToSQL, resolveToSQLOptimized } from "@gscdump/engine/resolver";
 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();
@@ -55,118 +16,10 @@ function pagesQueryState(period, limit = DEFAULT_LIMIT$1) {
 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) {
+function str$23(v) {
 	return v == null ? "" : String(v);
 }
 function analyzeBrandSegmentation(keywords, options) {
@@ -238,13 +91,13 @@ const brandAnalyzer = defineAnalyzer({
 	},
 	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),
+			query: str$23(r.query),
+			page: r.page == null ? void 0 : str$23(r.page),
 			clicks: num(r.clicks),
 			impressions: num(r.impressions),
 			ctr: num(r.ctr),
 			position: num(r.position),
-			segment: str$6(r.segment)
+			segment: str$23(r.segment)
 		}));
 		let brandClicks = 0;
 		let nonBrandClicks = 0;
@@ -293,6 +146,26 @@ const brandAnalyzer = defineAnalyzer({
 		};
 	}
 });
+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);
+	};
+}
 const sortRowResults$1 = createSorter((item, metric) => {
 	switch (metric) {
 		case "clicks": return item.totalClicks;
@@ -301,10 +174,10 @@ const sortRowResults$1 = createSorter((item, metric) => {
 		case "pageCount": return item.pages.length;
 	}
 }, "clicks");
-function str$5(v) {
+function str$22(v) {
 	return v == null ? "" : String(v);
 }
-function parseJsonList$4(v) {
+function parseJsonList$16(v) {
 	if (Array.isArray(v)) return v;
 	if (typeof v === "string" && v.length > 0) {
 		const parsed = JSON.parse(v);
@@ -464,19 +337,19 @@ const cannibalizationAnalyzer = defineAnalyzer({
 	},
 	reduceSql(rows) {
 		const events = (Array.isArray(rows) ? rows : []).map((r) => ({
-			keyword: str$5(r.keyword),
+			keyword: str$22(r.keyword),
 			totalImpressions: num(r.totalImpressions),
 			totalClicks: num(r.totalClicks),
 			competitorCount: num(r.competitorCount),
-			leaderUrl: str$5(r.leaderUrl),
+			leaderUrl: str$22(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),
+			competitors: parseJsonList$16(r.competitors).map((c) => ({
+				url: str$22(c.url),
 				clicks: num(c.clicks),
 				impressions: num(c.impressions),
 				ctr: num(c.ctr),
@@ -574,10 +447,10 @@ const INTENT_PREFIXES = [
 	"near me"
 ];
 const WHITESPACE_RE = /\s+/;
-function str$4(v) {
+function str$21(v) {
 	return v == null ? "" : String(v);
 }
-function parseJsonList$3(v) {
+function parseJsonList$15(v) {
 	if (Array.isArray(v)) return v;
 	if (typeof v === "string" && v.length > 0) {
 		const parsed = JSON.parse(v);
@@ -722,14 +595,14 @@ const clusteringAnalyzer = defineAnalyzer({
 	},
 	reduceSql(rows) {
 		const clusters = (Array.isArray(rows) ? rows : []).map((r) => ({
-			clusterName: str$4(r.clusterName),
-			clusterType: str$4(r.clusterType),
+			clusterName: str$21(r.clusterName),
+			clusterType: str$21(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),
+			keywords: parseJsonList$15(r.keywords).map((k) => ({
+				query: str$21(k.query),
 				clicks: num(k.clicks),
 				impressions: num(k.impressions),
 				ctr: num(k.ctr),
@@ -759,10 +632,10 @@ const clusteringAnalyzer = defineAnalyzer({
 		};
 	}
 });
-function str$3(v) {
+function str$20(v) {
 	return v == null ? "" : String(v);
 }
-function parseJsonList$2(v) {
+function parseJsonList$14(v) {
 	if (Array.isArray(v)) return v;
 	if (typeof v === "string" && v.length > 0) {
 		const parsed = JSON.parse(v);
@@ -910,20 +783,20 @@ const concentrationAnalyzer = defineAnalyzer({
 	},
 	reduceSql(rows, params) {
 		const r = (Array.isArray(rows) ? rows : [])[0] ?? {};
-		const topRaw = parseJsonList$2(r.topNItems);
+		const topRaw = parseJsonList$14(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),
+					key: str$20(t.key),
 					clicks: num(t.clicks),
 					share: num(t.share)
 				})),
 				totalItems: num(r.totalItems),
 				totalClicks: num(r.totalClicks),
-				riskLevel: str$3(r.riskLevel)
+				riskLevel: str$20(r.riskLevel)
 			}],
 			meta: {
 				total: 1,
@@ -953,10 +826,10 @@ const sortResults$1 = createMetricSorter("lostClicks", {
 	declinePercent: "desc",
 	currentClicks: "asc"
 });
-function str$2(v) {
+function str$19(v) {
 	return v == null ? "" : String(v);
 }
-function parseJsonList$1(v) {
+function parseJsonList$13(v) {
 	if (Array.isArray(v)) return v;
 	if (typeof v === "string" && v.length > 0) {
 		const parsed = JSON.parse(v);
@@ -1093,7 +966,7 @@ const decayAnalyzer = defineAnalyzer({
 		const arr = Array.isArray(rows) ? rows : [];
 		return {
 			results: arr.map((r) => ({
-				page: str$2(r.page),
+				page: str$19(r.page),
 				currentClicks: num(r.currentClicks),
 				previousClicks: num(r.previousClicks),
 				lostClicks: num(r.lostClicks),
@@ -1101,8 +974,8 @@ const decayAnalyzer = defineAnalyzer({
 				currentPosition: num(r.currentPosition),
 				previousPosition: num(r.previousPosition),
 				positionDrop: num(r.positionDrop),
-				series: parseJsonList$1(r.seriesJson).map((s) => ({
-					week: str$2(s.week),
+				series: parseJsonList$13(r.seriesJson).map((s) => ({
+					week: str$19(s.week),
 					clicks: num(s.clicks),
 					impressions: num(s.impressions)
 				}))
@@ -1139,10 +1012,10 @@ function percentDifference(current, previous) {
 	if (previous === 0) return current > 0 ? 100 : 0;
 	return (current - previous) / previous * 100;
 }
-function str$1(v) {
+function str$18(v) {
 	return v == null ? "" : String(v);
 }
-function parseJsonList(v) {
+function parseJsonList$12(v) {
 	if (Array.isArray(v)) return v;
 	if (typeof v === "string" && v.length > 0) {
 		const parsed = JSON.parse(v);
@@ -1329,8 +1202,8 @@ const moversAnalyzer = defineAnalyzer({
 	},
 	reduceSql(rows) {
 		const normalized = (Array.isArray(rows) ? rows : []).map((r) => ({
-			keyword: str$1(r.keyword),
-			page: r.page == null ? null : str$1(r.page),
+			keyword: str$18(r.keyword),
+			page: r.page == null ? null : str$18(r.page),
 			recentClicks: num(r.recentClicks),
 			recentImpressions: num(r.recentImpressions),
 			recentPosition: num(r.recentPosition),
@@ -1341,9 +1214,9 @@ const moversAnalyzer = defineAnalyzer({
 			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),
+			direction: str$18(r.direction),
+			series: parseJsonList$12(r.seriesJson).map((s) => ({
+				week: str$18(s.week),
 				clicks: num(s.clicks),
 				impressions: num(s.impressions)
 			}))
@@ -1618,10 +1491,10 @@ const opportunityAnalyzer = defineAnalyzer({
 		};
 	}
 });
-function str(v) {
+function str$17(v) {
 	return v == null ? "" : String(v);
 }
-function bool(v) {
+function bool$2(v) {
 	return v === true || v === 1 || v === "true";
 }
 function calculateCV(values) {
@@ -1717,11 +1590,11 @@ const seasonalityAnalyzer = defineAnalyzer({
 	reduceSql(rows) {
 		const arr = Array.isArray(rows) ? rows : [];
 		const breakdown = arr.map((r) => ({
-			month: str(r.month),
+			month: str$17(r.month),
 			value: num(r.value),
 			vsAverage: num(r.vsAverage),
-			isPeak: bool(r.isPeak),
-			isTrough: bool(r.isTrough)
+			isPeak: bool$2(r.isPeak),
+			isTrough: bool$2(r.isTrough)
 		}));
 		const first = arr[0];
 		const strength = first ? num(first.strength) : 0;
@@ -1939,19 +1812,2928 @@ const zeroClickAnalyzer = defineAnalyzer({
 		};
 	}
 });
+const ROW_ANALYZERS = [
+	strikingDistanceAnalyzer.rows,
+	opportunityAnalyzer.rows,
+	brandAnalyzer.rows,
+	concentrationAnalyzer.rows,
+	clusteringAnalyzer.rows,
+	seasonalityAnalyzer.rows,
+	moversAnalyzer.rows,
+	decayAnalyzer.rows,
+	cannibalizationAnalyzer.rows,
+	zeroClickAnalyzer.rows
+];
+function num$5(v) {
+	if (typeof v === "number") return v;
+	if (typeof v === "bigint") return Number(v);
+	if (v == null) return 0;
+	const n = Number(v);
+	return Number.isFinite(n) ? n : 0;
+}
+function str$16(v) {
+	return v == null ? "" : String(v);
+}
+const bayesianCtrAnalyzer = defineAnalyzer({
+	id: "bayesian-ctr",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf(params);
+		const minImpressions = params.minImpressions ?? 50;
+		const limit = params.limit ?? 300;
+		const priorMinEntities = 5;
+		return {
+			sql: `
+    WITH entity AS (
+      SELECT
+        query,
+        url,
+        ${METRIC_EXPR.clicks} AS clicks,
+        ${METRIC_EXPR.impressions} AS impressions,
+        ${METRIC_EXPR.ctr} AS observed_ctr,
+        ${METRIC_EXPR.position} AS position,
+        CAST(ROUND(LEAST(${METRIC_EXPR.position}, 30)) AS INTEGER) AS bucket
+      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) >= ?
+        AND ${METRIC_EXPR.position} <= 30
+    ),
+    bucket_mu AS (
+      SELECT
+        bucket,
+        COUNT(*) AS n_entities,
+        SUM(observed_ctr * impressions) / NULLIF(SUM(impressions), 0) AS mu,
+        SUM(impressions) AS total_impressions
+      FROM entity
+      GROUP BY bucket
+    ),
+    bucket_var AS (
+      SELECT
+        e.bucket,
+        GREATEST(
+          SUM(e.impressions * POWER(e.observed_ctr - b.mu, 2))
+            / NULLIF(SUM(e.impressions), 0),
+          1e-9
+        ) AS v
+      FROM entity e
+      JOIN bucket_mu b USING (bucket)
+      GROUP BY e.bucket
+    ),
+    priors AS (
+      SELECT
+        m.bucket,
+        m.n_entities,
+        m.mu,
+        v.v,
+        CASE
+          WHEN m.n_entities >= ${Number(priorMinEntities)}
+            AND v.v > 0
+            AND m.mu > 0 AND m.mu < 1
+            AND (m.mu * (1.0 - m.mu) / v.v - 1.0) > 0
+          THEN GREATEST(0.5, m.mu * (m.mu * (1.0 - m.mu) / v.v - 1.0))
+          ELSE 2.0
+        END AS alpha,
+        CASE
+          WHEN m.n_entities >= ${Number(priorMinEntities)}
+            AND v.v > 0
+            AND m.mu > 0 AND m.mu < 1
+            AND (m.mu * (1.0 - m.mu) / v.v - 1.0) > 0
+          THEN GREATEST(0.5, (1.0 - m.mu) * (m.mu * (1.0 - m.mu) / v.v - 1.0))
+          ELSE 48.0
+        END AS beta
+      FROM bucket_mu m
+      JOIN bucket_var v USING (bucket)
+    ),
+    posterior AS (
+      SELECT
+        e.query,
+        e.url,
+        e.clicks,
+        e.impressions,
+        e.observed_ctr,
+        e.position,
+        e.bucket,
+        p.alpha AS prior_alpha,
+        p.beta AS prior_beta,
+        p.mu AS bucket_prior_mean,
+        p.alpha + e.clicks AS alpha_post,
+        p.beta + (e.impressions - e.clicks) AS beta_post
+      FROM entity e
+      JOIN priors p USING (bucket)
+    ),
+    scored AS (
+      SELECT *,
+        alpha_post / (alpha_post + beta_post) AS posterior_mean,
+        SQRT((alpha_post * beta_post)
+          / (POWER(alpha_post + beta_post, 2) * (alpha_post + beta_post + 1))) AS posterior_sd
+      FROM posterior
+    )
+    SELECT
+      query AS keyword,
+      url AS page,
+      clicks,
+      impressions,
+      observed_ctr AS observedCtr,
+      position,
+      bucket,
+      prior_alpha AS priorAlpha,
+      prior_beta AS priorBeta,
+      bucket_prior_mean AS bucketPriorMean,
+      posterior_mean AS posteriorMean,
+      posterior_sd AS posteriorSd,
+      GREATEST(0.0, posterior_mean - 1.96 * posterior_sd) AS ciLow,
+      LEAST(1.0, posterior_mean + 1.96 * posterior_sd) AS ciHigh,
+      posterior_mean - observed_ctr AS shrinkageDelta,
+      (posterior_mean - observed_ctr) * impressions AS expectedClicksDelta,
+      ABS(observed_ctr - posterior_mean) / NULLIF(posterior_sd, 0) AS significance,
+      CASE
+        WHEN observed_ctr > LEAST(1.0, posterior_mean + 1.96 * posterior_sd) THEN 'overperforming'
+        WHEN observed_ctr < GREATEST(0.0, posterior_mean - 1.96 * posterior_sd) THEN 'underperforming'
+        ELSE 'expected'
+      END AS classification
+    FROM scored
+    ORDER BY significance DESC NULLS LAST
+    LIMIT ${Number(limit)}
+  `,
+			params: [
+				startDate,
+				endDate,
+				minImpressions
+			],
+			current: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const minImpressions = params.minImpressions ?? 50;
+		const results = arr.map((r) => ({
+			keyword: str$16(r.keyword),
+			page: str$16(r.page),
+			clicks: num$5(r.clicks),
+			impressions: num$5(r.impressions),
+			observedCtr: num$5(r.observedCtr),
+			position: num$5(r.position),
+			bucket: num$5(r.bucket),
+			priorAlpha: num$5(r.priorAlpha),
+			priorBeta: num$5(r.priorBeta),
+			bucketPriorMean: num$5(r.bucketPriorMean),
+			posteriorMean: num$5(r.posteriorMean),
+			posteriorSd: num$5(r.posteriorSd),
+			ciLow: num$5(r.ciLow),
+			ciHigh: num$5(r.ciHigh),
+			shrinkageDelta: num$5(r.shrinkageDelta),
+			expectedClicksDelta: num$5(r.expectedClicksDelta),
+			significance: num$5(r.significance),
+			classification: str$16(r.classification)
+		}));
+		const under = results.filter((r) => r.classification === "underperforming").length;
+		const over = results.filter((r) => r.classification === "overperforming").length;
+		return {
+			results,
+			meta: {
+				total: results.length,
+				underperforming: under,
+				overperforming: over,
+				expected: results.length - under - over,
+				minImpressions
+			}
+		};
+	}
+});
+const BIPARTITE_PAGERANK_ITERATIONS = 25;
+const BIPARTITE_PAGERANK_DAMPING = .85;
+function str$15(v) {
+	return v == null ? "" : String(v);
+}
+function parseJsonList$11(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 [];
+}
+const bipartitePagerankAnalyzer = defineAnalyzer({
+	id: "bipartite-pagerank",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf(params);
+		const minImpressions = params.minImpressions ?? 50;
+		const topQueries = 1e3;
+		const topUrls = 500;
+		const limit = params.limit ?? 50;
+		const bridgingEdgeThreshold = .05;
+		const anchoringEdgeThreshold = .05;
+		const iterations = BIPARTITE_PAGERANK_ITERATIONS;
+		const d = BIPARTITE_PAGERANK_DAMPING;
+		const iterCtes = [];
+		for (let i = 1; i <= iterations; i++) iterCtes.push(`
+    ranks_${i} AS (
+      SELECT
+        'q' AS kind,
+        e.qid AS id,
+        (1.0 - ${d}) / (SELECT n FROM query_count)
+          + ${d} * SUM(e.w_u_to_q * r.rank) AS rank
+      FROM u_to_q_weights e
+      JOIN ranks_${i - 1} r ON r.kind = 'u' AND r.id = e.uid
+      GROUP BY e.qid
+      UNION ALL
+      SELECT
+        'u' AS kind,
+        e.uid AS id,
+        (1.0 - ${d}) / (SELECT n FROM url_count)
+          + ${d} * SUM(e.w_q_to_u * r.rank) AS rank
+      FROM q_to_u_weights e
+      JOIN ranks_${i - 1} r ON r.kind = 'q' AND r.id = e.qid
+      GROUP BY e.uid
+    )`);
+		const deltaParts = [];
+		for (let i = 1; i <= iterations; i++) deltaParts.push(`
+      SELECT ${i} AS step,
+        (SELECT COALESCE(SUM(ABS(a.rank - b.rank)), 0.0)
+         FROM ranks_${i} a
+         JOIN ranks_${i - 1} b USING (kind, id)) AS l1`);
+		return {
+			sql: `
+    WITH edges0 AS (
+      SELECT
+        query AS qid,
+        url   AS uid,
+        CAST(SUM(impressions) AS DOUBLE) AS impressions
+      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) >= ?
+    ),
+    -- Top-N caps per side keep the iteration tractable.
+    query_totals AS (
+      SELECT qid, SUM(impressions) AS tot
+      FROM edges0 GROUP BY qid
+    ),
+    url_totals AS (
+      SELECT uid, SUM(impressions) AS tot
+      FROM edges0 GROUP BY uid
+    ),
+    top_queries AS (
+      SELECT qid FROM query_totals
+      ORDER BY tot DESC, qid ASC LIMIT ${Number(topQueries)}
+    ),
+    top_urls AS (
+      SELECT uid FROM url_totals
+      ORDER BY tot DESC, uid ASC LIMIT ${Number(topUrls)}
+    ),
+    edges AS (
+      SELECT e.qid, e.uid, e.impressions
+      FROM edges0 e
+      JOIN top_queries tq USING (qid)
+      JOIN top_urls    tu USING (uid)
+    ),
+    query_nodes AS (SELECT DISTINCT qid FROM edges),
+    url_nodes   AS (SELECT DISTINCT uid FROM edges),
+    query_count AS (SELECT GREATEST(COUNT(*), 1) AS n FROM query_nodes),
+    url_count   AS (SELECT GREATEST(COUNT(*), 1) AS n FROM url_nodes),
+    -- Row-stochastic transition weights in each direction. For q->u the
+    -- weights out of a query sum to 1; symmetric for u->q.
+    q_out AS (SELECT qid, SUM(impressions) AS s FROM edges GROUP BY qid),
+    u_out AS (SELECT uid, SUM(impressions) AS s FROM edges GROUP BY uid),
+    q_to_u_weights AS (
+      SELECT e.qid, e.uid,
+        e.impressions / NULLIF(q.s, 0) AS w_q_to_u
+      FROM edges e JOIN q_out q USING (qid)
+    ),
+    u_to_q_weights AS (
+      SELECT e.qid, e.uid,
+        e.impressions / NULLIF(u.s, 0) AS w_u_to_q
+      FROM edges e JOIN u_out u USING (uid)
+    ),
+    -- Seed: uniform distribution per side. Total mass = 2 (one unit per side).
+    ranks_0 AS (
+      SELECT 'q' AS kind, q.qid AS id, 1.0 / (SELECT n FROM query_count) AS rank
+      FROM query_nodes q
+      UNION ALL
+      SELECT 'u' AS kind, u.uid AS id, 1.0 / (SELECT n FROM url_count) AS rank
+      FROM url_nodes u
+    ),
+    ${iterCtes.join(",\n")},
+    final_ranks AS (SELECT * FROM ranks_${iterations}),
+    -- Hub/anchor diagnostics computed from raw edge mass (not rank). A
+    -- query "bridges" URLs it sends >= ${bridgingEdgeThreshold} of its mass
+    -- to; a URL "anchors" queries that contribute >= ${anchoringEdgeThreshold}
+    -- of its incoming mass.
+    q_bridging AS (
+      SELECT qid, COUNT(*) AS bridging
+      FROM q_to_u_weights
+      WHERE w_q_to_u >= ${bridgingEdgeThreshold}
+      GROUP BY qid
+    ),
+    u_anchoring AS (
+      SELECT uid, COUNT(*) AS anchoring
+      FROM u_to_q_weights
+      WHERE w_u_to_q >= ${anchoringEdgeThreshold}
+      GROUP BY uid
+    ),
+    q_degree AS (
+      SELECT qid, COUNT(*) AS degree, SUM(impressions) AS impressions
+      FROM edges GROUP BY qid
+    ),
+    u_degree AS (
+      SELECT uid, COUNT(*) AS degree, SUM(impressions) AS impressions
+      FROM edges GROUP BY uid
+    ),
+    deltas AS (
+      ${deltaParts.join("\n      UNION ALL\n")}
+    ),
+    query_rows AS (
+      SELECT
+        'query' AS kind, f.id, f.rank,
+        COALESCE(b.bridging, 0)      AS bridging,
+        0                             AS anchoring,
+        COALESCE(qd.degree, 0)       AS degree,
+        COALESCE(qd.impressions, 0)  AS impressions
+      FROM final_ranks f
+      LEFT JOIN q_bridging b ON b.qid = f.id
+      LEFT JOIN q_degree   qd ON qd.qid = f.id
+      WHERE f.kind = 'q'
+      ORDER BY f.rank DESC
+      LIMIT ${Number(limit)}
+    ),
+    url_rows AS (
+      SELECT
+        'url' AS kind, f.id, f.rank,
+        0                             AS bridging,
+        COALESCE(a.anchoring, 0)     AS anchoring,
+        COALESCE(ud.degree, 0)       AS degree,
+        COALESCE(ud.impressions, 0)  AS impressions
+      FROM final_ranks f
+      LEFT JOIN u_anchoring a ON a.uid = f.id
+      LEFT JOIN u_degree   ud ON ud.uid = f.id
+      WHERE f.kind = 'u'
+      ORDER BY f.rank DESC
+      LIMIT ${Number(limit)}
+    ),
+    nodes AS (
+      SELECT * FROM query_rows
+      UNION ALL
+      SELECT * FROM url_rows
+    ),
+    counts AS (
+      SELECT
+        (SELECT n FROM query_count) AS q_count,
+        (SELECT n FROM url_count)   AS u_count
+    ),
+    deltas_json AS (
+      SELECT to_json(list({ 'step': step, 'l1': l1 } ORDER BY step)) AS dj
+      FROM deltas
+    )
+    SELECT
+      n.kind,
+      n.id,
+      n.rank,
+      n.bridging,
+      n.anchoring,
+      n.degree,
+      n.impressions,
+      c.q_count AS queryCount,
+      c.u_count AS urlCount,
+      dj.dj     AS deltasJson
+    FROM nodes n
+    CROSS JOIN counts c
+    CROSS JOIN deltas_json dj
+    ORDER BY n.kind, n.rank DESC
+  `,
+			params: [
+				startDate,
+				endDate,
+				minImpressions
+			],
+			current: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const iterations = BIPARTITE_PAGERANK_ITERATIONS;
+		const d = BIPARTITE_PAGERANK_DAMPING;
+		const results = arr.map((r) => ({
+			kind: str$15(r.kind),
+			id: str$15(r.id),
+			rank: num(r.rank),
+			bridging: num(r.bridging),
+			anchoring: num(r.anchoring),
+			degree: num(r.degree),
+			impressions: num(r.impressions)
+		}));
+		const first = arr[0] ?? {};
+		const queryCount = num(first.queryCount);
+		const urlCount = num(first.urlCount);
+		const deltas = parseJsonList$11(first.deltasJson).map((e) => ({
+			step: num(e.step),
+			l1: num(e.l1)
+		}));
+		const convergenceDelta = deltas.length > 0 ? deltas[deltas.length - 1].l1 : 0;
+		return {
+			results,
+			meta: {
+				total: results.length,
+				convergenceDelta,
+				iterations,
+				damping: d,
+				queryCount,
+				urlCount,
+				deltas
+			}
+		};
+	}
+});
+function num$4(v) {
+	if (typeof v === "number") return v;
+	if (typeof v === "bigint") return Number(v);
+	if (v == null) return 0;
+	const n = Number(v);
+	return Number.isFinite(n) ? n : 0;
+}
+function str$14(v) {
+	return v == null ? "" : String(v);
+}
+function parseJsonList$10(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 [];
+}
+const changePointAnalyzer = defineAnalyzer({
+	id: "change-point",
+	buildSql(params) {
+		const endDate = params.endDate ?? defaultEndDate();
+		const startDate = params.startDate ?? daysAgo(93);
+		const minDays = 21;
+		const minSide = 7;
+		const threshold = params.threshold ?? 10;
+		const minImpressions = params.minImpressions ?? 50;
+		const metric = params.metric === "clicks" || params.metric === "impressions" ? params.metric : "position";
+		const limit = params.limit ?? 100;
+		const valueExpr = metric === "position" ? METRIC_EXPR.position : `CAST(SUM(${metric}) AS DOUBLE)`;
+		return {
+			sql: `
+    WITH daily AS (
+      SELECT
+        query,
+        url AS page,
+        date,
+        ${METRIC_EXPR.clicks} AS clicks,
+        ${METRIC_EXPR.impressions} AS impressions,
+        ${valueExpr} AS value
+      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, date
+      HAVING SUM(impressions) >= 1
+    ),
+    entity_stats AS (
+      SELECT query, page,
+        COUNT(*) AS n_total,
+        SUM(impressions) AS total_impressions,
+        SUM(value) AS sum_total,
+        SUM(value * value) AS sumsq_total
+      FROM daily
+      GROUP BY query, page
+      HAVING COUNT(*) >= ${Number(minDays)}
+        AND SUM(impressions) >= ?
+    ),
+    filtered AS (
+      SELECT d.*,
+        e.n_total, e.sum_total, e.sumsq_total, e.total_impressions
+      FROM daily d
+      JOIN entity_stats e USING (query, page)
+    ),
+    cumulated AS (
+      SELECT *,
+        COUNT(*) OVER w AS n_left,
+        SUM(value) OVER w AS sum_left,
+        SUM(value * value) OVER w AS sumsq_left
+      FROM filtered
+      WINDOW w AS (
+        PARTITION BY query, page
+        ORDER BY date
+        ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
+      )
+    ),
+    llr_scored AS (
+      SELECT *,
+        (n_total - n_left) AS n_right,
+        (sum_total - sum_left) AS sum_right,
+        (sumsq_total - sumsq_left) AS sumsq_right,
+        GREATEST(
+          (sumsq_left / NULLIF(n_left, 0))
+            - (sum_left / NULLIF(n_left, 0)) * (sum_left / NULLIF(n_left, 0)),
+          1e-9
+        ) AS var_left,
+        GREATEST(
+          ((sumsq_total - sumsq_left) / NULLIF(n_total - n_left, 0))
+            - ((sum_total - sum_left) / NULLIF(n_total - n_left, 0))
+              * ((sum_total - sum_left) / NULLIF(n_total - n_left, 0)),
+          1e-9
+        ) AS var_right,
+        GREATEST(
+          (sumsq_total / NULLIF(n_total, 0))
+            - (sum_total / NULLIF(n_total, 0)) * (sum_total / NULLIF(n_total, 0)),
+          1e-9
+        ) AS var_single
+      FROM cumulated
+    ),
+    llr AS (
+      SELECT *,
+        CASE
+          WHEN n_left >= ${Number(minSide)} AND (n_total - n_left) >= ${Number(minSide)}
+          THEN n_total * LN(var_single)
+            - n_left * LN(var_left)
+            - (n_total - n_left) * LN(var_right)
+          ELSE NULL
+        END AS llr
+      FROM llr_scored
+    ),
+    best AS (
+      SELECT query, page, n_total, total_impressions,
+        arg_max(date, llr) AS change_date,
+        MAX(llr) AS best_llr,
+        arg_max(sum_left / NULLIF(n_left, 0), llr) AS left_mean,
+        arg_max((sum_total - sum_left) / NULLIF(n_total - n_left, 0), llr) AS right_mean,
+        arg_max(sqrt(var_left), llr) AS left_std,
+        arg_max(sqrt(var_right), llr) AS right_std
+      FROM llr
+      WHERE llr IS NOT NULL
+      GROUP BY query, page, n_total, total_impressions
+      HAVING MAX(llr) > ${Number(threshold)}
+    ),
+    series AS (
+      SELECT query, page,
+        to_json(list({
+          'date': strftime(date, '%Y-%m-%d'),
+          'value': value
+        } ORDER BY date)) AS seriesJson
+      FROM daily
+      GROUP BY query, page
+    )
+    SELECT
+      b.query AS keyword,
+      b.page,
+      CAST(b.n_total AS DOUBLE) AS totalDays,
+      CAST(b.total_impressions AS DOUBLE) AS totalImpressions,
+      strftime(b.change_date, '%Y-%m-%d') AS changeDate,
+      b.best_llr AS llr,
+      b.left_mean AS leftMean,
+      b.right_mean AS rightMean,
+      (b.right_mean - b.left_mean) AS delta,
+      b.left_std AS leftStddev,
+      b.right_std AS rightStddev,
+      s.seriesJson
+    FROM best b
+    LEFT JOIN series s USING (query, page)
+    ORDER BY b.best_llr DESC
+    LIMIT ${Number(limit)}
+  `,
+			params: [
+				startDate,
+				endDate,
+				minImpressions
+			],
+			current: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const threshold = params.threshold ?? 10;
+		const metric = params.metric === "clicks" || params.metric === "impressions" ? params.metric : "position";
+		const lowerIsBetter = metric === "position";
+		const results = arr.map((r) => {
+			const delta = num$4(r.delta);
+			const improved = lowerIsBetter ? delta < 0 : delta > 0;
+			return {
+				keyword: str$14(r.keyword),
+				page: str$14(r.page),
+				totalDays: num$4(r.totalDays),
+				totalImpressions: num$4(r.totalImpressions),
+				changeDate: str$14(r.changeDate),
+				llr: num$4(r.llr),
+				leftMean: num$4(r.leftMean),
+				rightMean: num$4(r.rightMean),
+				delta,
+				leftStddev: num$4(r.leftStddev),
+				rightStddev: num$4(r.rightStddev),
+				direction: improved ? "improved" : "worsened",
+				series: parseJsonList$10(r.seriesJson).map((s) => ({
+					date: str$14(s.date),
+					value: num$4(s.value)
+				}))
+			};
+		});
+		return {
+			results,
+			meta: {
+				total: results.length,
+				metric,
+				threshold,
+				improved: results.filter((r) => r.direction === "improved").length,
+				worsened: results.filter((r) => r.direction === "worsened").length
+			}
+		};
+	}
+});
+function num$3(v) {
+	if (typeof v === "number") return v;
+	if (typeof v === "bigint") return Number(v);
+	if (v == null) return 0;
+	const n = Number(v);
+	return Number.isFinite(n) ? n : 0;
+}
+function str$13(v) {
+	return v == null ? "" : String(v);
+}
+const contentVelocityAnalyzer = defineAnalyzer({
+	id: "content-velocity",
+	buildSql(params) {
+		const days = Math.min(Math.max(Number(params.days ?? 90), 7), 365);
+		const { endDate } = periodOf(params);
+		const start = new Date(endDate);
+		start.setUTCDate(start.getUTCDate() - days);
+		const startDate = toIsoDate(start);
+		return {
+			sql: `
+    WITH src AS (
+      SELECT query, date
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ? AND impressions > 0
+    ),
+    first_seen AS (
+      SELECT query, MIN(date) AS first_date FROM src GROUP BY query
+    ),
+    per_week AS (
+      SELECT
+        strftime(CAST(date AS DATE), '%G-W%V') AS week,
+        MIN(date) AS week_start,
+        CAST(COUNT(DISTINCT query) AS DOUBLE) AS totalKeywords
+      FROM src
+      GROUP BY week
+    ),
+    new_per_week AS (
+      SELECT
+        strftime(CAST(first_date AS DATE), '%G-W%V') AS week,
+        CAST(COUNT(*) AS DOUBLE) AS newKeywords
+      FROM first_seen
+      GROUP BY week
+    )
+    SELECT
+      pw.week AS week,
+      COALESCE(npw.newKeywords, 0) AS newKeywords,
+      pw.totalKeywords AS totalKeywords
+    FROM per_week pw
+    LEFT JOIN new_per_week npw ON pw.week = npw.week
+    ORDER BY pw.week ASC
+  `,
+			params: [startDate, endDate],
+			current: {
+				table: "keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const days = Math.min(Math.max(Number(params.days ?? 90), 7), 365);
+		const { endDate } = periodOf(params);
+		const startDateD = new Date(endDate);
+		startDateD.setUTCDate(startDateD.getUTCDate() - days);
+		const startDate = toIsoDate(startDateD);
+		const weekly = arr.map((r) => ({
+			week: str$13(r.week),
+			newKeywords: num$3(r.newKeywords),
+			totalKeywords: num$3(r.totalKeywords)
+		}));
+		const total = weekly.reduce((s, w) => s + w.newKeywords, 0);
+		const avg = weekly.length > 0 ? total / weekly.length : 0;
+		const mid = Math.floor(weekly.length / 2);
+		const firstAvg = mid > 0 ? weekly.slice(0, mid).reduce((s, w) => s + w.newKeywords, 0) / mid : 0;
+		const diff = (weekly.length - mid > 0 ? weekly.slice(mid).reduce((s, w) => s + w.newKeywords, 0) / (weekly.length - mid) : 0) - firstAvg;
+		const threshold = Math.max(1, avg * .15);
+		return {
+			results: weekly,
+			meta: {
+				summary: {
+					totalNewKeywords: total,
+					avgPerWeek: avg,
+					trend: diff > threshold ? "accelerating" : diff < -threshold ? "decelerating" : "stable"
+				},
+				days,
+				startDate,
+				endDate
+			}
+		};
+	}
+});
+function num$2(v) {
+	if (typeof v === "number") return v;
+	if (typeof v === "bigint") return Number(v);
+	if (v == null) return 0;
+	const n = Number(v);
+	return Number.isFinite(n) ? n : 0;
+}
+function str$12(v) {
+	return v == null ? "" : String(v);
+}
+function bool$1(v) {
+	return v === true || v === 1 || v === "true";
+}
+function parseJsonList$9(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 [];
+}
+const ctrAnomalyAnalyzer = defineAnalyzer({
+	id: "ctr-anomaly",
+	buildSql(params) {
+		const endDate = params.endDate ?? defaultEndDate();
+		const startDate = params.startDate ?? daysAgo(93);
+		const minDailyImpressions = params.minImpressions ?? 5;
+		const minRollingN = 14;
+		const zThreshold = params.threshold ?? 2;
+		const maxPositionDelta = 1.5;
+		const minBreachDays = 2;
+		const limit = params.limit ?? 200;
+		return {
+			sql: `
+    WITH daily AS (
+      SELECT
+        query,
+        url AS page,
+        date,
+        ${METRIC_EXPR.clicks} AS day_clicks,
+        ${METRIC_EXPR.impressions} AS day_impressions,
+        ${METRIC_EXPR.ctr} AS day_ctr,
+        ${METRIC_EXPR.position} AS day_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, date
+      HAVING SUM(impressions) >= ?
+    ),
+    rolled AS (
+      SELECT *,
+        AVG(day_ctr)           OVER w AS rolling_ctr,
+        STDDEV_POP(day_ctr)    OVER w AS rolling_stddev,
+        AVG(day_position)      OVER w AS rolling_position,
+        COUNT(*)               OVER w AS rolling_n
+      FROM daily
+      WINDOW w AS (
+        PARTITION BY query, page
+        ORDER BY date
+        ROWS BETWEEN 28 PRECEDING AND 1 PRECEDING
+      )
+    ),
+    flagged AS (
+      SELECT *,
+        CASE
+          WHEN rolling_n >= ${Number(minRollingN)} AND rolling_stddev > 0
+            THEN (day_ctr - rolling_ctr) / rolling_stddev
+          ELSE 0.0
+        END AS z_score,
+        CASE
+          WHEN rolling_position IS NULL THEN 0.0
+          ELSE ABS(day_position - rolling_position)
+        END AS position_delta
+      FROM rolled
+    ),
+    breaches AS (
+      SELECT *,
+        CASE
+          WHEN ABS(z_score) >= ${zThreshold}
+            AND position_delta <= ${maxPositionDelta}
+            AND rolling_n >= ${Number(minRollingN)}
+          THEN true ELSE false
+        END AS is_breach
+      FROM flagged
+    ),
+    per_entity AS (
+      SELECT
+        query, page,
+        COUNT(*) FILTER (WHERE is_breach AND z_score < 0) AS breach_days_down,
+        COUNT(*) FILTER (WHERE is_breach AND z_score > 0) AS breach_days_up,
+        SUM(CASE
+          WHEN is_breach AND z_score < 0
+            THEN (rolling_ctr - day_ctr) * day_impressions
+          ELSE 0.0
+        END) AS clicks_lost,
+        SUM(CASE
+          WHEN is_breach AND z_score < 0
+            THEN ABS(z_score) * day_impressions
+          ELSE 0.0
+        END) AS severity_raw,
+        MAX(CASE WHEN is_breach THEN ABS(z_score) ELSE 0.0 END) AS max_z,
+        AVG(rolling_ctr) FILTER (WHERE rolling_n >= ${Number(minRollingN)}) AS baseline_ctr,
+        AVG(rolling_position) FILTER (WHERE rolling_n >= ${Number(minRollingN)}) AS baseline_position,
+        SUM(day_impressions) AS total_impressions,
+        SUM(day_clicks) AS total_clicks
+      FROM breaches
+      GROUP BY query, page
+      HAVING COUNT(*) FILTER (WHERE is_breach AND z_score < 0) >= ${Number(minBreachDays)}
+    ),
+    series AS (
+      SELECT query, page,
+        to_json(list({
+          'date': strftime(date, '%Y-%m-%d'),
+          'ctr': day_ctr,
+          'position': day_position,
+          'impressions': day_impressions,
+          'rollingCtr': rolling_ctr,
+          'rollingStddev': rolling_stddev,
+          'z': z_score,
+          'breach': is_breach AND z_score < 0
+        } ORDER BY date)) AS seriesJson
+      FROM breaches
+      GROUP BY query, page
+    )
+    SELECT
+      e.query AS keyword,
+      e.page,
+      CAST(e.breach_days_down AS DOUBLE) AS breachDaysDown,
+      CAST(e.breach_days_up AS DOUBLE) AS breachDaysUp,
+      CAST(ROUND(e.clicks_lost) AS DOUBLE) AS clicksLost,
+      e.severity_raw AS severityRaw,
+      e.max_z AS maxZ,
+      e.baseline_ctr AS baselineCtr,
+      e.baseline_position AS baselinePosition,
+      e.total_impressions AS totalImpressions,
+      e.total_clicks AS totalClicks,
+      s.seriesJson
+    FROM per_entity e
+    LEFT JOIN series s USING (query, page)
+    ORDER BY clicksLost DESC
+    LIMIT ${Number(limit)}
+  `,
+			params: [
+				startDate,
+				endDate,
+				minDailyImpressions
+			],
+			current: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const minRollingN = 14;
+		const zThreshold = params.threshold ?? 2;
+		const anomalies = arr.map((r) => ({
+			keyword: str$12(r.keyword),
+			page: str$12(r.page),
+			breachDaysDown: num$2(r.breachDaysDown),
+			breachDaysUp: num$2(r.breachDaysUp),
+			clicksLost: num$2(r.clicksLost),
+			severity: num$2(r.severityRaw),
+			maxZ: num$2(r.maxZ),
+			baselineCtr: num$2(r.baselineCtr),
+			baselinePosition: num$2(r.baselinePosition),
+			totalImpressions: num$2(r.totalImpressions),
+			totalClicks: num$2(r.totalClicks),
+			series: parseJsonList$9(r.seriesJson).map((s) => ({
+				date: str$12(s.date),
+				ctr: num$2(s.ctr),
+				position: num$2(s.position),
+				impressions: num$2(s.impressions),
+				rollingCtr: s.rollingCtr == null ? null : num$2(s.rollingCtr),
+				rollingStddev: s.rollingStddev == null ? null : num$2(s.rollingStddev),
+				z: num$2(s.z),
+				breach: bool$1(s.breach)
+			}))
+		}));
+		const totalClicksLost = anomalies.reduce((s, a) => s + a.clicksLost, 0);
+		const totalBreachDays = anomalies.reduce((s, a) => s + a.breachDaysDown, 0);
+		return {
+			results: anomalies,
+			meta: {
+				total: anomalies.length,
+				totalClicksLost,
+				totalBreachDays,
+				zThreshold,
+				minRollingN
+			}
+		};
+	}
+});
+function num$1(v) {
+	if (typeof v === "number") return v;
+	if (typeof v === "bigint") return Number(v);
+	if (v == null) return 0;
+	const n = Number(v);
+	return Number.isFinite(n) ? n : 0;
+}
+function str$11(v) {
+	return v == null ? "" : String(v);
+}
+function parseJsonList$8(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 [];
+}
+const ctrCurveAnalyzer = defineAnalyzer({
+	id: "ctr-curve",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf(params);
+		return {
+			sql: `
+    WITH src AS (
+      SELECT
+        query,
+        clicks,
+        impressions,
+        sum_position,
+        (sum_position / NULLIF(impressions, 0) + 1) AS avg_pos
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ? AND impressions > 0
+    ),
+    curve AS (
+      SELECT
+        CASE
+          WHEN avg_pos <= 1.5 THEN '1'
+          WHEN avg_pos <= 2.5 THEN '2'
+          WHEN avg_pos <= 3.5 THEN '3'
+          WHEN avg_pos <= 5.5 THEN '4-5'
+          WHEN avg_pos <= 10.5 THEN '6-10'
+          WHEN avg_pos <= 20.5 THEN '11-20'
+          ELSE '20+'
+        END AS bucket,
+        AVG(CAST(clicks AS DOUBLE) / NULLIF(impressions, 0)) AS avgCtr,
+        AVG(avg_pos) AS medianPosition,
+        CAST(COUNT(DISTINCT query) AS DOUBLE) AS keywordCount,
+        ${METRIC_EXPR.clicks} AS totalClicks,
+        ${METRIC_EXPR.impressions} AS totalImpressions
+      FROM src
+      GROUP BY bucket
+    ),
+    ks AS (
+      SELECT
+        query,
+        ${METRIC_EXPR.clicks} AS clicks,
+        ${METRIC_EXPR.impressions} AS impressions,
+        ${METRIC_EXPR.ctr} AS ctr,
+        ${METRIC_EXPR.position} AS position,
+        CASE
+          WHEN ${METRIC_EXPR.position} <= 3.5 THEN 'top3'
+          WHEN ${METRIC_EXPR.position} <= 10.5 THEN 'page1'
+          WHEN ${METRIC_EXPR.position} <= 20.5 THEN 'page2'
+          ELSE 'deep'
+        END AS band
+      FROM src
+      GROUP BY query
+      HAVING SUM(impressions) >= 20
+    ),
+    band_avg AS (
+      SELECT band, AVG(ctr) AS band_avg_ctr FROM ks GROUP BY band
+    ),
+    outliers AS (
+      SELECT
+        ks.query, ks.clicks, ks.impressions, ks.ctr, ks.position,
+        ba.band_avg_ctr AS expectedCtr,
+        ks.ctr - ba.band_avg_ctr AS ctrDiff
+      FROM ks JOIN band_avg ba ON ks.band = ba.band
+      ORDER BY ABS(ks.ctr - ba.band_avg_ctr) DESC
+      LIMIT 50
+    )
+    SELECT
+      (SELECT to_json(list({
+        'bucket': bucket,
+        'avgCtr': avgCtr,
+        'medianPosition': medianPosition,
+        'keywordCount': keywordCount,
+        'totalClicks': totalClicks,
+        'totalImpressions': totalImpressions
+      })) FROM curve) AS curve_json,
+      (SELECT to_json(list({
+        'query': query,
+        'clicks': clicks,
+        'impressions': impressions,
+        'ctr': ctr,
+        'position': position,
+        'expectedCtr': expectedCtr,
+        'ctrDiff': ctrDiff
+      })) FROM outliers) AS outliers_json
+  `,
+			params: [startDate, endDate],
+			current: {
+				table: "keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const { startDate, endDate } = periodOf(params);
+		const row = arr[0] ?? {};
+		const curve = parseJsonList$8(row.curve_json).map((r) => ({
+			bucket: str$11(r.bucket),
+			avgCtr: num$1(r.avgCtr),
+			medianPosition: num$1(r.medianPosition),
+			keywordCount: num$1(r.keywordCount),
+			totalClicks: num$1(r.totalClicks),
+			totalImpressions: num$1(r.totalImpressions)
+		}));
+		const outliers = parseJsonList$8(row.outliers_json).map((r) => ({
+			query: str$11(r.query),
+			clicks: num$1(r.clicks),
+			impressions: num$1(r.impressions),
+			ctr: num$1(r.ctr),
+			position: num$1(r.position),
+			expectedCtr: num$1(r.expectedCtr),
+			ctrDiff: num$1(r.ctrDiff)
+		}));
+		return {
+			results: curve,
+			meta: {
+				overperforming: outliers.filter((o) => o.ctrDiff > 0).slice(0, 25),
+				underperforming: outliers.filter((o) => o.ctrDiff < 0).slice(0, 25),
+				startDate,
+				endDate
+			}
+		};
+	}
+});
+function str$10(v) {
+	return v == null ? "" : String(v);
+}
+function parseJsonList$7(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 [];
+}
+const darkTrafficAnalyzer = defineAnalyzer({
+	id: "dark-traffic",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf(params);
+		return {
+			sql: `
+    WITH page_totals AS (
+      SELECT SUM(clicks) AS total_clicks, SUM(impressions) AS total_impressions
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ?
+    ),
+    kw_totals AS (
+      SELECT SUM(clicks) AS total_clicks, SUM(impressions) AS total_impressions
+      FROM read_parquet({{FILES_KEYWORDS}}, union_by_name = true)
+      WHERE date >= ? AND date <= ?
+    ),
+    per_page AS (
+      SELECT url, SUM(clicks) AS page_clicks
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ?
+      GROUP BY url
+      HAVING SUM(clicks) > 0
+    ),
+    per_page_kw AS (
+      SELECT url, SUM(clicks) AS attributed_clicks, COUNT(DISTINCT query) AS kw_count
+      FROM read_parquet({{FILES_PAGE_KEYWORDS}}, union_by_name = true)
+      WHERE date >= ? AND date <= ?
+      GROUP BY url
+    ),
+    page_rows AS (
+      SELECT
+        p.url AS url,
+        CAST(p.page_clicks AS DOUBLE) AS totalClicks,
+        CAST(COALESCE(k.attributed_clicks, 0) AS DOUBLE) AS attributedClicks,
+        CAST(p.page_clicks - COALESCE(k.attributed_clicks, 0) AS DOUBLE) AS darkClicks,
+        CAST(p.page_clicks - COALESCE(k.attributed_clicks, 0) AS DOUBLE)
+          / NULLIF(p.page_clicks, 0) AS darkPercent,
+        CAST(COALESCE(k.kw_count, 0) AS DOUBLE) AS keywordCount
+      FROM per_page p
+      LEFT JOIN per_page_kw k ON p.url = k.url
+      WHERE p.page_clicks - COALESCE(k.attributed_clicks, 0) > 0
+      ORDER BY darkClicks DESC
+      LIMIT 50
+    )
+    SELECT
+      (SELECT to_json({
+        'totalClicks': CAST(total_clicks AS DOUBLE),
+        'totalImpressions': CAST(total_impressions AS DOUBLE)
+      }) FROM page_totals) AS page_totals_json,
+      (SELECT to_json({
+        'attributedClicks': CAST(total_clicks AS DOUBLE),
+        'attributedImpressions': CAST(total_impressions AS DOUBLE)
+      }) FROM kw_totals) AS kw_totals_json,
+      (SELECT to_json(list({
+        'url': url,
+        'totalClicks': totalClicks,
+        'attributedClicks': attributedClicks,
+        'darkClicks': darkClicks,
+        'darkPercent': darkPercent,
+        'keywordCount': keywordCount
+      })) FROM page_rows) AS pages_json
+  `,
+			params: [
+				startDate,
+				endDate,
+				startDate,
+				endDate,
+				startDate,
+				endDate,
+				startDate,
+				endDate
+			],
+			current: {
+				table: "pages",
+				partitions: enumeratePartitions(startDate, endDate)
+			},
+			extraFiles: {
+				KEYWORDS: {
+					table: "keywords",
+					partitions: enumeratePartitions(startDate, endDate)
+				},
+				PAGE_KEYWORDS: {
+					table: "page_keywords",
+					partitions: enumeratePartitions(startDate, endDate)
+				}
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const { startDate, endDate } = periodOf(params);
+		const row = arr[0] ?? {};
+		const pageTotals = typeof row.page_totals_json === "string" ? JSON.parse(row.page_totals_json) : row.page_totals_json ?? {};
+		const kwTotals = typeof row.kw_totals_json === "string" ? JSON.parse(row.kw_totals_json) : row.kw_totals_json ?? {};
+		const totalClicks = num(pageTotals.totalClicks);
+		const totalImpressions = num(pageTotals.totalImpressions);
+		const attributedClicks = num(kwTotals.attributedClicks);
+		const attributedImpressions = num(kwTotals.attributedImpressions);
+		const darkClicks = Math.max(0, totalClicks - attributedClicks);
+		const darkPercent = totalClicks > 0 ? darkClicks / totalClicks : 0;
+		return {
+			results: parseJsonList$7(row.pages_json).map((r) => ({
+				url: str$10(r.url),
+				totalClicks: num(r.totalClicks),
+				attributedClicks: num(r.attributedClicks),
+				darkClicks: num(r.darkClicks),
+				darkPercent: num(r.darkPercent),
+				keywordCount: num(r.keywordCount)
+			})),
+			meta: {
+				summary: {
+					totalClicks,
+					attributedClicks,
+					darkClicks,
+					darkPercent,
+					totalImpressions,
+					attributedImpressions
+				},
+				startDate,
+				endDate
+			}
+		};
+	}
+});
+function requireBuilderState(input, tool) {
+	if (!input || typeof input !== "object" || !("dimensions" in input) || !Array.isArray(input.dimensions)) throw new Error(`${tool}: params.q is required (BuilderState)`);
+	return input;
+}
+function optionalBuilderState(input, tool, key) {
+	if (input == null) return null;
+	if (typeof input !== "object" || !("dimensions" in input) || !Array.isArray(input.dimensions)) throw new Error(`${tool}: params.${key} must be a BuilderState`);
+	return input;
+}
+const NUMERIC_METRIC_COLS = [
+	"clicks",
+	"impressions",
+	"ctr",
+	"position",
+	"prevClicks",
+	"prevImpressions",
+	"prevCtr",
+	"prevPosition",
+	"variantCount",
+	"totalCount"
+];
+function coerceNumericCols(row) {
+	const out = { ...row };
+	for (const col of NUMERIC_METRIC_COLS) if (col in out && out[col] != null) out[col] = Number(out[col]);
+	return out;
+}
+function shapeDataQuery(rows, extras, opts) {
+	let totalCount;
+	let cleaned;
+	if (opts.hasPrev) {
+		cleaned = rows.map(coerceNumericCols);
+		totalCount = Number((extras?.count?.[0])?.total ?? cleaned.length);
+	} else {
+		const first = rows[0];
+		totalCount = Number(first?.totalCount ?? 0);
+		cleaned = rows.map((raw) => {
+			const { totalCount: _tc, totalClicks: _tclk, totalImpressions: _timp, totalCtr: _tctr, totalPosition: _tpos, sum_position: _sp, ...rest } = raw;
+			return coerceNumericCols(rest);
+		});
+	}
+	const totalsRow = extras?.totals?.[0] ?? {};
+	const totals = {
+		clicks: Number(totalsRow.clicks ?? 0),
+		impressions: Number(totalsRow.impressions ?? 0),
+		ctr: Number(totalsRow.ctr ?? 0),
+		position: Number(totalsRow.position ?? 0)
+	};
+	const extrasResults = [];
+	if (extras?.canonicalExtras) extrasResults.push({
+		key: "canonicalExtras",
+		results: extras.canonicalExtras
+	});
+	return {
+		results: mergeExtras(cleaned, extrasResults),
+		meta: {
+			totalCount,
+			totals
+		}
+	};
+}
+function buildDataQueryPlan(params, options) {
+	const state = requireBuilderState(params.q, "data-query");
+	if (state.dimensions.includes("date")) throw new Error("data-query: date dimension not supported; use data-detail");
+	const prev = optionalBuilderState(params.qc, "data-query", "qc");
+	const totals = buildTotalsSql(state, options);
+	const extras = buildExtrasQueries(state, options);
+	const extraQueries = [{
+		name: "totals",
+		sql: totals.sql,
+		params: totals.params
+	}, ...extras.map((extra) => ({
+		name: extra.key,
+		sql: extra.sql,
+		params: extra.params
+	}))];
+	const tableKey = options.adapter.inferTable(state.dimensions);
+	if (prev) {
+		const comparison = resolveComparisonSQL(state, prev, options, params.comparisonFilter);
+		extraQueries.push({
+			name: "count",
+			sql: comparison.countSql,
+			params: comparison.countParams
+		});
+		return {
+			tableKey,
+			sql: comparison.sql,
+			params: comparison.params,
+			extraQueries,
+			shape: (rows, _params, resolvedExtras) => shapeDataQuery(rows, resolvedExtras, { hasPrev: true })
+		};
+	}
+	const optimized = resolveToSQLOptimized(state, options);
+	return {
+		tableKey,
+		sql: optimized.sql,
+		params: optimized.params,
+		extraQueries,
+		shape: (rows, _params, resolvedExtras) => shapeDataQuery(rows, resolvedExtras, { hasPrev: false })
+	};
+}
+function buildDataDetailPlan(params, options) {
+	const state = requireBuilderState(params.q, "data-detail");
+	if (!state.dimensions.includes("date")) throw new Error("data-detail: `date` dimension is required");
+	const main = resolveToSQL(state, options);
+	const totals = buildTotalsSql(state, options);
+	const prev = optionalBuilderState(params.qc, "data-detail", "qc");
+	const extraQueries = [{
+		name: "totals",
+		sql: totals.sql,
+		params: totals.params
+	}];
+	if (prev) {
+		const previousTotals = buildTotalsSql(prev, options);
+		extraQueries.push({
+			name: "prevTotals",
+			sql: previousTotals.sql,
+			params: previousTotals.params
+		});
+	}
+	const tableKey = options.adapter.inferTable(state.dimensions);
+	const { startDate: rangeStart, endDate: rangeEnd } = extractDateRange(state.filter);
+	return {
+		tableKey,
+		sql: main.sql,
+		params: main.params,
+		extraQueries,
+		shape: (rows, _params, extras) => {
+			const coerced = rows.map(coerceNumericCols);
+			const daily = rangeStart && rangeEnd ? padTimeseries(coerced, {
+				startDate: rangeStart,
+				endDate: rangeEnd
+			}) : coerced;
+			const totalsRow = extras?.totals?.[0] ?? {};
+			const meta = { totals: {
+				clicks: Number(totalsRow.clicks ?? 0),
+				impressions: Number(totalsRow.impressions ?? 0),
+				ctr: Number(totalsRow.ctr ?? 0),
+				position: Number(totalsRow.position ?? 0)
+			} };
+			if (extras?.prevTotals) {
+				const previousTotalsRow = extras.prevTotals[0] ?? {};
+				meta.previousTotals = {
+					clicks: Number(previousTotalsRow.clicks ?? 0),
+					impressions: Number(previousTotalsRow.impressions ?? 0),
+					ctr: Number(previousTotalsRow.ctr ?? 0),
+					position: Number(previousTotalsRow.position ?? 0)
+				};
+			}
+			return {
+				results: daily,
+				meta
+			};
+		}
+	};
+}
+const dataDetailAnalyzer = defineAnalyzer({
+	id: "data-detail",
+	buildSql(params) {
+		const plan = buildDataDetailPlan(params, { adapter: pgResolverAdapter });
+		return {
+			sql: plan.sql,
+			params: plan.params,
+			current: {
+				table: plan.tableKey,
+				partitions: []
+			},
+			requiresAttachedTables: true,
+			extraQueries: plan.extraQueries
+		};
+	},
+	reduceSql(rows, params, ctx) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const { results, meta } = buildDataDetailPlan(params, { adapter: pgResolverAdapter }).shape(arr, params, ctx.extras);
+		return {
+			results,
+			meta
+		};
+	}
+});
+const dataQueryAnalyzer = defineAnalyzer({
+	id: "data-query",
+	buildSql(params) {
+		const plan = buildDataQueryPlan(params, { adapter: pgResolverAdapter });
+		return {
+			sql: plan.sql,
+			params: plan.params,
+			current: {
+				table: plan.tableKey,
+				partitions: []
+			},
+			requiresAttachedTables: true,
+			extraQueries: plan.extraQueries
+		};
+	},
+	reduceSql(rows, params, ctx) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const { results, meta } = buildDataQueryPlan(params, { adapter: pgResolverAdapter }).shape(arr, params, ctx.extras);
+		return {
+			results,
+			meta
+		};
+	}
+});
+function str$9(v) {
+	return v == null ? "" : String(v);
+}
+const deviceGapAnalyzer = defineAnalyzer({
+	id: "device-gap",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf(params);
+		return {
+			sql: `
+    SELECT
+      date,
+      device,
+      ${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 date, device
+    ORDER BY date ASC
+  `,
+			params: [startDate, endDate],
+			current: {
+				table: "devices",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const { startDate, endDate } = periodOf(params);
+		const typed = arr.map((r) => ({
+			date: str$9(r.date),
+			device: str$9(r.device).toUpperCase(),
+			clicks: num(r.clicks),
+			impressions: num(r.impressions),
+			ctr: num(r.ctr),
+			position: num(r.position)
+		}));
+		const byDate = /* @__PURE__ */ new Map();
+		for (const r of typed) {
+			const entry = byDate.get(r.date) ?? {};
+			const metrics = {
+				clicks: r.clicks,
+				impressions: r.impressions,
+				ctr: r.ctr,
+				position: r.position
+			};
+			if (r.device === "DESKTOP") entry.desktop = metrics;
+			else if (r.device === "MOBILE") entry.mobile = metrics;
+			byDate.set(r.date, entry);
+		}
+		const zero = {
+			clicks: 0,
+			impressions: 0,
+			ctr: 0,
+			position: 0
+		};
+		const daily = [...byDate.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([date, sides]) => {
+			const d = sides.desktop ?? zero;
+			const m = sides.mobile ?? zero;
+			return {
+				date,
+				desktop: d,
+				mobile: m,
+				gaps: {
+					ctrGap: d.ctr - m.ctr,
+					positionGap: m.position - d.position
+				}
+			};
+		});
+		const weekly = (start, end) => {
+			const slice = daily.slice(start, end);
+			if (slice.length === 0) return {
+				ctr: 0,
+				pos: 0
+			};
+			const sum = slice.reduce((acc, d) => ({
+				ctr: acc.ctr + d.gaps.ctrGap,
+				pos: acc.pos + d.gaps.positionGap
+			}), {
+				ctr: 0,
+				pos: 0
+			});
+			return {
+				ctr: sum.ctr / slice.length,
+				pos: sum.pos / slice.length
+			};
+		};
+		const first = weekly(0, 7);
+		const last = weekly(Math.max(0, daily.length - 7), daily.length);
+		const classify = (firstVal, lastVal) => {
+			const diff = Math.abs(lastVal) - Math.abs(firstVal);
+			if (Math.abs(diff) < .005) return "stable";
+			return diff < 0 ? "improving" : "worsening";
+		};
+		return {
+			results: daily,
+			meta: {
+				summary: {
+					avgCtrGap: daily.reduce((s, d) => s + d.gaps.ctrGap, 0) / Math.max(1, daily.length),
+					avgPositionGap: daily.reduce((s, d) => s + d.gaps.positionGap, 0) / Math.max(1, daily.length),
+					ctrGapTrend: classify(first.ctr, last.ctr),
+					positionGapTrend: classify(first.pos, last.pos)
+				},
+				startDate,
+				endDate
+			}
+		};
+	}
+});
+function str$8(v) {
+	return v == null ? "" : String(v);
+}
+function parseJsonList$6(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 [];
+}
+const INTENT_ATLAS_STOP_WORDS = [
+	"the",
+	"a",
+	"an",
+	"is",
+	"are",
+	"was",
+	"were",
+	"be",
+	"been",
+	"of",
+	"to",
+	"in",
+	"for",
+	"on",
+	"and",
+	"or",
+	"with",
+	"at",
+	"by",
+	"from",
+	"into",
+	"about",
+	"as",
+	"so",
+	"than",
+	"then",
+	"that",
+	"this",
+	"my",
+	"your",
+	"our",
+	"their",
+	"his",
+	"her",
+	"its",
+	"me",
+	"you",
+	"what",
+	"how",
+	"why",
+	"when",
+	"where",
+	"who",
+	"which",
+	"do",
+	"does"
+];
+const intentAtlasAnalyzer = defineAnalyzer({
+	id: "intent-atlas",
+	buildSql(params) {
+		const endDate = params.endDate ?? defaultEndDate();
+		const startDate = params.startDate ?? daysAgo(90);
+		const minQueryImpressions = params.minImpressions ?? 20;
+		const minClusterSize = params.minClusterSize ?? 3;
+		const minTokenImpressions = 50;
+		const limit = params.limit ?? 200;
+		const stopList = INTENT_ATLAS_STOP_WORDS.map((w) => `'${w}'`).join(", ");
+		return {
+			sql: `
+    WITH queries AS (
+      SELECT
+        query,
+        ${METRIC_EXPR.impressions} AS impressions,
+        ${METRIC_EXPR.clicks} AS clicks,
+        ${METRIC_EXPR.position} AS position
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ?
+        AND query IS NOT NULL AND query <> ''
+      GROUP BY query
+      HAVING SUM(impressions) >= ?
+    ),
+    tokens AS (
+      SELECT q.query, q.impressions, q.clicks, q.position,
+        LOWER(t.token) AS token
+      FROM queries q,
+        unnest(regexp_split_to_array(LOWER(q.query), '\\s+')) AS t(token)
+      WHERE LENGTH(t.token) >= 3
+        AND LOWER(t.token) NOT IN (${stopList})
+    ),
+    token_weights AS (
+      SELECT token,
+        SUM(impressions) AS token_impressions,
+        COUNT(DISTINCT query) AS query_count
+      FROM tokens
+      GROUP BY token
+      HAVING SUM(impressions) >= ${Number(minTokenImpressions)}
+    ),
+    ranked_tokens AS (
+      SELECT t.query, t.token, tw.token_impressions,
+        ROW_NUMBER() OVER (
+          PARTITION BY t.query
+          ORDER BY tw.token_impressions DESC, t.token ASC
+        ) AS rnk
+      FROM tokens t
+      JOIN token_weights tw USING (token)
+    ),
+    cluster_keys AS (
+      SELECT query,
+        array_to_string(list(token ORDER BY token), ' + ') AS cluster_key
+      FROM ranked_tokens
+      WHERE rnk <= 2
+      GROUP BY query
+      HAVING COUNT(*) >= 2
+    ),
+    clustered AS (
+      SELECT q.query, q.impressions, q.clicks, q.position, ck.cluster_key
+      FROM queries q
+      JOIN cluster_keys ck USING (query)
+    )
+    SELECT
+      cluster_key AS clusterKey,
+      COUNT(*) AS keywordCount,
+      SUM(impressions) AS totalImpressions,
+      SUM(clicks) AS totalClicks,
+      SUM(clicks) / NULLIF(SUM(impressions), 0) AS ctr,
+      AVG(position) AS avgPosition,
+      to_json(list({
+        'query': query,
+        'impressions': impressions,
+        'clicks': clicks,
+        'position': position
+      } ORDER BY impressions DESC)) AS keywords
+    FROM clustered
+    GROUP BY cluster_key
+    HAVING COUNT(*) >= ${Number(minClusterSize)}
+    ORDER BY totalImpressions DESC
+    LIMIT ${Number(limit)}
+  `,
+			params: [
+				startDate,
+				endDate,
+				minQueryImpressions
+			],
+			current: {
+				table: "keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows) {
+		const clusters = (Array.isArray(rows) ? rows : []).map((r) => ({
+			clusterKey: str$8(r.clusterKey),
+			keywordCount: num(r.keywordCount),
+			totalImpressions: num(r.totalImpressions),
+			totalClicks: num(r.totalClicks),
+			ctr: num(r.ctr),
+			avgPosition: num(r.avgPosition),
+			keywords: parseJsonList$6(r.keywords).slice(0, 25).map((k) => ({
+				query: str$8(k.query),
+				impressions: num(k.impressions),
+				clicks: num(k.clicks),
+				position: num(k.position)
+			}))
+		}));
+		const totalImpressions = clusters.reduce((s, c) => s + c.totalImpressions, 0);
+		const totalKeywords = clusters.reduce((s, c) => s + c.keywordCount, 0);
+		return {
+			results: clusters,
+			meta: {
+				total: clusters.length,
+				totalImpressions,
+				totalKeywords
+			}
+		};
+	}
+});
+function str$7(v) {
+	return v == null ? "" : String(v);
+}
+function parseJsonList$5(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 [];
+}
+const keywordBreadthAnalyzer = defineAnalyzer({
+	id: "keyword-breadth",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf(params);
+		return {
+			sql: `
+    WITH per_page AS (
+      SELECT
+        url,
+        CAST(COUNT(DISTINCT query) AS DOUBLE) AS keywordCount,
+        ${METRIC_EXPR.clicks} AS clicks,
+        ${METRIC_EXPR.impressions} AS impressions
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ? AND impressions > 0
+      GROUP BY url
+    ),
+    bucketed AS (
+      SELECT
+        CASE
+          WHEN keywordCount = 1 THEN '1'
+          WHEN keywordCount BETWEEN 2 AND 5 THEN '2-5'
+          WHEN keywordCount BETWEEN 6 AND 15 THEN '6-15'
+          WHEN keywordCount BETWEEN 16 AND 50 THEN '16-50'
+          ELSE '50+'
+        END AS bucket,
+        MIN(keywordCount) AS sort_key,
+        CAST(COUNT(*) AS DOUBLE) AS pageCount
+      FROM per_page
+      GROUP BY bucket
+    ),
+    fragile AS (
+      SELECT url, keywordCount, clicks, impressions
+      FROM per_page
+      WHERE keywordCount <= 2 AND clicks >= 5
+      ORDER BY clicks DESC
+      LIMIT 20
+    ),
+    authority AS (
+      SELECT url, keywordCount, clicks, impressions
+      FROM per_page
+      WHERE keywordCount >= 20
+      ORDER BY keywordCount DESC
+      LIMIT 20
+    ),
+    stats AS (
+      SELECT
+        CAST(COUNT(*) AS DOUBLE) AS totalPages,
+        CAST(AVG(keywordCount) AS DOUBLE) AS avgKeywordsPerPage,
+        CAST(SUM(CASE WHEN keywordCount <= 2 THEN 1 ELSE 0 END) AS DOUBLE) AS fragileCount,
+        CAST(SUM(CASE WHEN keywordCount >= 20 THEN 1 ELSE 0 END) AS DOUBLE) AS authorityCount
+      FROM per_page
+    )
+    SELECT
+      (SELECT to_json(list({ 'bucket': bucket, 'pageCount': pageCount, 'sortKey': sort_key })
+        ORDER BY sort_key ASC) FROM bucketed) AS distribution_json,
+      (SELECT to_json(list({ 'url': url, 'keywordCount': keywordCount, 'clicks': clicks, 'impressions': impressions })) FROM fragile) AS fragile_json,
+      (SELECT to_json(list({ 'url': url, 'keywordCount': keywordCount, 'clicks': clicks, 'impressions': impressions })) FROM authority) AS authority_json,
+      (SELECT to_json({
+        'totalPages': totalPages,
+        'avgKeywordsPerPage': avgKeywordsPerPage,
+        'fragileCount': fragileCount,
+        'authorityCount': authorityCount
+      }) FROM stats) AS stats_json
+  `,
+			params: [startDate, endDate],
+			current: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const { startDate, endDate } = periodOf(params);
+		const row = arr[0] ?? {};
+		const distribution = parseJsonList$5(row.distribution_json).sort((a, b) => num(a.sortKey) - num(b.sortKey)).map((r) => ({
+			bucket: str$7(r.bucket),
+			pageCount: num(r.pageCount)
+		}));
+		const fragile = parseJsonList$5(row.fragile_json).map((r) => ({
+			url: str$7(r.url),
+			keywordCount: num(r.keywordCount),
+			clicks: num(r.clicks),
+			impressions: num(r.impressions)
+		}));
+		const authority = parseJsonList$5(row.authority_json).map((r) => ({
+			url: str$7(r.url),
+			keywordCount: num(r.keywordCount),
+			clicks: num(r.clicks),
+			impressions: num(r.impressions)
+		}));
+		const stats = typeof row.stats_json === "string" ? JSON.parse(row.stats_json) : row.stats_json ?? {};
+		return {
+			results: distribution,
+			meta: {
+				fragilePages: fragile,
+				authorityPages: authority,
+				summary: {
+					totalPages: num(stats.totalPages),
+					avgKeywordsPerPage: num(stats.avgKeywordsPerPage),
+					fragileCount: num(stats.fragileCount),
+					authorityCount: num(stats.authorityCount)
+				},
+				startDate,
+				endDate
+			}
+		};
+	}
+});
+function str$6(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 downsampleLogRank(points) {
+	const all = points.map((p) => ({
+		rank: num(p.rank),
+		impressions: num(p.impressions),
+		clicks: num(p.clicks),
+		query: str$6(p.query)
+	}));
+	if (all.length <= 80) return all;
+	const top = all.slice(0, 10);
+	const rest = all.slice(10);
+	const stepped = [];
+	let nextThreshold = 1.15;
+	for (const p of rest) if (p.rank >= nextThreshold) {
+		stepped.push(p);
+		nextThreshold *= 1.15;
+	}
+	return [...top, ...stepped];
+}
+const longTailAnalyzer = defineAnalyzer({
+	id: "long-tail",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf(params);
+		const minQueries = 10;
+		const minQueryImpressions = params.minImpressions ?? 5;
+		const limit = params.limit ?? 100;
+		return {
+			sql: `
+    WITH page_queries AS (
+      SELECT
+        url AS page,
+        query,
+        ${METRIC_EXPR.impressions} AS impressions,
+        ${METRIC_EXPR.clicks} AS clicks
+      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 url, query
+      HAVING SUM(impressions) >= ?
+    ),
+    ranked AS (
+      SELECT
+        page, query, impressions, clicks,
+        ROW_NUMBER() OVER (PARTITION BY page ORDER BY impressions DESC, query ASC) AS rnk
+      FROM page_queries
+    ),
+    log_space AS (
+      SELECT *,
+        LN(rnk) AS log_rank,
+        LN(impressions) AS log_impr
+      FROM ranked
+    ),
+    fit AS (
+      SELECT
+        page,
+        COUNT(*) AS query_count,
+        SUM(impressions) AS total_impressions,
+        SUM(clicks) AS total_clicks,
+        REGR_SLOPE(log_impr, log_rank) AS slope,
+        REGR_INTERCEPT(log_impr, log_rank) AS intercept,
+        REGR_R2(log_impr, log_rank) AS r2,
+        MAX(impressions) AS head_impressions,
+        MAX(CASE WHEN rnk = 1 THEN impressions END) / NULLIF(SUM(impressions), 0) AS head_share
+      FROM log_space
+      GROUP BY page
+      HAVING COUNT(*) >= ${Number(minQueries)}
+    ),
+    scatter AS (
+      SELECT
+        l.page,
+        to_json(list({
+          'rank': l.rnk,
+          'impressions': l.impressions,
+          'clicks': l.clicks,
+          'query': l.query
+        } ORDER BY l.rnk)) AS pointsJson
+      FROM log_space l
+      JOIN fit f USING (page)
+      GROUP BY l.page
+    )
+    SELECT
+      f.page,
+      f.query_count AS queryCount,
+      f.total_impressions AS totalImpressions,
+      f.total_clicks AS totalClicks,
+      f.slope AS slope,
+      f.intercept AS intercept,
+      f.r2 AS r2,
+      f.head_impressions AS headImpressions,
+      f.head_share AS headShare,
+      s.pointsJson AS pointsJson,
+      CASE
+        WHEN f.slope > -0.6 THEN 'flat-tail'
+        WHEN f.slope > -1.2 THEN 'balanced'
+        ELSE 'head-heavy'
+      END AS fingerprint
+    FROM fit f
+    LEFT JOIN scatter s USING (page)
+    ORDER BY f.total_impressions DESC
+    LIMIT ${Number(limit)}
+  `,
+			params: [
+				startDate,
+				endDate,
+				minQueryImpressions
+			],
+			current: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows) {
+		const results = (Array.isArray(rows) ? rows : []).map((r) => ({
+			page: str$6(r.page),
+			queryCount: num(r.queryCount),
+			totalImpressions: num(r.totalImpressions),
+			totalClicks: num(r.totalClicks),
+			slope: num(r.slope),
+			intercept: num(r.intercept),
+			r2: num(r.r2),
+			headImpressions: num(r.headImpressions),
+			headShare: num(r.headShare),
+			fingerprint: str$6(r.fingerprint),
+			points: downsampleLogRank(parseJsonList$4(r.pointsJson))
+		}));
+		const counts = {
+			"flat-tail": 0,
+			"balanced": 0,
+			"head-heavy": 0
+		};
+		for (const r of results) counts[r.fingerprint]++;
+		return {
+			results,
+			meta: {
+				total: results.length,
+				fingerprints: counts,
+				avgSlope: results.length > 0 ? results.reduce((s, r) => s + r.slope, 0) / results.length : 0
+			}
+		};
+	}
+});
+function str$5(v) {
+	return v == null ? "" : String(v);
+}
+const positionDistributionAnalyzer = defineAnalyzer({
+	id: "position-distribution",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf(params);
+		return {
+			sql: `
+    WITH pos AS (
+      SELECT
+        date,
+        (sum_position / NULLIF(impressions, 0) + 1) AS avg_pos
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ? AND impressions > 0
+    )
+    SELECT
+      date,
+      CAST(SUM(CASE WHEN avg_pos <= 3 THEN 1 ELSE 0 END) AS DOUBLE) AS pos_1_3,
+      CAST(SUM(CASE WHEN avg_pos > 3 AND avg_pos <= 10 THEN 1 ELSE 0 END) AS DOUBLE) AS pos_4_10,
+      CAST(SUM(CASE WHEN avg_pos > 10 AND avg_pos <= 20 THEN 1 ELSE 0 END) AS DOUBLE) AS pos_11_20,
+      CAST(SUM(CASE WHEN avg_pos > 20 THEN 1 ELSE 0 END) AS DOUBLE) AS pos_20_plus,
+      CAST(COUNT(*) AS DOUBLE) AS total
+    FROM pos
+    GROUP BY date
+    ORDER BY date ASC
+  `,
+			params: [startDate, endDate],
+			current: {
+				table: "keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const { startDate, endDate } = periodOf(params);
+		return {
+			results: arr.map((r) => ({
+				date: str$5(r.date),
+				pos_1_3: num(r.pos_1_3),
+				pos_4_10: num(r.pos_4_10),
+				pos_11_20: num(r.pos_11_20),
+				pos_20_plus: num(r.pos_20_plus),
+				total: num(r.total)
+			})),
+			meta: {
+				total: arr.length,
+				startDate,
+				endDate
+			}
+		};
+	}
+});
+function str$4(v) {
+	return v == null ? "" : String(v);
+}
+const positionVolatilityAnalyzer = defineAnalyzer({
+	id: "position-volatility",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf(params);
+		const topN = params.topN ?? 30;
+		const minDayImpressions = params.minImpressions ?? 10;
+		const minDays = params.minWeeksWithData ?? 7;
+		return {
+			sql: `
+    WITH query_day AS (
+      SELECT
+        url AS page,
+        query,
+        date,
+        ${METRIC_EXPR.impressions} AS q_impressions,
+        ${METRIC_EXPR.position} AS q_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 url, query, date
+      HAVING SUM(impressions) >= 1
+    ),
+    daily AS (
+      SELECT
+        page, date,
+        COUNT(*) AS query_count,
+        SUM(q_impressions) AS day_impressions,
+        SUM(q_position * q_impressions) / NULLIF(SUM(q_impressions), 0) AS avg_position,
+        COALESCE(STDDEV_POP(q_position), 0.0) AS pos_stddev,
+        MIN(q_position) AS best_position,
+        MAX(q_position) AS worst_position
+      FROM query_day
+      GROUP BY page, date
+      HAVING SUM(q_impressions) >= ?
+    ),
+    with_shift AS (
+      SELECT *,
+        LAG(avg_position) OVER (PARTITION BY page ORDER BY date) AS prev_position,
+        COALESCE(
+          ABS(avg_position - LAG(avg_position) OVER (PARTITION BY page ORDER BY date)),
+          0.0
+        ) AS dod_shift
+      FROM daily
+    ),
+    scored AS (
+      SELECT *,
+        pos_stddev + dod_shift AS volatility
+      FROM with_shift
+    ),
+    top_pages AS (
+      SELECT page,
+        SUM(day_impressions) AS total_impressions,
+        AVG(volatility) AS avg_volatility,
+        MAX(volatility) AS peak_volatility,
+        COUNT(*) AS days_with_data
+      FROM scored
+      GROUP BY page
+      HAVING COUNT(*) >= ?
+      ORDER BY avg_volatility DESC
+      LIMIT ${Number(topN)}
+    )
+    SELECT
+      s.page,
+      strftime(s.date, '%Y-%m-%d') AS date,
+      s.query_count AS queryCount,
+      s.day_impressions AS dayImpressions,
+      s.avg_position AS avgPosition,
+      s.pos_stddev AS posStddev,
+      s.best_position AS bestPosition,
+      s.worst_position AS worstPosition,
+      s.dod_shift AS dodShift,
+      s.volatility AS volatility,
+      t.avg_volatility AS pageAvgVolatility,
+      t.peak_volatility AS pagePeakVolatility,
+      t.total_impressions AS pageTotalImpressions
+    FROM scored s
+    JOIN top_pages t USING (page)
+    ORDER BY t.avg_volatility DESC, s.date ASC
+  `,
+			params: [
+				startDate,
+				endDate,
+				minDayImpressions,
+				minDays
+			],
+			current: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const byPage = /* @__PURE__ */ new Map();
+		const allDates = /* @__PURE__ */ new Set();
+		for (const r of arr) {
+			const page = str$4(r.page);
+			const date = str$4(r.date);
+			allDates.add(date);
+			const entry = byPage.get(page) ?? {
+				page,
+				avgVolatility: num(r.pageAvgVolatility),
+				peakVolatility: num(r.pagePeakVolatility),
+				totalImpressions: num(r.pageTotalImpressions),
+				days: []
+			};
+			entry.days.push({
+				date,
+				queryCount: num(r.queryCount),
+				dayImpressions: num(r.dayImpressions),
+				avgPosition: num(r.avgPosition),
+				posStddev: num(r.posStddev),
+				bestPosition: num(r.bestPosition),
+				worstPosition: num(r.worstPosition),
+				dodShift: num(r.dodShift),
+				volatility: num(r.volatility)
+			});
+			byPage.set(page, entry);
+		}
+		const pages = [...byPage.values()].sort((a, b) => b.avgVolatility - a.avgVolatility);
+		const dates = [...allDates].sort();
+		const maxVolatility = pages.reduce((m, p) => Math.max(m, p.peakVolatility), 0);
+		return {
+			results: pages,
+			meta: {
+				total: pages.length,
+				dates,
+				maxVolatility
+			}
+		};
+	}
+});
+function str$3(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 [];
+}
+const queryMigrationAnalyzer = defineAnalyzer({
+	id: "query-migration",
+	buildSql(params) {
+		const cur = periodOf(params);
+		let prevStart = params.prevStartDate;
+		let prevEnd = params.prevEndDate;
+		if (prevStart == null || prevEnd == null) {
+			const curStartMs = new Date(cur.startDate).getTime();
+			const span = new Date(cur.endDate).getTime() - curStartMs;
+			prevEnd = toIsoDate(new Date(curStartMs - MS_PER_DAY));
+			prevStart = toIsoDate(new Date(curStartMs - MS_PER_DAY - span));
+		}
+		const minImpressions = params.minImpressions ?? 20;
+		const limit = params.limit ?? 200;
+		const maxLevenshtein = 2;
+		return {
+			sql: `
+    WITH cur AS (
+      SELECT query, url AS page,
+        ${METRIC_EXPR.impressions} AS impressions,
+        ${METRIC_EXPR.clicks} AS clicks,
+        ${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) >= ?
+    ),
+    prev AS (
+      SELECT query, url AS page,
+        ${METRIC_EXPR.impressions} AS impressions,
+        ${METRIC_EXPR.clicks} AS clicks,
+        ${METRIC_EXPR.position} AS position
+      FROM read_parquet({{FILES_PREV}}, 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) >= ?
+    ),
+    lost AS (
+      SELECT p.page AS source_page, p.query AS source_query, p.impressions AS source_impressions
+      FROM prev p
+      LEFT JOIN cur c ON p.page = c.page AND p.query = c.query
+      WHERE c.query IS NULL
+    ),
+    gained AS (
+      SELECT c.page AS target_page, c.query AS target_query, c.impressions AS target_impressions
+      FROM cur c
+      LEFT JOIN prev p ON p.page = c.page AND p.query = c.query
+      WHERE p.query IS NULL
+    ),
+    matched AS (
+      SELECT
+        l.source_page, l.source_query, l.source_impressions,
+        g.target_page, g.target_query, g.target_impressions,
+        CASE
+          WHEN l.source_query = g.target_query THEN 'exact'
+          ELSE 'fuzzy'
+        END AS match_type,
+        LEAST(l.source_impressions, g.target_impressions) AS absorbed_impressions
+      FROM lost l
+      JOIN gained g
+        ON l.source_page <> g.target_page
+        AND ABS(LENGTH(l.source_query) - LENGTH(g.target_query)) <= ${maxLevenshtein}
+        AND (
+          l.source_query = g.target_query
+          OR levenshtein(l.source_query, g.target_query) <= ${maxLevenshtein}
+        )
+    ),
+    edges AS (
+      SELECT
+        source_page, target_page,
+        SUM(absorbed_impressions) AS weight,
+        COUNT(*) AS query_count,
+        SUM(CASE WHEN match_type = 'exact' THEN 1 ELSE 0 END) AS exact_count,
+        to_json(list({
+          'sourceQuery': source_query,
+          'targetQuery': target_query,
+          'absorbed': absorbed_impressions,
+          'matchType': match_type
+        } ORDER BY absorbed_impressions DESC)) AS examplesJson
+      FROM matched
+      GROUP BY source_page, target_page
+    )
+    SELECT *
+    FROM edges
+    ORDER BY weight DESC
+    LIMIT ${Number(limit)}
+  `,
+			params: [
+				cur.startDate,
+				cur.endDate,
+				minImpressions,
+				prevStart,
+				prevEnd,
+				minImpressions
+			],
+			current: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(cur.startDate, cur.endDate)
+			},
+			previous: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(prevStart, prevEnd)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const cur = periodOf(params);
+		let prevStart = params.prevStartDate;
+		let prevEnd = params.prevEndDate;
+		if (prevStart == null || prevEnd == null) {
+			const curStartMs = new Date(cur.startDate).getTime();
+			const span = new Date(cur.endDate).getTime() - curStartMs;
+			prevEnd = toIsoDate(new Date(curStartMs - MS_PER_DAY));
+			prevStart = toIsoDate(new Date(curStartMs - MS_PER_DAY - span));
+		}
+		const edges = arr.map((r) => ({
+			sourcePage: str$3(r.source_page),
+			targetPage: str$3(r.target_page),
+			weight: num(r.weight),
+			queryCount: num(r.query_count),
+			exactCount: num(r.exact_count),
+			fuzzyCount: num(r.query_count) - num(r.exact_count),
+			examples: parseJsonList$3(r.examplesJson).slice(0, 8).map((e) => ({
+				sourceQuery: str$3(e.sourceQuery),
+				targetQuery: str$3(e.targetQuery),
+				absorbed: num(e.absorbed),
+				matchType: str$3(e.matchType)
+			}))
+		}));
+		const nodeAgg = /* @__PURE__ */ new Map();
+		for (const e of edges) {
+			const src = nodeAgg.get(e.sourcePage) ?? {
+				url: e.sourcePage,
+				outgoing: 0,
+				incoming: 0
+			};
+			src.outgoing += e.weight;
+			nodeAgg.set(e.sourcePage, src);
+			const tgt = nodeAgg.get(e.targetPage) ?? {
+				url: e.targetPage,
+				outgoing: 0,
+				incoming: 0
+			};
+			tgt.incoming += e.weight;
+			nodeAgg.set(e.targetPage, tgt);
+		}
+		const nodes = [...nodeAgg.values()];
+		const totalAbsorbed = edges.reduce((s, e) => s + e.weight, 0);
+		return {
+			results: edges,
+			meta: {
+				total: edges.length,
+				totalAbsorbed,
+				period: {
+					current: cur,
+					previous: {
+						startDate: prevStart,
+						endDate: prevEnd
+					}
+				},
+				nodes
+			}
+		};
+	}
+});
+function str$2(v) {
+	return v == null ? "" : String(v);
+}
+function bool(v) {
+	return v === true || v === 1 || v === "true";
+}
+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 [];
+}
+const stlDecomposeAnalyzer = defineAnalyzer({
+	id: "stl-decompose",
+	buildSql(params) {
+		const endDate = params.endDate ?? defaultEndDate();
+		const startDate = params.startDate ?? daysAgo(93);
+		const minImpressions = params.minImpressions ?? 100;
+		const minDays = 21;
+		const metric = params.metric === "clicks" ? "clicks" : "impressions";
+		const limit = params.limit ?? 100;
+		return {
+			sql: `
+    WITH daily AS (
+      SELECT
+        query,
+        url AS page,
+        date,
+        ${METRIC_EXPR.clicks} AS clicks,
+        ${METRIC_EXPR.impressions} AS impressions,
+        CAST(SUM(${metric}) AS DOUBLE) AS observed
+      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, date
+    ),
+    entity_stats AS (
+      SELECT query, page,
+        COUNT(*) AS days,
+        SUM(impressions) AS total_impressions
+      FROM daily
+      GROUP BY query, page
+      HAVING COUNT(*) >= ${Number(minDays)}
+        AND SUM(impressions) >= ?
+    ),
+    filtered AS (
+      SELECT d.*
+      FROM daily d
+      JOIN entity_stats e USING (query, page)
+    ),
+    trended AS (
+      SELECT *,
+        CASE
+          WHEN COUNT(*) OVER w = 7
+            THEN AVG(observed) OVER w
+          ELSE NULL
+        END AS trend
+      FROM filtered
+      WINDOW w AS (
+        PARTITION BY query, page
+        ORDER BY date
+        ROWS BETWEEN 3 PRECEDING AND 3 FOLLOWING
+      )
+    ),
+    detrended AS (
+      SELECT *,
+        observed - trend AS detrended,
+        dayofweek(date) AS dow
+      FROM trended
+    ),
+    seasonal_raw AS (
+      SELECT *,
+        AVG(detrended) OVER (PARTITION BY query, page, dow) AS seasonal_dow
+      FROM detrended
+    ),
+    seasonal_centered AS (
+      SELECT *,
+        seasonal_dow - AVG(seasonal_dow) OVER (PARTITION BY query, page) AS seasonal
+      FROM seasonal_raw
+    ),
+    residualed AS (
+      SELECT *,
+        CASE
+          WHEN trend IS NULL OR seasonal IS NULL THEN NULL
+          ELSE observed - trend - seasonal
+        END AS residual
+      FROM seasonal_centered
+    ),
+    scored AS (
+      SELECT *,
+        STDDEV_POP(residual) OVER (PARTITION BY query, page) AS resid_std,
+        CASE
+          WHEN residual IS NOT NULL
+            AND STDDEV_POP(residual) OVER (PARTITION BY query, page) > 0
+            AND ABS(residual) > 2.0 * STDDEV_POP(residual) OVER (PARTITION BY query, page)
+          THEN true ELSE false
+        END AS anomaly
+      FROM residualed
+    ),
+    per_entity AS (
+      SELECT query, page,
+        COUNT(*) AS days,
+        SUM(impressions) AS total_impressions,
+        VAR_POP(detrended) AS var_detrended,
+        VAR_POP(seasonal) AS var_seasonal,
+        VAR_POP(residual) AS var_residual,
+        COUNT(*) FILTER (WHERE anomaly) AS residual_anomalies,
+        REGR_SLOPE(observed, epoch(date) / 86400.0) AS trend_slope
+      FROM scored
+      GROUP BY query, page
+    ),
+    series AS (
+      SELECT query, page,
+        to_json(list({
+          'date': strftime(date, '%Y-%m-%d'),
+          'observed': observed,
+          'trend': trend,
+          'seasonal': seasonal,
+          'residual': residual,
+          'anomaly': anomaly
+        } ORDER BY date)) AS seriesJson
+      FROM scored
+      GROUP BY query, page
+    )
+    SELECT
+      e.query AS keyword,
+      e.page,
+      CAST(e.total_impressions AS DOUBLE) AS totalImpressions,
+      CAST(e.days AS DOUBLE) AS days,
+      CASE
+        WHEN e.var_detrended IS NULL OR e.var_detrended = 0 THEN 0.0
+        ELSE LEAST(e.var_seasonal / NULLIF(e.var_detrended, 0), 1.0)
+      END AS seasonalStrength,
+      CASE
+        WHEN e.var_detrended IS NULL OR e.var_detrended = 0 THEN 0.0
+        ELSE GREATEST(0.0, 1.0 - e.var_residual / NULLIF(e.var_detrended, 0))
+      END AS trendStrength,
+      CAST(e.residual_anomalies AS DOUBLE) AS residualAnomalies,
+      COALESCE(e.trend_slope, 0.0) AS trendSlope,
+      s.seriesJson
+    FROM per_entity e
+    LEFT JOIN series s USING (query, page)
+    ORDER BY seasonalStrength DESC, ABS(COALESCE(e.trend_slope, 0.0)) DESC
+    LIMIT ${Number(limit)}
+  `,
+			params: [
+				startDate,
+				endDate,
+				minImpressions
+			],
+			current: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const metric = params.metric === "clicks" ? "clicks" : "impressions";
+		const results = arr.map((r) => ({
+			keyword: str$2(r.keyword),
+			page: str$2(r.page),
+			totalImpressions: num(r.totalImpressions),
+			days: num(r.days),
+			seasonalStrength: num(r.seasonalStrength),
+			trendStrength: num(r.trendStrength),
+			residualAnomalies: num(r.residualAnomalies),
+			trendSlope: num(r.trendSlope),
+			series: parseJsonList$2(r.seriesJson).map((s) => ({
+				date: str$2(s.date),
+				observed: num(s.observed),
+				trend: s.trend == null ? null : num(s.trend),
+				seasonal: s.seasonal == null ? null : num(s.seasonal),
+				residual: s.residual == null ? null : num(s.residual),
+				anomaly: bool(s.anomaly)
+			}))
+		}));
+		return {
+			results,
+			meta: {
+				total: results.length,
+				metric,
+				avgSeasonalStrength: results.length > 0 ? results.reduce((a, r) => a + r.seasonalStrength, 0) / results.length : 0
+			}
+		};
+	}
+});
+function str$1(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 [];
+}
+const survivalAnalyzer = defineAnalyzer({
+	id: "survival",
+	buildSql(params) {
+		const endDate = params.endDate ?? defaultEndDate();
+		const startDate = params.startDate ?? daysAgo(183);
+		const minImpressions = params.minImpressions ?? 5;
+		return {
+			sql: `
+    WITH daily AS (
+      SELECT
+        query,
+        url,
+        date,
+        ${METRIC_EXPR.clicks} AS day_clicks,
+        ${METRIC_EXPR.impressions} AS day_impressions,
+        ${METRIC_EXPR.position} AS day_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, date
+      HAVING SUM(impressions) >= ?
+    ),
+    classified AS (
+      SELECT *,
+        (day_position <= 10) AS in_top10
+      FROM daily
+    ),
+    transitions AS (
+      SELECT *,
+        CASE
+          WHEN in_top10 AND (LAG(in_top10) OVER w IS NULL OR NOT LAG(in_top10) OVER w)
+            THEN 1 ELSE 0
+        END AS is_entry
+      FROM classified
+      WINDOW w AS (PARTITION BY query, url ORDER BY date)
+    ),
+    run_ids AS (
+      SELECT *,
+        SUM(is_entry) OVER (PARTITION BY query, url ORDER BY date) AS run_id
+      FROM transitions
+      WHERE in_top10
+    ),
+    window_bounds AS (
+      SELECT MIN(date) AS window_start, MAX(date) AS window_end FROM daily
+    ),
+    episodes_raw AS (
+      SELECT
+        query, url, run_id,
+        MIN(date) AS entry_date,
+        MAX(date) AS exit_date,
+        DATEDIFF('day', MIN(date), MAX(date)) + 1 AS tenure
+      FROM run_ids
+      GROUP BY query, url, run_id
+    ),
+    episodes AS (
+      SELECT
+        e.query, e.url, e.run_id, e.entry_date, e.exit_date, e.tenure,
+        (e.exit_date >= wb.window_end - INTERVAL 2 DAY) AS censored,
+        CASE
+          WHEN regexp_extract(e.url, '^(?:https?://[^/]+)?(/[^/?#]*)', 1) = '/' OR e.url = '/'
+            THEN 'home'
+          WHEN regexp_extract(e.url, '^(?:https?://[^/]+)?/([^/?#]+)', 1) = ''
+            THEN 'home'
+          ELSE regexp_extract(e.url, '^(?:https?://[^/]+)?/([^/?#]+)', 1)
+        END AS cohort
+      FROM episodes_raw e
+      CROSS JOIN window_bounds wb
+    ),
+    episodes_all AS (
+      SELECT query, url, tenure, censored, cohort FROM episodes
+      UNION ALL
+      SELECT query, url, tenure, censored, '__all__' AS cohort FROM episodes
+    ),
+    cohort_totals AS (
+      SELECT cohort, COUNT(*) AS n_total
+      FROM episodes_all
+      GROUP BY cohort
+    ),
+    events AS (
+      SELECT
+        cohort,
+        tenure,
+        COUNT(*) FILTER (WHERE NOT censored) AS d_t,
+        COUNT(*) AS n_ending_at_t
+      FROM episodes_all
+      GROUP BY cohort, tenure
+    ),
+    km AS (
+      SELECT
+        e.cohort,
+        e.tenure,
+        e.d_t,
+        e.n_ending_at_t,
+        SUM(e.n_ending_at_t) OVER (PARTITION BY e.cohort ORDER BY e.tenure DESC
+          ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS at_risk
+      FROM events e
+    ),
+    km_surv AS (
+      SELECT
+        cohort, tenure, d_t, at_risk,
+        EXP(SUM(LN(GREATEST(1.0 - CAST(d_t AS DOUBLE) / NULLIF(at_risk, 0), 1e-9)))
+          OVER (PARTITION BY cohort ORDER BY tenure
+            ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)) AS survival
+      FROM km
+    ),
+    curve_agg AS (
+      SELECT
+        cohort,
+        to_json(list({
+          'tenure': tenure,
+          'survival': survival,
+          'atRisk': at_risk,
+          'events': d_t
+        } ORDER BY tenure)) AS curveJson
+      FROM km_surv
+      GROUP BY cohort
+    ),
+    cohort_stats AS (
+      SELECT
+        ea.cohort,
+        COUNT(*) AS episode_count,
+        AVG(CASE WHEN ea.censored THEN 1.0 ELSE 0.0 END) AS censoring_rate
+      FROM episodes_all ea
+      GROUP BY ea.cohort
+    )
+    SELECT
+      cs.cohort,
+      cs.episode_count AS episodeCount,
+      cs.censoring_rate AS censoringRate,
+      ca.curveJson
+    FROM cohort_stats cs
+    LEFT JOIN curve_agg ca USING (cohort)
+    ORDER BY cs.cohort
+  `,
+			params: [
+				startDate,
+				endDate,
+				minImpressions
+			],
+			current: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const endDate = params.endDate ?? defaultEndDate();
+		const startDate = params.startDate ?? daysAgo(183);
+		const windowDays = Math.round((new Date(endDate).getTime() - new Date(startDate).getTime()) / MS_PER_DAY) + 1;
+		const results = arr.map((r) => {
+			const curve = parseJsonList$1(r.curveJson).map((p) => ({
+				tenure: num(p.tenure),
+				survival: num(p.survival),
+				atRisk: num(p.atRisk),
+				events: num(p.events)
+			}));
+			let medianTenure = 0;
+			for (let i = 0; i < curve.length; i++) {
+				const cur = curve[i];
+				if (cur.survival <= .5) {
+					if (i === 0) medianTenure = cur.tenure;
+					else {
+						const prev = curve[i - 1];
+						const span = prev.survival - cur.survival;
+						const frac = span > 0 ? (prev.survival - .5) / span : 0;
+						medianTenure = prev.tenure + frac * (cur.tenure - prev.tenure);
+					}
+					break;
+				}
+			}
+			const last = curve[curve.length - 1];
+			if (medianTenure === 0 && last && last.survival > .5) medianTenure = last.tenure;
+			return {
+				cohort: str$1(r.cohort),
+				episodeCount: num(r.episodeCount),
+				censoringRate: num(r.censoringRate),
+				medianTenure,
+				curve
+			};
+		});
+		return {
+			results,
+			meta: {
+				totalEpisodes: results.find((r) => r.cohort === "__all__")?.episodeCount ?? 0,
+				cohortCount: results.filter((r) => r.cohort !== "__all__").length,
+				windowDays
+			}
+		};
+	}
+});
+function str(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 [];
+}
+const trendsAnalyzer = defineAnalyzer({
+	id: "trends",
+	buildSql(params) {
+		const weeks = params.weeks ?? 28;
+		const endDate = params.endDate || defaultEndDate();
+		const startDate = params.startDate || toIsoDate(/* @__PURE__ */ new Date(Date.parse(endDate) - (weeks * 7 - 1) * MS_PER_DAY));
+		const minImpressions = params.minImpressions ?? 100;
+		const minWeeksWithData = params.minWeeksWithData ?? Math.max(2, Math.floor(weeks / 4));
+		const limit = params.limit ?? 500;
+		const dim = params.dimension === "keywords" ? "keywords" : "pages";
+		const table = dim === "keywords" ? "keywords" : "pages";
+		return {
+			sql: `
+    WITH bucketed AS (
+      SELECT
+        ${dim === "keywords" ? "query" : "url"} AS entity,
+        date_trunc('week', CAST(date AS DATE)) AS week,
+        ${METRIC_EXPR.clicks} AS clicks,
+        ${METRIC_EXPR.impressions} AS impressions,
+        SUM(sum_position) AS sum_position_sum
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ?
+      GROUP BY entity, week
+    ),
+    with_meta AS (
+      SELECT
+        entity, week, clicks, impressions, sum_position_sum,
+        ROW_NUMBER() OVER (PARTITION BY entity ORDER BY week) - 1 AS week_idx,
+        COUNT(*) OVER (PARTITION BY entity) AS n_weeks,
+        (ROW_NUMBER() OVER (PARTITION BY entity ORDER BY week) - 1)
+          < (COUNT(*) OVER (PARTITION BY entity) / 2) AS is_first_half
+      FROM bucketed
+    ),
+    agg AS (
+      SELECT
+        entity,
+        SUM(clicks) AS totalClicks,
+        SUM(impressions) AS totalImpressions,
+        any_value(n_weeks) AS weeksWithData,
+        COALESCE(regr_slope(clicks, CAST(week_idx AS DOUBLE)), 0.0) AS slope,
+        SUM(CASE WHEN is_first_half THEN clicks ELSE 0 END) AS firstHalfClicks,
+        SUM(CASE WHEN NOT is_first_half THEN clicks ELSE 0 END) AS secondHalfClicks,
+        SUM(sum_position_sum) / NULLIF(SUM(impressions), 0) + 1 AS avgPosition,
+        to_json(list({
+          'week': strftime(week, '%Y-%m-%d'),
+          'clicks': clicks,
+          'impressions': impressions
+        } ORDER BY week)) AS seriesJson
+      FROM with_meta
+      GROUP BY entity
+      HAVING SUM(impressions) >= ? AND any_value(n_weeks) >= ?
+    ),
+    classified AS (
+      SELECT
+        *,
+        CASE
+          WHEN firstHalfClicks = 0 AND secondHalfClicks > 0 THEN 10.0
+          WHEN firstHalfClicks = 0 THEN 1.0
+          ELSE secondHalfClicks / firstHalfClicks
+        END AS growthRatio
+      FROM agg
+    )
+    SELECT
+      entity,
+      totalClicks,
+      totalImpressions,
+      weeksWithData,
+      slope,
+      growthRatio,
+      avgPosition,
+      CASE
+        WHEN growthRatio >= 1.5 AND slope > 0 THEN 'accelerating'
+        WHEN growthRatio >= 1.1 AND slope >= 0 THEN 'growing'
+        WHEN growthRatio < 0.5 THEN 'cratering'
+        WHEN growthRatio < 0.9 AND slope < 0 THEN 'declining'
+        ELSE 'steady'
+      END AS trend,
+      seriesJson
+    FROM classified
+    ORDER BY
+      CASE
+        WHEN growthRatio >= 1.5 AND slope > 0 THEN 0
+        WHEN growthRatio < 0.5 THEN 1
+        WHEN growthRatio >= 1.1 AND slope >= 0 THEN 2
+        WHEN growthRatio < 0.9 AND slope < 0 THEN 3
+        ELSE 4
+      END,
+      ABS(growthRatio - 1) DESC,
+      totalClicks DESC
+    LIMIT ${Number(limit)}
+  `,
+			params: [
+				startDate,
+				endDate,
+				minImpressions,
+				minWeeksWithData
+			],
+			current: {
+				table,
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const weeks = params.weeks ?? 28;
+		const endDate = params.endDate || defaultEndDate();
+		const startDate = params.startDate || toIsoDate(/* @__PURE__ */ new Date(Date.parse(endDate) - (weeks * 7 - 1) * MS_PER_DAY));
+		const dim = params.dimension === "keywords" ? "keywords" : "pages";
+		const results = arr.map((r) => {
+			const series = parseJsonList(r.seriesJson).map((s) => ({
+				week: str(s.week),
+				clicks: num(s.clicks),
+				impressions: num(s.impressions)
+			}));
+			return {
+				[dim === "keywords" ? "query" : "page"]: str(r.entity),
+				totalClicks: num(r.totalClicks),
+				totalImpressions: num(r.totalImpressions),
+				weeksWithData: num(r.weeksWithData),
+				slope: num(r.slope),
+				growthRatio: num(r.growthRatio),
+				avgPosition: num(r.avgPosition),
+				trend: str(r.trend),
+				series
+			};
+		});
+		const counts = {
+			accelerating: 0,
+			growing: 0,
+			steady: 0,
+			declining: 0,
+			cratering: 0
+		};
+		for (const r of results) counts[r.trend] = (counts[r.trend] ?? 0) + 1;
+		return {
+			results,
+			meta: {
+				total: results.length,
+				dimension: dim,
+				weeks: Number(weeks),
+				startDate,
+				endDate,
+				counts
+			}
+		};
+	}
+});
 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
+	rows: ROW_ANALYZERS,
+	sql: [
+		bayesianCtrAnalyzer.sql,
+		bipartitePagerankAnalyzer.sql,
+		brandAnalyzer.sql,
+		cannibalizationAnalyzer.sql,
+		changePointAnalyzer.sql,
+		clusteringAnalyzer.sql,
+		concentrationAnalyzer.sql,
+		contentVelocityAnalyzer.sql,
+		ctrAnomalyAnalyzer.sql,
+		ctrCurveAnalyzer.sql,
+		darkTrafficAnalyzer.sql,
+		dataDetailAnalyzer.sql,
+		dataQueryAnalyzer.sql,
+		decayAnalyzer.sql,
+		deviceGapAnalyzer.sql,
+		intentAtlasAnalyzer.sql,
+		keywordBreadthAnalyzer.sql,
+		longTailAnalyzer.sql,
+		moversAnalyzer.sql,
+		opportunityAnalyzer.sql,
+		positionDistributionAnalyzer.sql,
+		positionVolatilityAnalyzer.sql,
+		queryMigrationAnalyzer.sql,
+		seasonalityAnalyzer.sql,
+		stlDecomposeAnalyzer.sql,
+		strikingDistanceAnalyzer.sql,
+		survivalAnalyzer.sql,
+		trendsAnalyzer.sql,
+		zeroClickAnalyzer.sql
+	]
 });
 export { defaultAnalyzerRegistry };