@gscdump/analysis 0.4.0

package/dist/analyzer/index.mjs

@@ -0,0 +1,4944 @@
+import { enumeratePartitions } from "@gscdump/engine/planner";
+import { METRIC_EXPR } from "@gscdump/engine/sql-fragments";
+import { MS_PER_DAY, daysAgo, toIsoDate } from "gscdump";
+import { between, date, extractDateRange, gsc, page, query } from "gscdump/query";
+import { buildExtrasQueries, buildTotalsSql, mergeExtras, pgResolverAdapter, resolveComparisonSQL, resolveToSQL, resolveToSQLOptimized } from "@gscdump/engine/resolver";
+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
+		}
+	};
+}
+const DEFAULT_FILL = {
+	clicks: 0,
+	impressions: 0,
+	ctr: 0,
+	position: 0
+};
+function padTimeseries(rows, options) {
+	const { startDate, endDate } = options;
+	const dateKey = options.dateKey ?? "date";
+	const fill = options.fill ?? DEFAULT_FILL;
+	const byDate = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const d = String(row[dateKey]);
+		const bucket = byDate.get(d);
+		if (bucket) bucket.push(row);
+		else byDate.set(d, [row]);
+	}
+	const result = [];
+	const start = /* @__PURE__ */ new Date(`${startDate}T00:00:00Z`);
+	const end = /* @__PURE__ */ new Date(`${endDate}T00:00:00Z`);
+	if (Number.isNaN(start.getTime()) || Number.isNaN(end.getTime())) throw new Error(`padTimeseries: invalid date range ${startDate}..${endDate}`);
+	for (let cursorMs = start.getTime(), endMs = end.getTime(); cursorMs <= endMs; cursorMs += MS_PER_DAY) {
+		const dateStr = toIsoDate(new Date(cursorMs));
+		const existing = byDate.get(dateStr);
+		if (existing) result.push(...existing);
+		else result.push({
+			...fill,
+			[dateKey]: dateStr
+		});
+	}
+	return result;
+}
+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$23(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$23(r.keyword),
+			page: str$23(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$23(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
+			}
+		};
+	}
+});
+function num$4(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);
+	};
+}
+const BIPARTITE_PAGERANK_ITERATIONS = 25;
+const BIPARTITE_PAGERANK_DAMPING = .85;
+function str$22(v) {
+	return v == null ? "" : String(v);
+}
+function parseJsonList$16(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$22(r.kind),
+			id: str$22(r.id),
+			rank: num$4(r.rank),
+			bridging: num$4(r.bridging),
+			anchoring: num$4(r.anchoring),
+			degree: num$4(r.degree),
+			impressions: num$4(r.impressions)
+		}));
+		const first = arr[0] ?? {};
+		const queryCount = num$4(first.queryCount);
+		const urlCount = num$4(first.urlCount);
+		const deltas = parseJsonList$16(first.deltasJson).map((e) => ({
+			step: num$4(e.step),
+			l1: num$4(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
+			}
+		};
+	}
+});
+const DEFAULT_LIMIT$1 = 25e3;
+function keywordsQueryState(period, limit = DEFAULT_LIMIT$1) {
+	return gsc.select(query, page).where(between(date, period.startDate, period.endDate)).limit(limit).getState();
+}
+function pagesQueryState(period, limit = DEFAULT_LIMIT$1) {
+	return gsc.select(page).where(between(date, period.startDate, period.endDate)).limit(limit).getState();
+}
+function datesQueryState(period, limit = DEFAULT_LIMIT$1) {
+	return gsc.select(date).where(between(date, period.startDate, period.endDate)).limit(limit).getState();
+}
+function escapeRegexAlt(s) {
+	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function str$21(v) {
+	return v == null ? "" : String(v);
+}
+function analyzeBrandSegmentation(keywords, options) {
+	const { brandTerms, minImpressions = 10 } = options;
+	const lowerBrandTerms = brandTerms.map((t) => t.toLowerCase());
+	const brand = [];
+	const nonBrand = [];
+	for (const row of keywords) {
+		if (num$4(row.impressions) < minImpressions) continue;
+		if (lowerBrandTerms.some((term) => row.query.toLowerCase().includes(term))) brand.push(row);
+		else nonBrand.push(row);
+	}
+	const brandClicks = brand.reduce((sum, k) => sum + num$4(k.clicks), 0);
+	const nonBrandClicks = nonBrand.reduce((sum, k) => sum + num$4(k.clicks), 0);
+	const totalClicks = brandClicks + nonBrandClicks;
+	return {
+		brand,
+		nonBrand,
+		summary: {
+			brandClicks,
+			nonBrandClicks,
+			brandShare: totalClicks > 0 ? brandClicks / totalClicks : 0,
+			brandImpressions: brand.reduce((sum, k) => sum + num$4(k.impressions), 0),
+			nonBrandImpressions: nonBrand.reduce((sum, k) => sum + num$4(k.impressions), 0)
+		}
+	};
+}
+const brandAnalyzer = defineAnalyzer({
+	id: "brand",
+	buildSql(params) {
+		if (!params.brandTerms?.length) throw new Error("Brand analysis requires brandTerms");
+		const { startDate, endDate } = periodOf(params);
+		const minImpressions = params.minImpressions ?? 10;
+		const limit = params.limit ?? 1e4;
+		const regex = `(${params.brandTerms.map((t) => escapeRegexAlt(t.toLowerCase())).join("|")})`;
+		return {
+			sql: `
+    WITH agg AS (
+      SELECT
+        query,
+        url AS page,
+        ${METRIC_EXPR.clicks} AS clicks,
+        ${METRIC_EXPR.impressions} AS impressions,
+        ${METRIC_EXPR.ctr} AS ctr,
+        ${METRIC_EXPR.position} AS position
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ?
+      GROUP BY query, url
+      HAVING SUM(impressions) >= ?
+    )
+    SELECT
+      query, page, clicks, impressions, ctr, position,
+      CASE WHEN regexp_matches(LOWER(query), ?) THEN 'brand' ELSE 'non-brand' END AS segment
+    FROM agg
+    ORDER BY clicks DESC
+    LIMIT ${Number(limit)}
+  `,
+			params: [
+				startDate,
+				endDate,
+				minImpressions,
+				regex
+			],
+			current: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows) {
+		const normalized = (Array.isArray(rows) ? rows : []).map((r) => ({
+			query: str$21(r.query),
+			page: r.page == null ? void 0 : str$21(r.page),
+			clicks: num$4(r.clicks),
+			impressions: num$4(r.impressions),
+			ctr: num$4(r.ctr),
+			position: num$4(r.position),
+			segment: str$21(r.segment)
+		}));
+		let brandClicks = 0;
+		let nonBrandClicks = 0;
+		let brandImpressions = 0;
+		let nonBrandImpressions = 0;
+		for (const r of normalized) if (r.segment === "brand") {
+			brandClicks += r.clicks;
+			brandImpressions += r.impressions;
+		} else {
+			nonBrandClicks += r.clicks;
+			nonBrandImpressions += r.impressions;
+		}
+		const totalClicks = brandClicks + nonBrandClicks;
+		return {
+			results: normalized,
+			meta: {
+				total: normalized.length,
+				summary: {
+					brandClicks,
+					nonBrandClicks,
+					brandShare: totalClicks > 0 ? brandClicks / totalClicks : 0,
+					brandImpressions,
+					nonBrandImpressions
+				}
+			}
+		};
+	},
+	buildRows(params) {
+		return { keywords: keywordsQueryState(periodOf(params), params.limit) };
+	},
+	reduceRows(rows, params) {
+		if (!params.brandTerms?.length) throw new Error("Brand analysis requires brandTerms");
+		const result = analyzeBrandSegmentation(Array.isArray(rows) ? rows : [], {
+			brandTerms: params.brandTerms,
+			minImpressions: params.minImpressions
+		});
+		return {
+			results: [...result.brand.map((r) => ({
+				...r,
+				segment: "brand"
+			})), ...result.nonBrand.map((r) => ({
+				...r,
+				segment: "non-brand"
+			}))],
+			meta: { summary: result.summary }
+		};
+	}
+});
+const sortRowResults$1 = createSorter((item, metric) => {
+	switch (metric) {
+		case "clicks": return item.totalClicks;
+		case "impressions": return item.totalImpressions;
+		case "positionSpread": return item.positionSpread;
+		case "pageCount": return item.pages.length;
+	}
+}, "clicks");
+function str$20(v) {
+	return v == null ? "" : String(v);
+}
+function parseJsonList$15(v) {
+	if (Array.isArray(v)) return v;
+	if (typeof v === "string" && v.length > 0) {
+		const parsed = JSON.parse(v);
+		return Array.isArray(parsed) ? parsed : [];
+	}
+	return [];
+}
+function analyzeCannibalization(rows, options = {}) {
+	const { minImpressions = 10, maxPositionSpread = 10, minPages = 2, sortBy = "clicks", sortOrder = "desc" } = options;
+	const queryMap = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		if (row.impressions < minImpressions) continue;
+		const pages = queryMap.get(row.query) || [];
+		pages.push({
+			page: row.page,
+			clicks: row.clicks,
+			impressions: row.impressions,
+			ctr: row.ctr,
+			position: row.position
+		});
+		queryMap.set(row.query, pages);
+	}
+	const results = [];
+	for (const [query, pages] of queryMap) {
+		if (pages.length < minPages) continue;
+		pages.sort((a, b) => b.clicks - a.clicks);
+		const positions = pages.map((p) => p.position);
+		const positionSpread = Math.max(...positions) - Math.min(...positions);
+		if (positionSpread > maxPositionSpread) continue;
+		results.push({
+			query,
+			pages,
+			totalClicks: pages.reduce((sum, p) => sum + p.clicks, 0),
+			totalImpressions: pages.reduce((sum, p) => sum + p.impressions, 0),
+			positionSpread
+		});
+	}
+	return sortRowResults$1(results, sortBy, sortOrder);
+}
+const cannibalizationAnalyzer = defineAnalyzer({
+	id: "cannibalization",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf(params);
+		const minImpressions = params.minImpressions ?? 50;
+		const minCompetitors = 2;
+		const minQueryImpressions = (params.minImpressions ?? 50) * 2;
+		const limit = params.limit ?? 200;
+		return {
+			sql: `
+      WITH agg AS (
+        SELECT
+          query,
+          url,
+          ${METRIC_EXPR.clicks} AS clicks,
+          ${METRIC_EXPR.impressions} AS impressions,
+          ${METRIC_EXPR.ctr} AS ctr,
+          ${METRIC_EXPR.position} AS position
+        FROM read_parquet({{FILES}}, union_by_name = true)
+        WHERE date >= ? AND date <= ?
+          AND query IS NOT NULL AND query <> ''
+          AND url IS NOT NULL AND url <> ''
+        GROUP BY query, url
+        HAVING SUM(impressions) >= ?
+      ),
+      query_totals AS (
+        SELECT
+          query,
+          SUM(impressions) AS total_impressions,
+          SUM(clicks) AS total_clicks,
+          COUNT(*) AS competitor_count
+        FROM agg
+        GROUP BY query
+        HAVING COUNT(*) >= ? AND SUM(impressions) >= ?
+      ),
+      ranked AS (
+        SELECT
+          a.query,
+          a.url,
+          a.clicks,
+          a.impressions,
+          a.ctr,
+          a.position,
+          a.impressions / NULLIF(t.total_impressions, 0) AS share,
+          ROW_NUMBER() OVER (
+            PARTITION BY a.query
+            ORDER BY a.impressions DESC, a.clicks DESC, a.url ASC
+          ) AS rnk
+        FROM agg a
+        JOIN query_totals t USING (query)
+      ),
+      leader AS (
+        SELECT query, url AS leader_url, ctr AS leader_ctr, position AS leader_position
+        FROM ranked WHERE rnk = 1
+      ),
+      events AS (
+        SELECT
+          r.query,
+          any_value(l.leader_url) AS leader_url,
+          any_value(l.leader_ctr) AS leader_ctr,
+          any_value(l.leader_position) AS leader_position,
+          SUM(POWER(r.share * 100.0, 2)) AS hhi,
+          SUM(CASE
+            WHEN r.rnk > 1 AND l.leader_ctr > r.ctr
+              THEN (l.leader_ctr - r.ctr) * r.impressions
+            ELSE 0.0
+          END) AS stolen_clicks,
+          to_json(list({
+            'url': r.url,
+            'clicks': r.clicks,
+            'impressions': r.impressions,
+            'ctr': r.ctr,
+            'position': r.position,
+            'share': r.share,
+            'rank': r.rnk
+          } ORDER BY r.rnk)) AS competitors
+        FROM ranked r
+        JOIN leader l USING (query)
+        GROUP BY r.query
+      )
+      SELECT
+        e.query AS keyword,
+        t.total_impressions AS totalImpressions,
+        t.total_clicks AS totalClicks,
+        t.competitor_count AS competitorCount,
+        e.leader_url AS leaderUrl,
+        e.leader_ctr AS leaderCtr,
+        e.leader_position AS leaderPosition,
+        e.hhi AS hhi,
+        GREATEST(0.0, 1.0 - e.hhi / 10000.0) AS fragmentation,
+        e.stolen_clicks AS stolenClicks,
+        e.competitors AS competitors,
+        CAST(ROUND(LEAST(100.0,
+          100.0 * POWER(
+            GREATEST(1.0 - e.hhi / 10000.0, 0.0)
+              * LEAST(e.stolen_clicks / GREATEST(t.total_clicks + e.stolen_clicks, 1.0), 1.0)
+              * LEAST(LOG10(GREATEST(t.total_impressions, 10.0)) / 5.0, 1.0),
+            1.0 / 3.0
+          )
+        )) AS DOUBLE) AS severity
+      FROM events e
+      JOIN query_totals t USING (query)
+      ORDER BY severity DESC, stolenClicks DESC
+      LIMIT ${Number(limit)}
+    `,
+			params: [
+				startDate,
+				endDate,
+				minImpressions,
+				minCompetitors,
+				minQueryImpressions
+			],
+			current: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows) {
+		const events = (Array.isArray(rows) ? rows : []).map((r) => ({
+			keyword: str$20(r.keyword),
+			totalImpressions: num$4(r.totalImpressions),
+			totalClicks: num$4(r.totalClicks),
+			competitorCount: num$4(r.competitorCount),
+			leaderUrl: str$20(r.leaderUrl),
+			leaderCtr: num$4(r.leaderCtr),
+			leaderPosition: num$4(r.leaderPosition),
+			hhi: num$4(r.hhi),
+			fragmentation: num$4(r.fragmentation),
+			stolenClicks: num$4(r.stolenClicks),
+			severity: num$4(r.severity),
+			competitors: parseJsonList$15(r.competitors).map((c) => ({
+				url: str$20(c.url),
+				clicks: num$4(c.clicks),
+				impressions: num$4(c.impressions),
+				ctr: num$4(c.ctr),
+				position: num$4(c.position),
+				share: num$4(c.share),
+				rank: num$4(c.rank)
+			}))
+		}));
+		const nodeAgg = /* @__PURE__ */ new Map();
+		const edgeAgg = /* @__PURE__ */ new Map();
+		for (const ev of events) {
+			for (const c of ev.competitors) {
+				const n = nodeAgg.get(c.url) ?? {
+					impressions: 0,
+					clicks: 0,
+					queries: /* @__PURE__ */ new Set()
+				};
+				n.impressions += c.impressions;
+				n.clicks += c.clicks;
+				n.queries.add(ev.keyword);
+				nodeAgg.set(c.url, n);
+			}
+			for (let i = 0; i < ev.competitors.length; i++) for (let j = i + 1; j < ev.competitors.length; j++) {
+				const a = ev.competitors[i];
+				const b = ev.competitors[j];
+				const [src, tgt] = a.url < b.url ? [a.url, b.url] : [b.url, a.url];
+				const key = `${src}
${tgt}`;
+				const weight = Math.min(a.impressions, b.impressions);
+				const edge = edgeAgg.get(key) ?? {
+					source: src,
+					target: tgt,
+					weight: 0,
+					queries: 0
+				};
+				edge.weight += weight;
+				edge.queries += 1;
+				edgeAgg.set(key, edge);
+			}
+		}
+		const nodes = [...nodeAgg.entries()].map(([url, n]) => ({
+			url,
+			impressions: n.impressions,
+			clicks: n.clicks,
+			queryCount: n.queries.size
+		}));
+		const edges = [...edgeAgg.values()];
+		const avgFragmentation = events.length > 0 ? events.reduce((s, e) => s + e.fragmentation, 0) / events.length : 0;
+		const totalStolenClicks = events.reduce((s, e) => s + e.stolenClicks, 0);
+		return {
+			results: events,
+			meta: {
+				total: events.length,
+				totalStolenClicks,
+				avgFragmentation,
+				graph: {
+					nodes,
+					edges
+				}
+			}
+		};
+	},
+	buildRows(params) {
+		return { rows: keywordsQueryState(periodOf(params), params.limit) };
+	},
+	reduceRows(rows, params) {
+		const results = analyzeCannibalization(Array.isArray(rows) ? rows : [], {
+			minImpressions: params.minImpressions,
+			maxPositionSpread: params.maxPositionSpread,
+			minPages: params.minPages
+		});
+		return {
+			results,
+			meta: { total: results.length }
+		};
+	}
+});
+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$19(v) {
+	return v == null ? "" : String(v);
+}
+function parseJsonList$14(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$3(r.delta);
+			const improved = lowerIsBetter ? delta < 0 : delta > 0;
+			return {
+				keyword: str$19(r.keyword),
+				page: str$19(r.page),
+				totalDays: num$3(r.totalDays),
+				totalImpressions: num$3(r.totalImpressions),
+				changeDate: str$19(r.changeDate),
+				llr: num$3(r.llr),
+				leftMean: num$3(r.leftMean),
+				rightMean: num$3(r.rightMean),
+				delta,
+				leftStddev: num$3(r.leftStddev),
+				rightStddev: num$3(r.rightStddev),
+				direction: improved ? "improved" : "worsened",
+				series: parseJsonList$14(r.seriesJson).map((s) => ({
+					date: str$19(s.date),
+					value: num$3(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
+			}
+		};
+	}
+});
+const INTENT_PREFIXES_REGEX = "^(how to|what is|what are|why is|why do|where to|when to|best|top|vs|versus|compare|review|buy|cheap|free|near me)(\\s|$)";
+const INTENT_PREFIXES = [
+	"how to",
+	"what is",
+	"what are",
+	"why is",
+	"why do",
+	"where to",
+	"when to",
+	"best",
+	"top",
+	"vs",
+	"versus",
+	"compare",
+	"review",
+	"buy",
+	"cheap",
+	"free",
+	"near me"
+];
+const WHITESPACE_RE = /\s+/;
+function str$18(v) {
+	return v == null ? "" : String(v);
+}
+function parseJsonList$13(v) {
+	if (Array.isArray(v)) return v;
+	if (typeof v === "string" && v.length > 0) {
+		const parsed = JSON.parse(v);
+		return Array.isArray(parsed) ? parsed : [];
+	}
+	return [];
+}
+function extractIntentPrefix(keyword) {
+	const lower = keyword.toLowerCase();
+	for (const prefix of INTENT_PREFIXES) if (lower.startsWith(`${prefix} `) || lower.startsWith(prefix)) return prefix;
+	return null;
+}
+function extractWordPrefix(keyword, wordCount = 2) {
+	const words = keyword.toLowerCase().split(WHITESPACE_RE).filter(Boolean);
+	if (words.length < wordCount + 1) return null;
+	return words.slice(0, wordCount).join(" ");
+}
+function analyzeClustering(keywords, options = {}) {
+	const { minClusterSize = 2, minImpressions = 10, clusterBy = "both" } = options;
+	const filtered = keywords.filter((k) => num$4(k.impressions) >= minImpressions);
+	const clusterMap = /* @__PURE__ */ new Map();
+	const clusteredKeywords = /* @__PURE__ */ new Set();
+	if (clusterBy === "intent" || clusterBy === "both") for (const kw of filtered) {
+		const intent = extractIntentPrefix(kw.query);
+		if (intent) {
+			const existing = clusterMap.get(intent);
+			if (existing) existing.keywords.push(kw);
+			else clusterMap.set(intent, {
+				type: "intent",
+				keywords: [kw]
+			});
+			clusteredKeywords.add(kw.query);
+		}
+	}
+	if (clusterBy === "prefix" || clusterBy === "both") {
+		const unclustered = filtered.filter((kw) => !clusteredKeywords.has(kw.query));
+		const prefixMap = /* @__PURE__ */ new Map();
+		for (const kw of unclustered) {
+			const prefix = extractWordPrefix(kw.query);
+			if (prefix) {
+				const existing = prefixMap.get(prefix);
+				if (existing) existing.push(kw);
+				else prefixMap.set(prefix, [kw]);
+			}
+		}
+		for (const [prefix, kws] of prefixMap) if (kws.length >= minClusterSize) {
+			clusterMap.set(prefix, {
+				type: "prefix",
+				keywords: kws
+			});
+			kws.forEach((kw) => clusteredKeywords.add(kw.query));
+		}
+	}
+	const clusters = [];
+	for (const [name, data] of clusterMap) {
+		if (data.keywords.length < minClusterSize) continue;
+		const totalClicks = data.keywords.reduce((sum, k) => sum + num$4(k.clicks), 0);
+		const totalImpressions = data.keywords.reduce((sum, k) => sum + num$4(k.impressions), 0);
+		const avgPosition = data.keywords.reduce((sum, k) => sum + num$4(k.position), 0) / data.keywords.length;
+		clusters.push({
+			clusterName: name,
+			clusterType: data.type,
+			keywords: data.keywords,
+			totalClicks,
+			totalImpressions,
+			avgPosition,
+			keywordCount: data.keywords.length
+		});
+	}
+	clusters.sort((a, b) => b.totalClicks - a.totalClicks);
+	return {
+		clusters,
+		unclustered: filtered.filter((kw) => !clusteredKeywords.has(kw.query))
+	};
+}
+const clusteringAnalyzer = defineAnalyzer({
+	id: "clustering",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf(params);
+		const minImpressions = params.minImpressions ?? 10;
+		const minClusterSize = params.minClusterSize ?? 2;
+		const clusterBy = params.clusterBy ?? "both";
+		const doIntent = clusterBy === "intent" || clusterBy === "both";
+		const doPrefix = clusterBy === "prefix" || clusterBy === "both";
+		const intentExpr = doIntent ? `NULLIF(regexp_extract(LOWER(query), '${INTENT_PREFIXES_REGEX}', 1), '')` : `CAST(NULL AS VARCHAR)`;
+		const prefixExpr = doPrefix ? `CASE WHEN len(regexp_split_to_array(LOWER(query), '\\s+')) >= 3
+          THEN array_to_string(list_slice(regexp_split_to_array(LOWER(query), '\\s+'), 1, 2), ' ')
+          ELSE CAST(NULL AS VARCHAR) END` : `CAST(NULL AS VARCHAR)`;
+		return {
+			sql: `
+      WITH agg AS (
+        SELECT
+          query,
+          ${METRIC_EXPR.clicks} AS clicks,
+          ${METRIC_EXPR.impressions} AS impressions,
+          ${METRIC_EXPR.ctr} AS ctr,
+          ${METRIC_EXPR.position} AS position
+        FROM read_parquet({{FILES}}, union_by_name = true)
+        WHERE date >= ? AND date <= ?
+        GROUP BY query
+        HAVING SUM(impressions) >= ?
+      ),
+      classified AS (
+        SELECT
+          query, clicks, impressions, ctr, position,
+          ${intentExpr} AS intent_prefix,
+          ${prefixExpr} AS word_prefix
+        FROM agg
+      ),
+      keyed AS (
+        SELECT
+          query, clicks, impressions, ctr, position,
+          COALESCE(intent_prefix, word_prefix) AS cluster_name,
+          CASE WHEN intent_prefix IS NOT NULL THEN 'intent' ELSE 'prefix' END AS cluster_type
+        FROM classified
+        WHERE COALESCE(intent_prefix, word_prefix) IS NOT NULL
+      )
+      SELECT
+        cluster_name AS clusterName,
+        any_value(cluster_type) AS clusterType,
+        CAST(COUNT(*) AS DOUBLE) AS keywordCount,
+        ${METRIC_EXPR.clicks} AS totalClicks,
+        ${METRIC_EXPR.impressions} AS totalImpressions,
+        AVG(position) AS avgPosition,
+        to_json(list({ 'query': query, 'clicks': clicks, 'impressions': impressions, 'ctr': ctr, 'position': position })) AS keywords
+      FROM keyed
+      GROUP BY cluster_name
+      HAVING COUNT(*) >= ?
+      ORDER BY totalClicks DESC
+    `,
+			params: [
+				startDate,
+				endDate,
+				minImpressions,
+				minClusterSize
+			],
+			current: {
+				table: "keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows) {
+		const clusters = (Array.isArray(rows) ? rows : []).map((r) => ({
+			clusterName: str$18(r.clusterName),
+			clusterType: str$18(r.clusterType),
+			keywordCount: num$4(r.keywordCount),
+			totalClicks: num$4(r.totalClicks),
+			totalImpressions: num$4(r.totalImpressions),
+			avgPosition: num$4(r.avgPosition),
+			keywords: parseJsonList$13(r.keywords).map((k) => ({
+				query: str$18(k.query),
+				clicks: num$4(k.clicks),
+				impressions: num$4(k.impressions),
+				ctr: num$4(k.ctr),
+				position: num$4(k.position)
+			}))
+		}));
+		return {
+			results: clusters,
+			meta: {
+				total: clusters.length,
+				totalClusters: clusters.length
+			}
+		};
+	},
+	buildRows(params) {
+		return { keywords: keywordsQueryState(periodOf(params), params.limit) };
+	},
+	reduceRows(rows, params) {
+		const result = analyzeClustering(Array.isArray(rows) ? rows : [], {
+			clusterBy: params.clusterBy,
+			minClusterSize: params.minClusterSize,
+			minImpressions: params.minImpressions
+		});
+		return {
+			results: result.clusters,
+			meta: { totalClusters: result.clusters.length }
+		};
+	}
+});
+function str$17(v) {
+	return v == null ? "" : String(v);
+}
+function parseJsonList$12(v) {
+	if (Array.isArray(v)) return v;
+	if (typeof v === "string" && v.length > 0) {
+		const parsed = JSON.parse(v);
+		return Array.isArray(parsed) ? parsed : [];
+	}
+	return [];
+}
+function calculateGini(values) {
+	if (values.length === 0) return 0;
+	const sorted = [...values].sort((a, b) => a - b);
+	const n = sorted.length;
+	const sum = sorted.reduce((a, b) => a + b, 0);
+	if (sum === 0) return 0;
+	let weightedSum = 0;
+	for (let i = 0; i < n; i++) weightedSum += (2 * (i + 1) - n - 1) * sorted[i];
+	return weightedSum / (n * sum);
+}
+function calculateHHI(shares) {
+	return shares.reduce((sum, share) => sum + (share * 100) ** 2, 0);
+}
+function analyzeConcentration(items, options = {}) {
+	const { topN = 10 } = options;
+	if (items.length === 0) return {
+		giniCoefficient: 0,
+		hhi: 0,
+		topNConcentration: 0,
+		topNItems: [],
+		totalItems: 0,
+		totalClicks: 0,
+		riskLevel: "low"
+	};
+	const sorted = [...items].sort((a, b) => b.clicks - a.clicks);
+	const totalClicks = sorted.reduce((sum, item) => sum + item.clicks, 0);
+	const clickValues = sorted.map((i) => i.clicks);
+	const shares = totalClicks > 0 ? sorted.map((i) => i.clicks / totalClicks) : [];
+	const giniCoefficient = calculateGini(clickValues);
+	const hhi = calculateHHI(shares);
+	const topNItems = sorted.slice(0, topN).map((item) => ({
+		key: item.key,
+		clicks: item.clicks,
+		share: totalClicks > 0 ? item.clicks / totalClicks : 0
+	}));
+	const topNClicks = topNItems.reduce((sum, item) => sum + item.clicks, 0);
+	const topNConcentration = totalClicks > 0 ? topNClicks / totalClicks : 0;
+	let riskLevel = "low";
+	if (hhi > 2500) riskLevel = "high";
+	else if (hhi > 1500) riskLevel = "medium";
+	return {
+		giniCoefficient,
+		hhi,
+		topNConcentration,
+		topNItems,
+		totalItems: items.length,
+		totalClicks,
+		riskLevel
+	};
+}
+function analyzePageConcentration(pages, options) {
+	return analyzeConcentration(pages.map((p) => ({
+		key: p.page,
+		clicks: num$4(p.clicks)
+	})), options);
+}
+function analyzeKeywordConcentration(keywords, options) {
+	return analyzeConcentration(keywords.map((k) => ({
+		key: k.query,
+		clicks: num$4(k.clicks)
+	})), options);
+}
+const concentrationAnalyzer = defineAnalyzer({
+	id: "concentration",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf(params);
+		const dim = params.dimension || "pages";
+		const topN = params.topN ?? 10;
+		const table = dim === "keywords" ? "keywords" : "pages";
+		const keyCol = dim === "keywords" ? "query" : "url";
+		return {
+			sql: `
+    WITH items AS (
+      SELECT
+        ${keyCol} AS key,
+        ${METRIC_EXPR.clicks} AS clicks
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ?
+      GROUP BY ${keyCol}
+      HAVING SUM(clicks) > 0
+    ),
+    totals AS (
+      SELECT SUM(clicks) AS total_clicks, COUNT(*) AS total_items FROM items
+    ),
+    ranked AS (
+      SELECT
+        i.key, i.clicks,
+        i.clicks / NULLIF(t.total_clicks, 0) AS share,
+        ROW_NUMBER() OVER (ORDER BY i.clicks DESC, i.key ASC) AS rnk_desc,
+        ROW_NUMBER() OVER (ORDER BY i.clicks ASC, i.key ASC) AS rnk_asc,
+        t.total_clicks AS tclicks,
+        t.total_items AS titems
+      FROM items i, totals t
+    ),
+    gini_num AS (
+      SELECT SUM((2.0 * rnk_asc - titems - 1) * clicks) AS weighted_sum FROM ranked
+    ),
+    hhi_calc AS (
+      SELECT SUM(POWER(share * 100, 2)) AS hhi FROM ranked
+    ),
+    top_list AS (
+      SELECT
+        list({ 'key': key, 'clicks': clicks, 'share': share } ORDER BY clicks DESC, key ASC) AS items,
+        SUM(clicks) AS top_clicks
+      FROM ranked WHERE rnk_desc <= ?
+    )
+    SELECT
+      COALESCE(
+        (SELECT weighted_sum FROM gini_num)
+          / NULLIF((SELECT total_items FROM totals) * (SELECT total_clicks FROM totals), 0),
+        0.0
+      ) AS giniCoefficient,
+      COALESCE((SELECT hhi FROM hhi_calc), 0.0) AS hhi,
+      COALESCE(
+        CAST((SELECT top_clicks FROM top_list) AS DOUBLE)
+          / NULLIF((SELECT total_clicks FROM totals), 0),
+        0.0
+      ) AS topNConcentration,
+      COALESCE((SELECT to_json(items) FROM top_list), '[]') AS topNItems,
+      COALESCE((SELECT total_items FROM totals), 0) AS totalItems,
+      COALESCE((SELECT total_clicks FROM totals), 0.0) AS totalClicks,
+      CASE
+        WHEN COALESCE((SELECT hhi FROM hhi_calc), 0.0) > 2500 THEN 'high'
+        WHEN COALESCE((SELECT hhi FROM hhi_calc), 0.0) > 1500 THEN 'medium'
+        ELSE 'low'
+      END AS riskLevel
+  `,
+			params: [
+				startDate,
+				endDate,
+				topN
+			],
+			current: {
+				table,
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const r = (Array.isArray(rows) ? rows : [])[0] ?? {};
+		const topRaw = parseJsonList$12(r.topNItems);
+		return {
+			results: [{
+				giniCoefficient: num$4(r.giniCoefficient),
+				hhi: num$4(r.hhi),
+				topNConcentration: num$4(r.topNConcentration),
+				topNItems: topRaw.map((t) => ({
+					key: str$17(t.key),
+					clicks: num$4(t.clicks),
+					share: num$4(t.share)
+				})),
+				totalItems: num$4(r.totalItems),
+				totalClicks: num$4(r.totalClicks),
+				riskLevel: str$17(r.riskLevel)
+			}],
+			meta: {
+				total: 1,
+				dimension: params.dimension || "pages"
+			}
+		};
+	},
+	buildRows(params) {
+		const dim = params.dimension || "pages";
+		const period = periodOf(params);
+		const out = {};
+		if (dim === "pages") out.pages = pagesQueryState(period, params.limit);
+		else out.keywords = keywordsQueryState(period, params.limit);
+		return out;
+	},
+	reduceRows(rows, params) {
+		const dim = params.dimension || "pages";
+		const arr = Array.isArray(rows) ? rows : rows[dim] ?? [];
+		return {
+			results: [dim === "pages" ? analyzePageConcentration(arr, { topN: params.topN }) : analyzeKeywordConcentration(arr, { topN: params.topN })],
+			meta: { dimension: dim }
+		};
+	}
+});
+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$16(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(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(first_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$16(r.week),
+			newKeywords: num$2(r.newKeywords),
+			totalKeywords: num$2(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$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$15(v) {
+	return v == null ? "" : String(v);
+}
+function bool$2(v) {
+	return v === true || v === 1 || v === "true";
+}
+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 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$15(r.keyword),
+			page: str$15(r.page),
+			breachDaysDown: num$1(r.breachDaysDown),
+			breachDaysUp: num$1(r.breachDaysUp),
+			clicksLost: num$1(r.clicksLost),
+			severity: num$1(r.severityRaw),
+			maxZ: num$1(r.maxZ),
+			baselineCtr: num$1(r.baselineCtr),
+			baselinePosition: num$1(r.baselinePosition),
+			totalImpressions: num$1(r.totalImpressions),
+			totalClicks: num$1(r.totalClicks),
+			series: parseJsonList$11(r.seriesJson).map((s) => ({
+				date: str$15(s.date),
+				ctr: num$1(s.ctr),
+				position: num$1(s.position),
+				impressions: num$1(s.impressions),
+				rollingCtr: s.rollingCtr == null ? null : num$1(s.rollingCtr),
+				rollingStddev: s.rollingStddev == null ? null : num$1(s.rollingStddev),
+				z: num$1(s.z),
+				breach: bool$2(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(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 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$10(row.curve_json).map((r) => ({
+			bucket: str$14(r.bucket),
+			avgCtr: num(r.avgCtr),
+			medianPosition: num(r.medianPosition),
+			keywordCount: num(r.keywordCount),
+			totalClicks: num(r.totalClicks),
+			totalImpressions: num(r.totalImpressions)
+		}));
+		const outliers = parseJsonList$10(row.outliers_json).map((r) => ({
+			query: str$14(r.query),
+			clicks: num(r.clicks),
+			impressions: num(r.impressions),
+			ctr: num(r.ctr),
+			position: num(r.position),
+			expectedCtr: num(r.expectedCtr),
+			ctrDiff: num(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$13(v) {
+	return v == null ? "" : String(v);
+}
+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 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$4(pageTotals.totalClicks);
+		const totalImpressions = num$4(pageTotals.totalImpressions);
+		const attributedClicks = num$4(kwTotals.attributedClicks);
+		const attributedImpressions = num$4(kwTotals.attributedImpressions);
+		const darkClicks = Math.max(0, totalClicks - attributedClicks);
+		const darkPercent = totalClicks > 0 ? darkClicks / totalClicks : 0;
+		return {
+			results: parseJsonList$9(row.pages_json).map((r) => ({
+				url: str$13(r.url),
+				totalClicks: num$4(r.totalClicks),
+				attributedClicks: num$4(r.attributedClicks),
+				darkClicks: num$4(r.darkClicks),
+				darkPercent: num$4(r.darkPercent),
+				keywordCount: num$4(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
+		};
+	}
+});
+const sortResults$1 = createMetricSorter("lostClicks", {
+	lostClicks: "desc",
+	declinePercent: "desc",
+	currentClicks: "asc"
+});
+function str$12(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 [];
+}
+function analyzeDecay(input, options = {}) {
+	const { minPreviousClicks = 50, threshold = .2, sortBy = "lostClicks" } = options;
+	const currentMap = buildPeriodMap(input.current, (r) => r.page, (r) => ({
+		clicks: num$4(r.clicks),
+		position: num$4(r.position)
+	}));
+	const previousMap = buildPeriodMap(input.previous, (r) => r.page, (r) => ({
+		clicks: num$4(r.clicks),
+		position: num$4(r.position)
+	}), (r) => num$4(r.clicks) >= minPreviousClicks);
+	const results = [];
+	for (const [page, prev] of previousMap) {
+		const curr = currentMap.get(page) || {
+			clicks: 0,
+			position: 0
+		};
+		const lostClicks = prev.clicks - curr.clicks;
+		const declinePercent = prev.clicks > 0 ? lostClicks / prev.clicks : 0;
+		if (declinePercent >= threshold && lostClicks > 0) results.push({
+			page,
+			currentClicks: curr.clicks,
+			previousClicks: prev.clicks,
+			lostClicks,
+			declinePercent,
+			currentPosition: curr.position,
+			previousPosition: prev.position,
+			positionDrop: curr.position - prev.position
+		});
+	}
+	return sortResults$1(results, sortBy);
+}
+const decayAnalyzer = defineAnalyzer({
+	id: "decay",
+	buildSql(params) {
+		const { current: cur, previous: prev } = comparisonOf(params);
+		const minPreviousClicks = params.minPreviousClicks ?? 50;
+		const threshold = params.threshold ?? .2;
+		const limit = params.limit ?? 2e3;
+		return {
+			sql: `
+      WITH cur AS (
+        SELECT
+          url,
+          ${METRIC_EXPR.clicks} AS clicks,
+          ${METRIC_EXPR.position} AS position
+        FROM read_parquet({{FILES}}, union_by_name = true)
+        WHERE date >= ? AND date <= ?
+        GROUP BY url
+      ),
+      prev AS (
+        SELECT
+          url,
+          ${METRIC_EXPR.clicks} AS clicks,
+          ${METRIC_EXPR.position} AS position
+        FROM read_parquet({{FILES_PREV}}, union_by_name = true)
+        WHERE date >= ? AND date <= ?
+        GROUP BY url
+        HAVING SUM(clicks) >= ?
+      ),
+      weekly AS (
+        SELECT url, date_trunc('week', CAST(date AS DATE)) AS week,
+          ${METRIC_EXPR.clicks} AS clicks,
+          ${METRIC_EXPR.impressions} AS impressions
+        FROM (
+          SELECT url, date, clicks, impressions
+          FROM read_parquet({{FILES}}, union_by_name = true)
+          WHERE date >= ? AND date <= ?
+          UNION ALL
+          SELECT url, date, clicks, impressions
+          FROM read_parquet({{FILES_PREV}}, union_by_name = true)
+          WHERE date >= ? AND date <= ?
+        )
+        GROUP BY url, week
+      ),
+      series_by_url AS (
+        SELECT url, to_json(list({
+          'week': strftime(week, '%Y-%m-%d'),
+          'clicks': clicks,
+          'impressions': impressions
+        } ORDER BY week)) AS seriesJson
+        FROM weekly GROUP BY url
+      ),
+      joined AS (
+        SELECT
+          p.url AS page,
+          COALESCE(c.clicks, 0.0) AS currentClicks,
+          p.clicks AS previousClicks,
+          (p.clicks - COALESCE(c.clicks, 0.0)) AS lostClicks,
+          (p.clicks - COALESCE(c.clicks, 0.0)) / NULLIF(p.clicks, 0) AS declinePercent,
+          COALESCE(c.position, 0.0) AS currentPosition,
+          p.position AS previousPosition,
+          (COALESCE(c.position, 0.0) - p.position) AS positionDrop,
+          s.seriesJson
+        FROM prev p
+        LEFT JOIN cur c ON p.url = c.url
+        LEFT JOIN series_by_url s ON p.url = s.url
+      )
+      SELECT *
+      FROM joined
+      WHERE declinePercent >= ? AND lostClicks > 0
+      ORDER BY lostClicks DESC
+      LIMIT ${Number(limit)}
+    `,
+			params: [
+				cur.startDate,
+				cur.endDate,
+				prev.startDate,
+				prev.endDate,
+				minPreviousClicks,
+				cur.startDate,
+				cur.endDate,
+				prev.startDate,
+				prev.endDate,
+				threshold
+			],
+			current: {
+				table: "pages",
+				partitions: enumeratePartitions(cur.startDate, cur.endDate)
+			},
+			previous: {
+				table: "pages",
+				partitions: enumeratePartitions(prev.startDate, prev.endDate)
+			}
+		};
+	},
+	reduceSql(rows) {
+		const arr = Array.isArray(rows) ? rows : [];
+		return {
+			results: arr.map((r) => ({
+				page: str$12(r.page),
+				currentClicks: num$4(r.currentClicks),
+				previousClicks: num$4(r.previousClicks),
+				lostClicks: num$4(r.lostClicks),
+				declinePercent: num$4(r.declinePercent),
+				currentPosition: num$4(r.currentPosition),
+				previousPosition: num$4(r.previousPosition),
+				positionDrop: num$4(r.positionDrop),
+				series: parseJsonList$8(r.seriesJson).map((s) => ({
+					week: str$12(s.week),
+					clicks: num$4(s.clicks),
+					impressions: num$4(s.impressions)
+				}))
+			})),
+			meta: { total: arr.length }
+		};
+	},
+	buildRows(params) {
+		const { current, previous } = comparisonOf(params);
+		return {
+			current: pagesQueryState(current, params.limit),
+			previous: pagesQueryState(previous, params.limit)
+		};
+	},
+	reduceRows(rows, params) {
+		const map = rows && !Array.isArray(rows) ? rows : {
+			current: [],
+			previous: []
+		};
+		const results = analyzeDecay({
+			current: map.current ?? [],
+			previous: map.previous ?? []
+		}, {
+			minPreviousClicks: params.minPreviousClicks,
+			threshold: params.threshold
+		});
+		return {
+			results,
+			meta: { total: results.length }
+		};
+	}
+});
+function str$11(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$11(r.date),
+			device: str$11(r.device).toUpperCase(),
+			clicks: num$4(r.clicks),
+			impressions: num$4(r.impressions),
+			ctr: num$4(r.ctr),
+			position: num$4(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$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 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$10(r.clusterKey),
+			keywordCount: num$4(r.keywordCount),
+			totalImpressions: num$4(r.totalImpressions),
+			totalClicks: num$4(r.totalClicks),
+			ctr: num$4(r.ctr),
+			avgPosition: num$4(r.avgPosition),
+			keywords: parseJsonList$7(r.keywords).slice(0, 25).map((k) => ({
+				query: str$10(k.query),
+				impressions: num$4(k.impressions),
+				clicks: num$4(k.clicks),
+				position: num$4(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$9(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 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$6(row.distribution_json).sort((a, b) => num$4(a.sortKey) - num$4(b.sortKey)).map((r) => ({
+			bucket: str$9(r.bucket),
+			pageCount: num$4(r.pageCount)
+		}));
+		const fragile = parseJsonList$6(row.fragile_json).map((r) => ({
+			url: str$9(r.url),
+			keywordCount: num$4(r.keywordCount),
+			clicks: num$4(r.clicks),
+			impressions: num$4(r.impressions)
+		}));
+		const authority = parseJsonList$6(row.authority_json).map((r) => ({
+			url: str$9(r.url),
+			keywordCount: num$4(r.keywordCount),
+			clicks: num$4(r.clicks),
+			impressions: num$4(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$4(stats.totalPages),
+					avgKeywordsPerPage: num$4(stats.avgKeywordsPerPage),
+					fragileCount: num$4(stats.fragileCount),
+					authorityCount: num$4(stats.authorityCount)
+				},
+				startDate,
+				endDate
+			}
+		};
+	}
+});
+function str$8(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 [];
+}
+function downsampleLogRank(points) {
+	const all = points.map((p) => ({
+		rank: num$4(p.rank),
+		impressions: num$4(p.impressions),
+		clicks: num$4(p.clicks),
+		query: str$8(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$8(r.page),
+			queryCount: num$4(r.queryCount),
+			totalImpressions: num$4(r.totalImpressions),
+			totalClicks: num$4(r.totalClicks),
+			slope: num$4(r.slope),
+			intercept: num$4(r.intercept),
+			r2: num$4(r.r2),
+			headImpressions: num$4(r.headImpressions),
+			headShare: num$4(r.headShare),
+			fingerprint: str$8(r.fingerprint),
+			points: downsampleLogRank(parseJsonList$5(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 percentDifference(current, previous) {
+	if (previous === 0) return current > 0 ? 100 : 0;
+	return (current - previous) / previous * 100;
+}
+function str$7(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 analyzeMovers(input, options = {}) {
+	const { changeThreshold = .2, minImpressions = 50, sortBy = "clicksChange" } = options;
+	const normFactor = input.normalizationFactor ?? 1;
+	const baselineMap = buildPeriodMap(input.previous, (r) => r.query, (r) => ({
+		clicks: num$4(r.clicks) / normFactor,
+		impressions: num$4(r.impressions) / normFactor,
+		position: num$4(r.position),
+		page: r.page ?? null
+	}));
+	const pageMap = /* @__PURE__ */ new Map();
+	for (const row of input.current) if (!pageMap.has(row.query) && row.page) pageMap.set(row.query, row.page);
+	for (const row of input.previous) if (!pageMap.has(row.query) && row.page) pageMap.set(row.query, row.page);
+	const rising = [];
+	const declining = [];
+	const stable = [];
+	for (const row of input.current) {
+		const impressions = num$4(row.impressions);
+		const clicks = num$4(row.clicks);
+		const position = num$4(row.position);
+		if (impressions < minImpressions) continue;
+		const baseline = baselineMap.get(row.query) || {
+			clicks: 0,
+			impressions: 0,
+			position: 0,
+			page: null
+		};
+		const clicksChangePercent = percentDifference(clicks, baseline.clicks);
+		const impressionsChangePercent = percentDifference(impressions, baseline.impressions);
+		const data = {
+			keyword: row.query,
+			page: pageMap.get(row.query) ?? null,
+			recentClicks: clicks,
+			recentImpressions: impressions,
+			recentPosition: position,
+			baselineClicks: Math.round(baseline.clicks),
+			baselineImpressions: Math.round(baseline.impressions),
+			baselinePosition: baseline.position,
+			clicksChange: clicks - Math.round(baseline.clicks),
+			clicksChangePercent,
+			impressionsChangePercent,
+			positionChange: position - baseline.position
+		};
+		const absChange = Math.abs(clicksChangePercent / 100);
+		if (clicksChangePercent > 0 && absChange >= changeThreshold) rising.push(data);
+		else if (clicksChangePercent < 0 && absChange >= changeThreshold) declining.push(data);
+		else stable.push(data);
+	}
+	const sortFn = (a, b) => {
+		switch (sortBy) {
+			case "clicks": return b.recentClicks - a.recentClicks;
+			case "impressions": return b.recentImpressions - a.recentImpressions;
+			case "clicksChange": return Math.abs(b.clicksChangePercent) - Math.abs(a.clicksChangePercent);
+			case "impressionsChange": return Math.abs(b.impressionsChangePercent) - Math.abs(a.impressionsChangePercent);
+			case "positionChange": return Math.abs(b.positionChange) - Math.abs(a.positionChange);
+			default: return Math.abs(b.clicksChangePercent) - Math.abs(a.clicksChangePercent);
+		}
+	};
+	rising.sort(sortFn);
+	declining.sort(sortFn);
+	stable.sort((a, b) => b.recentClicks - a.recentClicks);
+	return {
+		rising,
+		declining,
+		stable
+	};
+}
+const moversAnalyzer = defineAnalyzer({
+	id: "movers",
+	buildSql(params) {
+		const { current: cur, previous: prev } = comparisonOf(params);
+		const minImpressions = params.minImpressions ?? 50;
+		const changeThreshold = params.changeThreshold ?? .2;
+		const limit = params.limit ?? 2e3;
+		return {
+			sql: `
+      WITH cur AS (
+        SELECT
+          query, url,
+          ${METRIC_EXPR.clicks} AS clicks,
+          ${METRIC_EXPR.impressions} AS impressions,
+          ${METRIC_EXPR.position} AS position
+        FROM read_parquet({{FILES}}, union_by_name = true)
+        WHERE date >= ? AND date <= ?
+        GROUP BY query, url
+      ),
+      prev AS (
+        SELECT
+          query, url,
+          ${METRIC_EXPR.clicks} AS clicks,
+          ${METRIC_EXPR.impressions} AS impressions,
+          ${METRIC_EXPR.position} AS position
+        FROM read_parquet({{FILES_PREV}}, union_by_name = true)
+        WHERE date >= ? AND date <= ?
+        GROUP BY query, url
+      ),
+      weekly AS (
+        SELECT query, url, date_trunc('week', CAST(date AS DATE)) AS week,
+          ${METRIC_EXPR.clicks} AS clicks,
+          ${METRIC_EXPR.impressions} AS impressions
+        FROM (
+          SELECT query, url, date, clicks, impressions
+          FROM read_parquet({{FILES}}, union_by_name = true)
+          WHERE date >= ? AND date <= ?
+          UNION ALL
+          SELECT query, url, date, clicks, impressions
+          FROM read_parquet({{FILES_PREV}}, union_by_name = true)
+          WHERE date >= ? AND date <= ?
+        )
+        GROUP BY query, url, week
+      ),
+      series_by_entity AS (
+        SELECT query, url, to_json(list({
+          'week': strftime(week, '%Y-%m-%d'),
+          'clicks': clicks,
+          'impressions': impressions
+        } ORDER BY week)) AS seriesJson
+        FROM weekly GROUP BY query, url
+      ),
+      joined AS (
+        SELECT
+          c.query AS keyword,
+          c.url AS page,
+          c.clicks AS recentClicks,
+          c.impressions AS recentImpressions,
+          c.position AS recentPosition,
+          COALESCE(p.clicks, 0.0) AS baselineClicks,
+          COALESCE(p.impressions, 0.0) AS baselineImpressions,
+          COALESCE(p.position, 0.0) AS baselinePosition,
+          (c.clicks - COALESCE(p.clicks, 0.0)) AS clicksChange,
+          CASE
+            WHEN COALESCE(p.clicks, 0.0) = 0 THEN CASE WHEN c.clicks > 0 THEN 100.0 ELSE 0.0 END
+            ELSE (c.clicks - p.clicks) * 100.0 / p.clicks
+          END AS clicksChangePercent,
+          CASE
+            WHEN COALESCE(p.impressions, 0.0) = 0 THEN CASE WHEN c.impressions > 0 THEN 100.0 ELSE 0.0 END
+            ELSE (c.impressions - p.impressions) * 100.0 / p.impressions
+          END AS impressionsChangePercent,
+          (c.position - COALESCE(p.position, 0.0)) AS positionChange,
+          s.seriesJson
+        FROM cur c
+        LEFT JOIN prev p ON c.query = p.query AND c.url = p.url
+        LEFT JOIN series_by_entity s ON c.query = s.query AND c.url = s.url
+        WHERE c.impressions >= ?
+      )
+      SELECT *,
+        CASE
+          WHEN clicksChangePercent > 0 AND ABS(clicksChangePercent) / 100.0 >= ? THEN 'rising'
+          WHEN clicksChangePercent < 0 AND ABS(clicksChangePercent) / 100.0 >= ? THEN 'declining'
+          ELSE 'stable'
+        END AS direction
+      FROM joined
+      ORDER BY ABS(clicksChangePercent) DESC
+      LIMIT ${Number(limit)}
+    `,
+			params: [
+				cur.startDate,
+				cur.endDate,
+				prev.startDate,
+				prev.endDate,
+				cur.startDate,
+				cur.endDate,
+				prev.startDate,
+				prev.endDate,
+				minImpressions,
+				changeThreshold,
+				changeThreshold
+			],
+			current: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(cur.startDate, cur.endDate)
+			},
+			previous: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(prev.startDate, prev.endDate)
+			}
+		};
+	},
+	reduceSql(rows) {
+		const normalized = (Array.isArray(rows) ? rows : []).map((r) => ({
+			keyword: str$7(r.keyword),
+			page: r.page == null ? null : str$7(r.page),
+			recentClicks: num$4(r.recentClicks),
+			recentImpressions: num$4(r.recentImpressions),
+			recentPosition: num$4(r.recentPosition),
+			baselineClicks: Math.round(num$4(r.baselineClicks)),
+			baselineImpressions: Math.round(num$4(r.baselineImpressions)),
+			baselinePosition: num$4(r.baselinePosition),
+			clicksChange: num$4(r.clicksChange),
+			clicksChangePercent: num$4(r.clicksChangePercent),
+			impressionsChangePercent: num$4(r.impressionsChangePercent),
+			positionChange: num$4(r.positionChange),
+			direction: str$7(r.direction),
+			series: parseJsonList$4(r.seriesJson).map((s) => ({
+				week: str$7(s.week),
+				clicks: num$4(s.clicks),
+				impressions: num$4(s.impressions)
+			}))
+		}));
+		const rising = normalized.filter((r) => r.direction === "rising");
+		const declining = normalized.filter((r) => r.direction === "declining");
+		const stable = normalized.filter((r) => r.direction === "stable");
+		const combined = [...rising, ...declining];
+		return {
+			results: combined,
+			meta: {
+				total: combined.length,
+				rising: rising.length,
+				declining: declining.length,
+				stable: stable.length
+			}
+		};
+	},
+	buildRows(params) {
+		const { current, previous } = comparisonOf(params);
+		return {
+			current: keywordsQueryState(current, params.limit),
+			previous: keywordsQueryState(previous, params.limit)
+		};
+	},
+	reduceRows(rows, params) {
+		const map = rows && !Array.isArray(rows) ? rows : {
+			current: [],
+			previous: []
+		};
+		const result = analyzeMovers({
+			current: map.current ?? [],
+			previous: map.previous ?? []
+		}, {
+			changeThreshold: params.changeThreshold,
+			minImpressions: params.minImpressions
+		});
+		return {
+			results: [...result.rising.map((r) => ({
+				...r,
+				direction: "rising"
+			})), ...result.declining.map((r) => ({
+				...r,
+				direction: "declining"
+			}))],
+			meta: {
+				rising: result.rising.length,
+				declining: result.declining.length
+			}
+		};
+	}
+});
+const DEFAULT_LIMIT = 1e3;
+const MAX_LIMIT = 5e4;
+function clampLimit(limit, fallback = DEFAULT_LIMIT) {
+	const n = Number(limit ?? fallback);
+	if (!Number.isFinite(n) || n <= 0) return fallback;
+	return Math.min(n, MAX_LIMIT);
+}
+function clampOffset(offset) {
+	const n = Number(offset ?? 0);
+	if (!Number.isFinite(n) || n < 0) return 0;
+	return Math.floor(n);
+}
+function paginateClause(input) {
+	const l = clampLimit(input.limit);
+	const o = clampOffset(input.offset);
+	return o > 0 ? `LIMIT ${l} OFFSET ${o}` : `LIMIT ${l}`;
+}
+function paginateInMemory(rows, input) {
+	const l = clampLimit(input.limit, rows.length);
+	const o = clampOffset(input.offset);
+	return rows.slice(o, o + l);
+}
+function resolveSort(input, allowed, defaults) {
+	return {
+		sortBy: input.sortBy && allowed.includes(input.sortBy) ? input.sortBy : defaults.sortBy,
+		sortDir: input.sortDir === "asc" || input.sortDir === "desc" ? input.sortDir : defaults.sortDir
+	};
+}
+const EXPECTED_CTR_BY_POSITION = {
+	1: .3,
+	2: .15,
+	3: .1,
+	4: .07,
+	5: .05,
+	6: .04,
+	7: .03,
+	8: .025,
+	9: .02,
+	10: .015
+};
+function getExpectedCtr(position) {
+	return EXPECTED_CTR_BY_POSITION[Math.round(Math.max(1, Math.min(position, 10)))] || .01;
+}
+function calculatePositionScore(position) {
+	if (position <= 3) return .2;
+	if (position > 50) return .1;
+	const distance = Math.abs(position - 11);
+	return Math.max(0, 1 - distance / 15);
+}
+function calculateImpressionScore(impressions) {
+	if (impressions <= 0) return 0;
+	return Math.min(Math.log10(impressions) / 5, 1);
+}
+function calculateCtrGapScore(actualCtr, position) {
+	const expectedCtr = getExpectedCtr(position);
+	if (actualCtr >= expectedCtr) return 0;
+	const gap = expectedCtr - actualCtr;
+	return Math.min(gap / expectedCtr, 1);
+}
+const sortResults = createMetricSorter("opportunityScore", {
+	opportunityScore: "desc",
+	potentialClicks: "desc",
+	impressions: "desc",
+	position: "asc"
+});
+const opportunityAnalyzer = defineAnalyzer({
+	id: "opportunity",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf(params);
+		const minImpressions = params.minImpressions ?? 100;
+		const w1 = 1;
+		const w2 = 1;
+		const w3 = 1;
+		const totalW = w1 + w2 + w3;
+		const limit = params.limit ?? 1e3;
+		return {
+			sql: `
+    WITH agg AS (
+      SELECT
+        query AS keyword,
+        url AS page,
+        ${METRIC_EXPR.clicks} AS clicks,
+        ${METRIC_EXPR.impressions} AS impressions,
+        ${METRIC_EXPR.ctr} AS ctr,
+        ${METRIC_EXPR.position} AS position
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ?
+      GROUP BY query, url
+      HAVING SUM(impressions) >= ?
+    ),
+    scored AS (
+      SELECT
+        keyword, page, clicks, impressions, ctr, position,
+        CASE
+          WHEN position <= 3 THEN 0.2
+          WHEN position > 50 THEN 0.1
+          ELSE GREATEST(0.0, 1.0 - ABS(position - 11.0) / 15.0)
+        END AS positionScore,
+        CASE WHEN impressions <= 0 THEN 0.0 ELSE LEAST(LOG10(impressions) / 5.0, 1.0) END AS impressionScore,
+        CASE CAST(ROUND(GREATEST(LEAST(position, 10.0), 1.0)) AS INTEGER)
+          WHEN 1 THEN 0.30
+          WHEN 2 THEN 0.15
+          WHEN 3 THEN 0.10
+          WHEN 4 THEN 0.07
+          WHEN 5 THEN 0.05
+          WHEN 6 THEN 0.04
+          WHEN 7 THEN 0.03
+          WHEN 8 THEN 0.025
+          WHEN 9 THEN 0.02
+          WHEN 10 THEN 0.015
+          ELSE 0.01
+        END AS expectedCtr
+      FROM agg
+    ),
+    gapped AS (
+      SELECT
+        *,
+        CASE WHEN ctr >= expectedCtr THEN 0.0 ELSE LEAST((expectedCtr - ctr) / expectedCtr, 1.0) END AS ctrGapScore
+      FROM scored
+    )
+    SELECT
+      keyword, page, clicks, impressions, ctr, position,
+      CAST(ROUND(POWER(
+        POWER(positionScore, ${w1}) * POWER(impressionScore, ${w2}) * POWER(ctrGapScore, ${w3}),
+        1.0 / ${totalW}
+      ) * 100) AS DOUBLE) AS opportunityScore,
+      CAST(ROUND(impressions * (
+        CASE CAST(ROUND(GREATEST(LEAST(position, 3.0), 1.0)) AS INTEGER)
+          WHEN 1 THEN 0.30
+          WHEN 2 THEN 0.15
+          WHEN 3 THEN 0.10
+          ELSE 0.10
+        END
+      )) AS DOUBLE) AS potentialClicks,
+      positionScore, impressionScore, ctrGapScore
+    FROM gapped
+    ORDER BY opportunityScore DESC
+    ${paginateClause({
+				limit,
+				offset: params.offset
+			})}
+  `,
+			params: [
+				startDate,
+				endDate,
+				minImpressions
+			],
+			current: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows) {
+		const arr = Array.isArray(rows) ? rows : [];
+		return {
+			results: arr.map((r) => ({
+				keyword: r.keyword == null ? "" : String(r.keyword),
+				page: r.page == null ? null : String(r.page),
+				clicks: num$4(r.clicks),
+				impressions: num$4(r.impressions),
+				ctr: num$4(r.ctr),
+				position: num$4(r.position),
+				opportunityScore: num$4(r.opportunityScore),
+				potentialClicks: num$4(r.potentialClicks),
+				factors: {
+					positionScore: num$4(r.positionScore),
+					impressionScore: num$4(r.impressionScore),
+					ctrGapScore: num$4(r.ctrGapScore)
+				}
+			})),
+			meta: { total: arr.length }
+		};
+	},
+	buildRows(params) {
+		return { keywords: keywordsQueryState(periodOf(params), params.limit) };
+	},
+	reduceRows(rows, params) {
+		const keywords = (Array.isArray(rows) ? rows : []) ?? [];
+		const minImpressions = params.minImpressions ?? 100;
+		const positionWeight = 1;
+		const impressionsWeight = 1;
+		const ctrGapWeight = 1;
+		const sortBy = "opportunityScore";
+		const results = [];
+		for (const row of keywords) {
+			const impressions = num$4(row.impressions);
+			const position = num$4(row.position);
+			const ctr = num$4(row.ctr);
+			const clicks = num$4(row.clicks);
+			if (impressions < minImpressions) continue;
+			const positionScore = calculatePositionScore(position);
+			const impressionScore = calculateImpressionScore(impressions);
+			const ctrGapScore = calculateCtrGapScore(ctr, position);
+			const geometricMean = (positionScore ** positionWeight * impressionScore ** impressionsWeight * ctrGapScore ** ctrGapWeight) ** (1 / (positionWeight + impressionsWeight + ctrGapWeight));
+			const opportunityScore = Math.round(geometricMean * 100);
+			const targetCtr = getExpectedCtr(Math.min(3, position));
+			const potentialClicks = Math.round(impressions * targetCtr);
+			results.push({
+				keyword: row.query,
+				page: row.page ?? null,
+				clicks,
+				impressions,
+				ctr,
+				position,
+				opportunityScore,
+				potentialClicks,
+				factors: {
+					positionScore,
+					impressionScore,
+					ctrGapScore
+				}
+			});
+		}
+		const sorted = sortResults(results, sortBy);
+		const paged = paginateInMemory(sorted, {
+			limit: params.limit,
+			offset: params.offset
+		});
+		return {
+			results: paged,
+			meta: {
+				total: sorted.length,
+				returned: paged.length
+			}
+		};
+	}
+});
+function str$6(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$6(r.date),
+				pos_1_3: num$4(r.pos_1_3),
+				pos_4_10: num$4(r.pos_4_10),
+				pos_11_20: num$4(r.pos_11_20),
+				pos_20_plus: num$4(r.pos_20_plus),
+				total: num$4(r.total)
+			})),
+			meta: {
+				total: arr.length,
+				startDate,
+				endDate
+			}
+		};
+	}
+});
+function str$5(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$5(r.page);
+			const date = str$5(r.date);
+			allDates.add(date);
+			const entry = byPage.get(page) ?? {
+				page,
+				avgVolatility: num$4(r.pageAvgVolatility),
+				peakVolatility: num$4(r.pagePeakVolatility),
+				totalImpressions: num$4(r.pageTotalImpressions),
+				days: []
+			};
+			entry.days.push({
+				date,
+				queryCount: num$4(r.queryCount),
+				dayImpressions: num$4(r.dayImpressions),
+				avgPosition: num$4(r.avgPosition),
+				posStddev: num$4(r.posStddev),
+				bestPosition: num$4(r.bestPosition),
+				worstPosition: num$4(r.worstPosition),
+				dodShift: num$4(r.dodShift),
+				volatility: num$4(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$4(v) {
+	return v == null ? "" : String(v);
+}
+function parseJsonList$3(v) {
+	if (Array.isArray(v)) return v;
+	if (typeof v === "string" && v.length > 0) {
+		const parsed = JSON.parse(v);
+		return Array.isArray(parsed) ? parsed : [];
+	}
+	return [];
+}
+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$4(r.source_page),
+			targetPage: str$4(r.target_page),
+			weight: num$4(r.weight),
+			queryCount: num$4(r.query_count),
+			exactCount: num$4(r.exact_count),
+			fuzzyCount: num$4(r.query_count) - num$4(r.exact_count),
+			examples: parseJsonList$3(r.examplesJson).slice(0, 8).map((e) => ({
+				sourceQuery: str$4(e.sourceQuery),
+				targetQuery: str$4(e.targetQuery),
+				absorbed: num$4(e.absorbed),
+				matchType: str$4(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$3(v) {
+	return v == null ? "" : String(v);
+}
+function bool$1(v) {
+	return v === true || v === 1 || v === "true";
+}
+function calculateCV(values) {
+	if (values.length === 0) return 0;
+	const mean = values.reduce((a, b) => a + b, 0) / values.length;
+	if (mean === 0) return 0;
+	const variance = values.reduce((sum, v) => sum + (v - mean) ** 2, 0) / values.length;
+	return Math.min(Math.sqrt(variance) / mean, 1);
+}
+function analyzeSeasonality(dates, options = {}) {
+	const { metric = "clicks" } = options;
+	if (dates.length === 0) return {
+		hasSeasonality: false,
+		strength: 0,
+		peakMonths: [],
+		troughMonths: [],
+		monthlyBreakdown: [],
+		insufficientData: true
+	};
+	const monthlyMap = /* @__PURE__ */ new Map();
+	for (const row of dates) {
+		const month = row.date.substring(0, 7);
+		const value = metric === "clicks" ? row.clicks : row.impressions;
+		monthlyMap.set(month, (monthlyMap.get(month) || 0) + value);
+	}
+	const months = Array.from(monthlyMap.keys()).sort();
+	const values = months.map((m) => monthlyMap.get(m) || 0);
+	const insufficientData = months.length < 12;
+	const totalValue = values.reduce((a, b) => a + b, 0);
+	const avgValue = values.length > 0 ? totalValue / values.length : 0;
+	const monthlyBreakdown = months.map((month, i) => {
+		const value = values[i] ?? 0;
+		const vsAverage = avgValue > 0 ? value / avgValue : 0;
+		return {
+			month,
+			value,
+			vsAverage,
+			isPeak: vsAverage > 1.5,
+			isTrough: vsAverage < .5
+		};
+	});
+	const peakMonths = [...new Set(monthlyBreakdown.filter((m) => m.isPeak).map((m) => m.month.substring(5, 7)))];
+	const troughMonths = [...new Set(monthlyBreakdown.filter((m) => m.isTrough).map((m) => m.month.substring(5, 7)))];
+	const strength = calculateCV(values);
+	return {
+		hasSeasonality: peakMonths.length > 0 || troughMonths.length > 0 || strength > .3,
+		strength,
+		peakMonths,
+		troughMonths,
+		monthlyBreakdown,
+		insufficientData
+	};
+}
+const seasonalityAnalyzer = defineAnalyzer({
+	id: "seasonality",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf(params);
+		return {
+			sql: `
+      WITH monthly AS (
+        SELECT
+          strftime(date, '%Y-%m') AS month,
+          CAST(SUM(${params.metric === "impressions" ? "impressions" : "clicks"}) AS DOUBLE) AS value
+        FROM read_parquet({{FILES}}, union_by_name = true)
+        WHERE date >= ? AND date <= ?
+        GROUP BY month
+      ),
+      stats AS (
+        SELECT
+          AVG(value) AS avg_val,
+          COALESCE(STDDEV_POP(value), 0.0) AS std_val,
+          CAST(COUNT(*) AS DOUBLE) AS month_count
+        FROM monthly
+      )
+      SELECT
+        m.month AS month,
+        m.value AS value,
+        CASE WHEN s.avg_val > 0 THEN m.value / s.avg_val ELSE 0.0 END AS vsAverage,
+        (s.avg_val > 0 AND m.value / s.avg_val > 1.5) AS isPeak,
+        (s.avg_val > 0 AND m.value / s.avg_val < 0.5) AS isTrough,
+        CASE WHEN s.avg_val > 0 THEN LEAST(s.std_val / s.avg_val, 1.0) ELSE 0.0 END AS strength,
+        s.month_count AS monthCount
+      FROM monthly m, stats s
+      ORDER BY m.month
+    `,
+			params: [startDate, endDate],
+			current: {
+				table: "pages",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const breakdown = arr.map((r) => ({
+			month: str$3(r.month),
+			value: num$4(r.value),
+			vsAverage: num$4(r.vsAverage),
+			isPeak: bool$1(r.isPeak),
+			isTrough: bool$1(r.isTrough)
+		}));
+		const first = arr[0];
+		const strength = first ? num$4(first.strength) : 0;
+		const monthCount = first ? num$4(first.monthCount) : 0;
+		const peakMonths = [...new Set(breakdown.filter((m) => m.isPeak).map((m) => m.month.substring(5, 7)))];
+		const troughMonths = [...new Set(breakdown.filter((m) => m.isTrough).map((m) => m.month.substring(5, 7)))];
+		const hasSeasonality = peakMonths.length > 0 || troughMonths.length > 0 || strength > .3;
+		const insufficientData = monthCount < 12;
+		return {
+			results: breakdown,
+			meta: {
+				total: breakdown.length,
+				hasSeasonality,
+				strength,
+				peakMonths,
+				troughMonths,
+				insufficientData
+			}
+		};
+	},
+	buildRows(params) {
+		return { dates: datesQueryState(periodOf(params), params.limit) };
+	},
+	reduceRows(rows, params) {
+		const result = analyzeSeasonality(Array.isArray(rows) ? rows : [], { metric: params.metric });
+		return {
+			results: result.monthlyBreakdown,
+			meta: { strength: result.strength }
+		};
+	}
+});
+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$4(r.totalImpressions),
+			days: num$4(r.days),
+			seasonalStrength: num$4(r.seasonalStrength),
+			trendStrength: num$4(r.trendStrength),
+			residualAnomalies: num$4(r.residualAnomalies),
+			trendSlope: num$4(r.trendSlope),
+			series: parseJsonList$2(r.seriesJson).map((s) => ({
+				date: str$2(s.date),
+				observed: num$4(s.observed),
+				trend: s.trend == null ? null : num$4(s.trend),
+				seasonal: s.seasonal == null ? null : num$4(s.seasonal),
+				residual: s.residual == null ? null : num$4(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
+			}
+		};
+	}
+});
+const DEFAULT_ROW_LIMIT$1 = 25e3;
+const strikingDistanceAnalyzer = defineAnalyzer({
+	id: "striking-distance",
+	reduce(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const minPosition = params.minPosition ?? 4;
+		const maxPosition = params.maxPosition ?? 20;
+		const minImpressions = params.minImpressions ?? 100;
+		const maxCtr = params.maxCtr ?? .05;
+		const limit = params.limit ?? 1e3;
+		const results = [];
+		for (const row of arr) {
+			const position = num$4(row.position);
+			const impressions = num$4(row.impressions);
+			const ctr = num$4(row.ctr);
+			const clicks = num$4(row.clicks);
+			if (position < minPosition || position > maxPosition) continue;
+			if (impressions < minImpressions) continue;
+			if (ctr > maxCtr) continue;
+			results.push({
+				keyword: String(row.query ?? ""),
+				page: row.page == null ? null : String(row.page),
+				clicks,
+				impressions,
+				ctr,
+				position,
+				potentialClicks: Math.round(impressions * .15)
+			});
+		}
+		results.sort((a, b) => b.potentialClicks - a.potentialClicks);
+		const paged = paginateInMemory(results, {
+			limit,
+			offset: params.offset
+		});
+		return {
+			results: paged,
+			meta: {
+				total: results.length,
+				returned: paged.length
+			}
+		};
+	},
+	buildSql(params) {
+		const { startDate, endDate } = periodOf(params);
+		return {
+			sql: `
+    SELECT
+      query,
+      url AS page,
+      CAST(SUM(clicks) AS DOUBLE) AS clicks,
+      CAST(SUM(impressions) AS DOUBLE) AS impressions,
+      CAST(SUM(clicks) AS DOUBLE) / NULLIF(SUM(impressions), 0) AS ctr,
+      SUM(sum_position) / NULLIF(SUM(impressions), 0) + 1 AS position
+    FROM read_parquet({{FILES}}, union_by_name = true)
+    WHERE date >= ? AND date <= ?
+    GROUP BY query, url
+  `,
+			params: [startDate, endDate],
+			current: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	buildRows(params) {
+		return { keywords: keywordsQueryState(periodOf(params), params.limit ?? DEFAULT_ROW_LIMIT$1) };
+	}
+});
+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$4(p.tenure),
+				survival: num$4(p.survival),
+				atRisk: num$4(p.atRisk),
+				events: num$4(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$4(r.episodeCount),
+				censoringRate: num$4(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$4(s.clicks),
+				impressions: num$4(s.impressions)
+			}));
+			return {
+				[dim === "keywords" ? "query" : "page"]: str(r.entity),
+				totalClicks: num$4(r.totalClicks),
+				totalImpressions: num$4(r.totalImpressions),
+				weeksWithData: num$4(r.weeksWithData),
+				slope: num$4(r.slope),
+				growthRatio: num$4(r.growthRatio),
+				avgPosition: num$4(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 DEFAULT_ROW_LIMIT = 25e3;
+const sortRowResults = createSorter((item) => item.impressions, "impressions");
+const zeroClickAnalyzer = defineAnalyzer({
+	id: "zero-click",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf(params);
+		const minImpressions = params.minImpressions ?? 1e3;
+		const maxCtr = params.maxCtr ?? .03;
+		const maxPosition = params.maxPosition ?? 10;
+		const limit = params.limit ?? 1e3;
+		return {
+			sql: `
+      WITH agg AS (
+        SELECT
+          query,
+          url AS page,
+          ${METRIC_EXPR.clicks} AS clicks,
+          ${METRIC_EXPR.impressions} AS impressions,
+          ${METRIC_EXPR.ctr} AS ctr,
+          ${METRIC_EXPR.position} AS position
+        FROM read_parquet({{FILES}}, union_by_name = true)
+        WHERE date >= ? AND date <= ?
+        GROUP BY query, url
+        HAVING SUM(impressions) >= ?
+      )
+      SELECT
+        query, page, clicks, impressions, ctr, position,
+        CAST(GREATEST(0, ROUND(impressions * (
+          CASE
+            WHEN position <= 1 THEN 0.30
+            WHEN position <= 3 THEN 0.15
+            WHEN position <= 5 THEN 0.08
+            ELSE 0.04
+          END
+        )) - clicks) AS DOUBLE) AS missedClicks
+      FROM agg
+      WHERE position <= ? AND ctr < ?
+      ORDER BY impressions DESC
+      ${paginateClause({
+				limit,
+				offset: params.offset
+			})}
+    `,
+			params: [
+				startDate,
+				endDate,
+				minImpressions,
+				maxPosition,
+				maxCtr
+			],
+			current: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const minImpressions = params.minImpressions ?? 1e3;
+		const maxCtr = params.maxCtr ?? .03;
+		const maxPosition = params.maxPosition ?? 10;
+		return {
+			results: arr.map((r) => ({
+				query: r.query == null ? "" : String(r.query),
+				page: r.page == null ? "" : String(r.page),
+				clicks: num$4(r.clicks),
+				impressions: num$4(r.impressions),
+				ctr: num$4(r.ctr),
+				position: num$4(r.position),
+				missedClicks: num$4(r.missedClicks)
+			})),
+			meta: {
+				total: arr.length,
+				minImpressions,
+				maxCtr,
+				maxPosition
+			}
+		};
+	},
+	buildRows(params) {
+		const period = periodOf(params);
+		const limit = params.limit ?? DEFAULT_ROW_LIMIT;
+		return { rows: gsc.select(query, page).where(between(date, period.startDate, period.endDate)).limit(limit).getState() };
+	},
+	reduceRows(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const minImpressions = params.minImpressions ?? 1e3;
+		const maxCtr = params.maxCtr ?? .03;
+		const maxPosition = params.maxPosition ?? 10;
+		const queryMap = /* @__PURE__ */ new Map();
+		for (const row of arr) {
+			if (row.impressions < minImpressions) continue;
+			if (row.position > maxPosition) continue;
+			if (row.ctr > maxCtr) continue;
+			const existing = queryMap.get(row.query);
+			if (!existing || row.position < existing.position) queryMap.set(row.query, {
+				query: row.query,
+				page: row.page,
+				clicks: row.clicks,
+				impressions: row.impressions,
+				ctr: row.ctr,
+				position: row.position
+			});
+		}
+		const results = sortRowResults(Array.from(queryMap.values()), "impressions", "desc");
+		const paged = paginateInMemory(results, {
+			limit: params.limit,
+			offset: params.offset
+		});
+		return {
+			results: paged,
+			meta: {
+				total: results.length,
+				returned: paged.length
+			}
+		};
+	}
+});
+var AnalyzerCapabilityError = class extends Error {
+	constructor(tool, missing) {
+		super(`analyzer "${tool}" requires capabilities [${missing.join(", ")}] not provided by source`);
+		this.tool = tool;
+		this.missing = missing;
+		this.name = "AnalyzerCapabilityError";
+	}
+};
+function sourceCapabilities(source) {
+	const caps = /* @__PURE__ */ new Set();
+	if (source.executeSql) caps.add("executeSql");
+	if (source.capabilities.fileSets) caps.add("partitionedParquet");
+	if (source.capabilities.regex) caps.add("regex");
+	if (source.capabilities.windowTotals) caps.add("windowTotals");
+	if (source.capabilities.comparisonJoin) caps.add("comparisonJoin");
+	if (source.capabilities.attachedTables) caps.add("attachedTables");
+	return caps;
+}
+function assertSatisfies(analyzer, caps) {
+	const missing = analyzer.requires.filter((c) => !caps.has(c));
+	if (missing.length > 0) throw new AnalyzerCapabilityError(analyzer.id, missing);
+}
+async function runAnalyzerFromSource(source, params, registry) {
+	const caps = sourceCapabilities(source);
+	const analyzer = registry.resolveAnalyzer(params.type, caps.has("executeSql") || caps.has("attachedTables"));
+	if (!analyzer) throw new AnalyzerCapabilityError(params.type, ["executeSql"]);
+	assertSatisfies(analyzer, caps);
+	const plan = analyzer.build(params);
+	if (plan.kind === "rows") return runRowsPlanAgainstSource(source, analyzer, plan, params);
+	return runSqlPlanAgainstSource(source, analyzer, plan, params);
+}
+async function runRowsPlanAgainstSource(source, analyzer, plan, params) {
+	const entries = Object.entries(plan.queries);
+	const resolved = await Promise.all(entries.map(async ([k, q]) => [k, await source.queryRows(q.state)]));
+	const rowMap = Object.fromEntries(resolved);
+	const { results, meta } = analyzer.reduce(rowMap, { params });
+	return {
+		results,
+		meta: {
+			tool: params.type,
+			...meta
+		}
+	};
+}
+function fileSetsFor(plan) {
+	const fileSets = { FILES: plan.current };
+	if (plan.previous) fileSets.FILES_PREV = plan.previous;
+	if (plan.extraFiles) for (const [key, fs] of Object.entries(plan.extraFiles)) fileSets[`FILES_${key}`] = fs;
+	return fileSets;
+}
+async function runSqlPlanAgainstSource(source, analyzer, plan, params) {
+	if (!source.executeSql) throw new AnalyzerCapabilityError(analyzer.id, ["executeSql"]);
+	if (plan.requiresAttachedTables && !source.capabilities.attachedTables) throw new AnalyzerCapabilityError(analyzer.id, ["attachedTables"]);
+	const fileSets = source.capabilities.fileSets ? fileSetsFor(plan) : void 0;
+	const rows = await source.executeSql(plan.sql, plan.params, fileSets ? { fileSets } : void 0);
+	const extras = {};
+	if (plan.extraQueries) for (const q of plan.extraQueries) {
+		const extraRows = await source.executeSql(q.sql, q.params, fileSets ? { fileSets } : void 0);
+		extras[q.name] = extraRows;
+	}
+	const { results, meta } = analyzer.reduce(rows, {
+		params,
+		extras
+	});
+	const sourceMeta = source.capabilities.localSource ? { source: "local" } : {};
+	return {
+		results,
+		meta: {
+			tool: params.type,
+			...sourceMeta,
+			...meta
+		}
+	};
+}
+function createAnalyzerRegistry(init = {}) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const a of init.rows ?? []) {
+		const entry = byId.get(a.id) ?? {};
+		entry.rows = a;
+		byId.set(a.id, entry);
+	}
+	for (const a of init.sql ?? []) {
+		const entry = byId.get(a.id) ?? {};
+		entry.sql = a;
+		byId.set(a.id, entry);
+	}
+	const listAnalyzerIds = () => [...byId.keys()].sort();
+	const getAnalyzerVariants = (id) => byId.get(id);
+	const resolveAnalyzer = (id, sourceSupportsSql) => {
+		const variants = byId.get(id);
+		if (!variants) return void 0;
+		if (sourceSupportsSql) return variants.sql ?? variants.rows;
+		return variants.rows;
+	};
+	const listAnalyzersFor = (sourceSupportsSql) => {
+		const out = [];
+		for (const id of listAnalyzerIds()) {
+			const a = resolveAnalyzer(id, sourceSupportsSql);
+			if (a) out.push(a);
+		}
+		return out;
+	};
+	const listAnalyzerIdsFor = (source) => {
+		const sourceSupportsSql = typeof source.executeSql === "function";
+		const out = [];
+		for (const id of listAnalyzerIds()) if (resolveAnalyzer(id, sourceSupportsSql)) out.push(id);
+		return out;
+	};
+	return {
+		listAnalyzerIds,
+		getAnalyzerVariants,
+		resolveAnalyzer,
+		listAnalyzersFor,
+		listAnalyzerIdsFor
+	};
+}
+const ROW_ANALYZERS = [
+	strikingDistanceAnalyzer.rows,
+	opportunityAnalyzer.rows,
+	brandAnalyzer.rows,
+	concentrationAnalyzer.rows,
+	clusteringAnalyzer.rows,
+	seasonalityAnalyzer.rows,
+	moversAnalyzer.rows,
+	decayAnalyzer.rows,
+	cannibalizationAnalyzer.rows,
+	zeroClickAnalyzer.rows
+];
+export { AnalyzerCapabilityError, ROW_ANALYZERS, bayesianCtrAnalyzer, bipartitePagerankAnalyzer, brandAnalyzer, cannibalizationAnalyzer, changePointAnalyzer, clampLimit, clampOffset, clusteringAnalyzer, concentrationAnalyzer, contentVelocityAnalyzer, createAnalyzerRegistry, ctrAnomalyAnalyzer, ctrCurveAnalyzer, darkTrafficAnalyzer, dataDetailAnalyzer, dataQueryAnalyzer, datesQueryState, decayAnalyzer, defineAnalyzer, deviceGapAnalyzer, intentAtlasAnalyzer, keywordBreadthAnalyzer, keywordsQueryState, longTailAnalyzer, moversAnalyzer, opportunityAnalyzer, pagesQueryState, paginateClause, paginateInMemory, positionDistributionAnalyzer, positionVolatilityAnalyzer, queryMigrationAnalyzer, resolveSort, runAnalyzerFromSource, seasonalityAnalyzer, stlDecomposeAnalyzer, strikingDistanceAnalyzer, survivalAnalyzer, trendsAnalyzer, zeroClickAnalyzer };