@gscdump/analysis 1.0.1 → 1.0.3

package/dist/default-registry.mjs

@@ -1,4892 +1,2 @@
-import { createAnalyzerRegistry, defineAnalyzer, requireAdapter } from "@gscdump/engine/analyzer";
-import { comparisonOf, defaultEndDate, padTimeseries, periodOf } from "@gscdump/engine/period";
-import { enumeratePartitions } from "@gscdump/engine/planner";
-import { METRIC_EXPR } from "@gscdump/engine/sql-fragments";
-import { num } from "@gscdump/engine/analysis-types";
-import { err, ok, unwrapResult } from "gscdump/result";
-import { between, date, extractDateRange, gsc, page, query } from "gscdump/query";
-import { MS_PER_DAY, daysAgoUtc, toIsoDate } from "gscdump/dates";
-import { buildExtrasQueries, buildTotalsSql, mergeExtras, resolveComparisonSQL, resolveToSQLOptimized } from "@gscdump/engine/resolver";
-function rowNumber(value) {
-	if (typeof value === "number") return Number.isFinite(value) ? value : 0;
-	if (typeof value === "bigint") return Number(value);
-	if (value == null) return 0;
-	const n = Number(value);
-	return Number.isFinite(n) ? n : 0;
-}
-function rowString(value) {
-	return value == null ? "" : String(value);
-}
-function rowBoolean(value) {
-	return value === true || value === 1 || value === "true";
-}
-function parseJsonRows(value) {
-	if (Array.isArray(value)) return value;
-	if (typeof value === "string" && value.length > 0) {
-		const parsed = JSON.parse(value);
-		return Array.isArray(parsed) ? parsed : [];
-	}
-	return [];
-}
-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_queries",
-				partitions: enumeratePartitions(startDate, endDate)
-			}
-		};
-	},
-	reduceSql(rows, params) {
-		const arr = Array.isArray(rows) ? rows : [];
-		const minImpressions = params.minImpressions ?? 50;
-		const results = arr.map((r) => ({
-			keyword: rowString(r.keyword),
-			page: rowString(r.page),
-			clicks: rowNumber(r.clicks),
-			impressions: rowNumber(r.impressions),
-			observedCtr: rowNumber(r.observedCtr),
-			position: rowNumber(r.position),
-			bucket: rowNumber(r.bucket),
-			priorAlpha: rowNumber(r.priorAlpha),
-			priorBeta: rowNumber(r.priorBeta),
-			bucketPriorMean: rowNumber(r.bucketPriorMean),
-			posteriorMean: rowNumber(r.posteriorMean),
-			posteriorSd: rowNumber(r.posteriorSd),
-			ciLow: rowNumber(r.ciLow),
-			ciHigh: rowNumber(r.ciHigh),
-			shrinkageDelta: rowNumber(r.shrinkageDelta),
-			expectedClicksDelta: rowNumber(r.expectedClicksDelta),
-			significance: rowNumber(r.significance),
-			classification: rowString(r.classification)
-		}));
-		const under = results.filter((r) => r.classification === "underperforming").length;
-		const over = results.filter((r) => r.classification === "overperforming").length;
-		return {
-			results,
-			meta: {
-				total: results.length,
-				underperforming: under,
-				overperforming: over,
-				expected: results.length - under - over,
-				minImpressions
-			}
-		};
-	}
-});
-const BIPARTITE_PAGERANK_ITERATIONS = 25;
-const BIPARTITE_PAGERANK_DAMPING = .85;
-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_queries",
-				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: rowString(r.kind),
-			id: rowString(r.id),
-			rank: num(r.rank),
-			bridging: num(r.bridging),
-			anchoring: num(r.anchoring),
-			degree: num(r.degree),
-			impressions: num(r.impressions)
-		}));
-		const first = arr[0] ?? {};
-		const queryCount = num(first.queryCount);
-		const urlCount = num(first.urlCount);
-		const deltas = parseJsonRows(first.deltasJson).map((e) => ({
-			step: num(e.step),
-			l1: num(e.l1)
-		}));
-		const convergenceDelta = deltas.length > 0 ? deltas[deltas.length - 1].l1 : 0;
-		return {
-			results,
-			meta: {
-				total: results.length,
-				convergenceDelta,
-				iterations,
-				damping: d,
-				queryCount,
-				urlCount,
-				deltas
-			}
-		};
-	}
-});
-const DEFAULT_LIMIT$1 = 25e3;
-function queriesQueryState(period, limit = DEFAULT_LIMIT$1) {
-	return gsc.select(query, page).where(between(date, period.startDate, period.endDate)).limit(limit).getState();
-}
-function pagesQueryState(period, limit = DEFAULT_LIMIT$1) {
-	return gsc.select(page).where(between(date, period.startDate, period.endDate)).limit(limit).getState();
-}
-function datesQueryState(period, limit = DEFAULT_LIMIT$1) {
-	return gsc.select(date).where(between(date, period.startDate, period.endDate)).limit(limit).getState();
-}
-const analysisErrors = {
-	missingReportParam(report, param, message) {
-		return {
-			kind: "missing-report-param",
-			report,
-			param,
-			message
-		};
-	},
-	missingComparisonWindow(report, message) {
-		return {
-			kind: "missing-comparison-window",
-			report,
-			message
-		};
-	},
-	missingBrandTerms() {
-		return {
-			kind: "missing-brand-terms",
-			message: "Brand analysis requires brandTerms"
-		};
-	},
-	unknownReport(report, available) {
-		return {
-			kind: "unknown-report",
-			report,
-			available,
-			message: `unknown report "${report}"; available: ${available.join(", ")}`
-		};
-	},
-	unknownAnalyzer(analyzer) {
-		return {
-			kind: "unknown-analyzer",
-			analyzer,
-			message: `unknown analyzer "${analyzer}"`
-		};
-	},
-	requiredStepFailed(report, stepKey, stepError, cause) {
-		return {
-			kind: "required-step-failed",
-			report,
-			stepKey,
-			stepError,
-			cause,
-			message: `runReport(${report}): required step "${stepKey}" failed: ${stepError}`
-		};
-	}
-};
-function analysisErrorToException(error) {
-	const exception = new Error(error.message);
-	if ("cause" in error && error.cause !== void 0) exception.cause = error.cause;
-	exception.analysisError = error;
-	return exception;
-}
-function escapeRegexAlt(s) {
-	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function requireBrandTermsResult(brandTerms) {
-	return brandTerms?.length ? ok(brandTerms) : err(analysisErrors.missingBrandTerms());
-}
-function requireBrandTerms(brandTerms) {
-	return unwrapResult(requireBrandTermsResult(brandTerms), analysisErrorToException);
-}
-function analyzeBrandSegmentation(keywords, options) {
-	const { brandTerms, minImpressions = 10 } = options;
-	const lowerBrandTerms = brandTerms.map((t) => t.toLowerCase());
-	const brand = [];
-	const nonBrand = [];
-	let brandClicks = 0;
-	let nonBrandClicks = 0;
-	let brandImpressions = 0;
-	let nonBrandImpressions = 0;
-	for (const row of keywords) {
-		const impressions = num(row.impressions);
-		if (impressions < minImpressions) continue;
-		const clicks = num(row.clicks);
-		if ((row.variants?.length ? row.variants : [row.query ?? row.keyword ?? ""]).some((query) => lowerBrandTerms.some((term) => query.toLowerCase().includes(term)))) {
-			brand.push(row);
-			brandClicks += clicks;
-			brandImpressions += impressions;
-		} else {
-			nonBrand.push(row);
-			nonBrandClicks += clicks;
-			nonBrandImpressions += impressions;
-		}
-	}
-	const totalClicks = brandClicks + nonBrandClicks;
-	return {
-		brand,
-		nonBrand,
-		summary: {
-			brandClicks,
-			nonBrandClicks,
-			brandShare: totalClicks > 0 ? brandClicks / totalClicks : 0,
-			brandImpressions,
-			nonBrandImpressions
-		}
-	};
-}
-const brandAnalyzer = defineAnalyzer({
-	id: "brand",
-	buildSql(params) {
-		const brandTerms = requireBrandTerms(params.brandTerms);
-		const { startDate, endDate } = periodOf(params);
-		const minImpressions = params.minImpressions ?? 10;
-		const limit = params.limit ?? 1e4;
-		const regex = `(${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_queries",
-				partitions: enumeratePartitions(startDate, endDate)
-			}
-		};
-	},
-	reduceSql(rows) {
-		const normalized = (Array.isArray(rows) ? rows : []).map((r) => ({
-			query: rowString(r.query),
-			page: r.page == null ? void 0 : rowString(r.page),
-			clicks: num(r.clicks),
-			impressions: num(r.impressions),
-			ctr: num(r.ctr),
-			position: num(r.position),
-			segment: rowString(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 { queries: queriesQueryState(periodOf(params), params.limit) };
-	},
-	reduceRows(rows, params) {
-		const brandTerms = requireBrandTerms(params.brandTerms);
-		const result = analyzeBrandSegmentation(Array.isArray(rows) ? rows : [], {
-			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 }
-		};
-	}
-});
-function buildPeriodMap(rows, key, value, filter) {
-	const out = /* @__PURE__ */ new Map();
-	for (const row of rows) {
-		if (filter && !filter(row)) continue;
-		out.set(key(row), value(row));
-	}
-	return out;
-}
-function createSorter(getValue, defaultMetric, defaultOrder = "desc") {
-	return (items, sortBy = defaultMetric, sortOrder = defaultOrder) => {
-		const mult = sortOrder === "desc" ? -1 : 1;
-		return [...items].sort((a, b) => (getValue(a, sortBy) - getValue(b, sortBy)) * mult);
-	};
-}
-function createMetricSorter(defaultMetric, orderByMetric) {
-	return (items, sortBy = defaultMetric) => {
-		const mult = orderByMetric[sortBy] === "desc" ? -1 : 1;
-		return [...items].sort((a, b) => (a[sortBy] - b[sortBy]) * mult);
-	};
-}
-const sortRowResults = 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 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;
-		let minPosition = Number.POSITIVE_INFINITY;
-		let maxPosition = Number.NEGATIVE_INFINITY;
-		let totalClicks = 0;
-		let totalImpressions = 0;
-		for (const page of pages) {
-			minPosition = Math.min(minPosition, page.position);
-			maxPosition = Math.max(maxPosition, page.position);
-			totalClicks += page.clicks;
-			totalImpressions += page.impressions;
-		}
-		const positionSpread = maxPosition - minPosition;
-		if (positionSpread > maxPositionSpread) continue;
-		pages.sort((a, b) => b.clicks - a.clicks);
-		results.push({
-			query,
-			pages,
-			totalClicks,
-			totalImpressions,
-			positionSpread
-		});
-	}
-	return sortRowResults(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_queries",
-				partitions: enumeratePartitions(startDate, endDate)
-			}
-		};
-	},
-	reduceSql(rows) {
-		const events = (Array.isArray(rows) ? rows : []).map((r) => ({
-			keyword: rowString(r.keyword),
-			totalImpressions: num(r.totalImpressions),
-			totalClicks: num(r.totalClicks),
-			competitorCount: num(r.competitorCount),
-			leaderUrl: rowString(r.leaderUrl),
-			leaderCtr: num(r.leaderCtr),
-			leaderPosition: num(r.leaderPosition),
-			hhi: num(r.hhi),
-			fragmentation: num(r.fragmentation),
-			stolenClicks: num(r.stolenClicks),
-			severity: num(r.severity),
-			competitors: parseJsonRows(r.competitors).map((c) => ({
-				url: rowString(c.url),
-				clicks: num(c.clicks),
-				impressions: num(c.impressions),
-				ctr: num(c.ctr),
-				position: num(c.position),
-				share: num(c.share),
-				rank: num(c.rank)
-			}))
-		}));
-		const nodeAgg = /* @__PURE__ */ new Map();
-		const edgeAgg = /* @__PURE__ */ new Map();
-		for (const ev of events) {
-			for (const c of ev.competitors) {
-				const n = nodeAgg.get(c.url) ?? {
-					impressions: 0,
-					clicks: 0,
-					queries: /* @__PURE__ */ new Set()
-				};
-				n.impressions += c.impressions;
-				n.clicks += c.clicks;
-				n.queries.add(ev.keyword);
-				nodeAgg.set(c.url, n);
-			}
-			for (let i = 0; i < ev.competitors.length; i++) for (let j = i + 1; j < ev.competitors.length; j++) {
-				const a = ev.competitors[i];
-				const b = ev.competitors[j];
-				const [src, tgt] = a.url < b.url ? [a.url, b.url] : [b.url, a.url];
-				const key = `${src}
${tgt}`;
-				const weight = Math.min(a.impressions, b.impressions);
-				const edge = edgeAgg.get(key) ?? {
-					source: src,
-					target: tgt,
-					weight: 0,
-					queries: 0
-				};
-				edge.weight += weight;
-				edge.queries += 1;
-				edgeAgg.set(key, edge);
-			}
-		}
-		const nodes = [...nodeAgg.entries()].map(([url, n]) => ({
-			url,
-			impressions: n.impressions,
-			clicks: n.clicks,
-			queryCount: n.queries.size
-		}));
-		const edges = [...edgeAgg.values()];
-		const avgFragmentation = events.length > 0 ? events.reduce((s, e) => s + e.fragmentation, 0) / events.length : 0;
-		const totalStolenClicks = events.reduce((s, e) => s + e.stolenClicks, 0);
-		return {
-			results: events,
-			meta: {
-				total: events.length,
-				totalStolenClicks,
-				avgFragmentation,
-				graph: {
-					nodes,
-					edges
-				}
-			}
-		};
-	},
-	buildRows(params) {
-		return { rows: queriesQueryState(periodOf(params), params.limit) };
-	},
-	reduceRows(rows, params) {
-		const results = analyzeCannibalization(Array.isArray(rows) ? rows : [], {
-			minImpressions: params.minImpressions,
-			maxPositionSpread: params.maxPositionSpread,
-			minPages: params.minPages
-		});
-		return {
-			results,
-			meta: { total: results.length }
-		};
-	}
-});
-const changePointAnalyzer = defineAnalyzer({
-	id: "change-point",
-	buildSql(params) {
-		const endDate = params.endDate ?? defaultEndDate();
-		const startDate = params.startDate ?? daysAgoUtc(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)`;
-		const weightExpr = metric === "position" ? METRIC_EXPR.impressions : "1.0";
-		return {
-			sql: `
-    WITH daily AS (
-      SELECT
-        query,
-        url AS page,
-        -- Normalize at the source CTE: union_by_name=true can coerce date to
-        -- VARCHAR across parquets with mixed schemas, which makes downstream
-        -- strftime(date, ...) binder-error.
-        CAST(date AS DATE) AS date,
-        ${METRIC_EXPR.clicks} AS clicks,
-        ${METRIC_EXPR.impressions} AS impressions,
-        ${valueExpr} AS value,
-        ${weightExpr} AS weight
-      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(weight) AS w_total,
-        SUM(value * weight) AS sum_total,
-        SUM(value * value * weight) AS sumsq_total
-      FROM daily
-      GROUP BY query, page
-      HAVING COUNT(*) >= ${Number(minDays)}
-        AND SUM(impressions) >= ?
-    ),
-    filtered AS (
-      SELECT d.*,
-        e.n_total, e.w_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(weight) OVER w AS w_left,
-        SUM(value * weight) OVER w AS sum_left,
-        SUM(value * value * weight) 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,
-        (w_total - w_left) AS w_right,
-        (sum_total - sum_left) AS sum_right,
-        (sumsq_total - sumsq_left) AS sumsq_right,
-        GREATEST(
-          (sumsq_left / NULLIF(w_left, 0))
-            - (sum_left / NULLIF(w_left, 0)) * (sum_left / NULLIF(w_left, 0)),
-          1e-9
-        ) AS var_left,
-        GREATEST(
-          ((sumsq_total - sumsq_left) / NULLIF(w_total - w_left, 0))
-            - ((sum_total - sum_left) / NULLIF(w_total - w_left, 0))
-              * ((sum_total - sum_left) / NULLIF(w_total - w_left, 0)),
-          1e-9
-        ) AS var_right,
-        GREATEST(
-          (sumsq_total / NULLIF(w_total, 0))
-            - (sum_total / NULLIF(w_total, 0)) * (sum_total / NULLIF(w_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(w_left, 0), llr) AS left_mean,
-        arg_max((sum_total - sum_left) / NULLIF(w_total - w_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_queries",
-				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 = rowNumber(r.delta);
-			const improved = lowerIsBetter ? delta < 0 : delta > 0;
-			return {
-				keyword: rowString(r.keyword),
-				page: rowString(r.page),
-				totalDays: rowNumber(r.totalDays),
-				totalImpressions: rowNumber(r.totalImpressions),
-				changeDate: rowString(r.changeDate),
-				llr: rowNumber(r.llr),
-				leftMean: rowNumber(r.leftMean),
-				rightMean: rowNumber(r.rightMean),
-				delta,
-				leftStddev: rowNumber(r.leftStddev),
-				rightStddev: rowNumber(r.rightStddev),
-				direction: improved ? "improved" : "worsened",
-				series: parseJsonRows(r.seriesJson).map((s) => ({
-					date: rowString(s.date),
-					value: rowNumber(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 extractIntentPrefix(keyword) {
-	const lower = keyword.toLowerCase();
-	for (const prefix of INTENT_PREFIXES) if (lower.startsWith(`${prefix} `) || lower.startsWith(prefix)) return prefix;
-	return null;
-}
-function extractWordPrefix(keyword, wordCount = 2) {
-	const words = keyword.toLowerCase().split(WHITESPACE_RE).filter(Boolean);
-	if (words.length < wordCount + 1) return null;
-	return words.slice(0, wordCount).join(" ");
-}
-function analyzeClustering(keywords, options = {}) {
-	const { minClusterSize = 2, minImpressions = 10, clusterBy = "both" } = options;
-	const filtered = keywords.filter((k) => num(k.impressions) >= minImpressions);
-	const clusterMap = /* @__PURE__ */ new Map();
-	const clusteredKeywords = /* @__PURE__ */ new Set();
-	if (clusterBy === "intent" || clusterBy === "both") for (const kw of filtered) {
-		const intent = extractIntentPrefix(kw.query);
-		if (intent) {
-			const existing = clusterMap.get(intent);
-			if (existing) existing.keywords.push(kw);
-			else clusterMap.set(intent, {
-				type: "intent",
-				keywords: [kw]
-			});
-			clusteredKeywords.add(kw.query);
-		}
-	}
-	if (clusterBy === "prefix" || clusterBy === "both") {
-		const prefixMap = /* @__PURE__ */ new Map();
-		for (const kw of filtered) {
-			if (clusteredKeywords.has(kw.query)) continue;
-			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
-			});
-			for (const kw of kws) clusteredKeywords.add(kw.query);
-		}
-	}
-	const clusters = [];
-	for (const [name, data] of clusterMap) {
-		if (data.keywords.length < minClusterSize) continue;
-		let totalClicks = 0;
-		let totalImpressions = 0;
-		let weightedPositionSum = 0;
-		let positionWeight = 0;
-		let positionSum = 0;
-		for (const k of data.keywords) {
-			const impressions = num(k.impressions);
-			const position = num(k.position);
-			totalClicks += num(k.clicks);
-			totalImpressions += impressions;
-			positionSum += position;
-			if (impressions > 0) {
-				weightedPositionSum += (position - 1) * impressions;
-				positionWeight += impressions;
-			}
-		}
-		const avgPosition = positionWeight > 0 ? weightedPositionSum / positionWeight + 1 : positionSum / 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,
-        SUM((position - 1) * impressions) / NULLIF(SUM(impressions), 0) + 1 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: "queries",
-				partitions: enumeratePartitions(startDate, endDate)
-			}
-		};
-	},
-	reduceSql(rows) {
-		const clusters = (Array.isArray(rows) ? rows : []).map((r) => ({
-			clusterName: rowString(r.clusterName),
-			clusterType: rowString(r.clusterType),
-			keywordCount: num(r.keywordCount),
-			totalClicks: num(r.totalClicks),
-			totalImpressions: num(r.totalImpressions),
-			avgPosition: num(r.avgPosition),
-			keywords: parseJsonRows(r.keywords).map((k) => ({
-				query: rowString(k.query),
-				clicks: num(k.clicks),
-				impressions: num(k.impressions),
-				ctr: num(k.ctr),
-				position: num(k.position)
-			}))
-		}));
-		return {
-			results: clusters,
-			meta: {
-				total: clusters.length,
-				totalClusters: clusters.length
-			}
-		};
-	},
-	buildRows(params) {
-		return { queries: queriesQueryState(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 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 n = sorted.length;
-	let totalClicks = 0;
-	let squaredClicks = 0;
-	let weightedSum = 0;
-	for (let i = 0; i < n; i++) {
-		const clicks = sorted[i].clicks;
-		totalClicks += clicks;
-		squaredClicks += clicks * clicks;
-		weightedSum += (n - 2 * i - 1) * clicks;
-	}
-	const giniCoefficient = totalClicks === 0 ? 0 : weightedSum / (n * totalClicks);
-	const hhi = totalClicks > 0 ? squaredClicks / (totalClicks * totalClicks) * 1e4 : 0;
-	const topNItems = sorted.slice(0, topN).map((item) => ({
-		key: item.key,
-		clicks: item.clicks,
-		share: totalClicks > 0 ? item.clicks / totalClicks : 0
-	}));
-	const topNClicks = topNItems.reduce((sum, item) => sum + item.clicks, 0);
-	const topNConcentration = totalClicks > 0 ? topNClicks / totalClicks : 0;
-	let riskLevel = "low";
-	if (hhi > 2500) riskLevel = "high";
-	else if (hhi > 1500) riskLevel = "medium";
-	return {
-		giniCoefficient,
-		hhi,
-		topNConcentration,
-		topNItems,
-		totalItems: items.length,
-		totalClicks,
-		riskLevel
-	};
-}
-function analyzePageConcentration(pages, options) {
-	return analyzeConcentration(pages.map((p) => ({
-		key: p.page,
-		clicks: num(p.clicks)
-	})), options);
-}
-function analyzeKeywordConcentration(keywords, options) {
-	return analyzeConcentration(keywords.map((k) => ({
-		key: k.query,
-		clicks: num(k.clicks)
-	})), options);
-}
-const concentrationAnalyzer = defineAnalyzer({
-	id: "concentration",
-	buildSql(params) {
-		const { startDate, endDate } = periodOf(params);
-		const dim = params.dimension || "pages";
-		const topN = params.topN ?? 10;
-		const table = dim === "keywords" ? "queries" : "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 = parseJsonRows(r.topNItems);
-		return {
-			results: [{
-				giniCoefficient: num(r.giniCoefficient),
-				hhi: num(r.hhi),
-				topNConcentration: num(r.topNConcentration),
-				topNItems: topRaw.map((t) => ({
-					key: rowString(t.key),
-					clicks: num(t.clicks),
-					share: num(t.share)
-				})),
-				totalItems: num(r.totalItems),
-				totalClicks: num(r.totalClicks),
-				riskLevel: rowString(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.queries = queriesQueryState(period, params.limit);
-		return out;
-	},
-	reduceRows(rows, params) {
-		const dim = params.dimension || "pages";
-		const arr = Array.isArray(rows) ? rows : rows[dim === "pages" ? "pages" : "queries"] ?? [];
-		return {
-			results: [dim === "pages" ? analyzePageConcentration(arr, { topN: params.topN }) : analyzeKeywordConcentration(arr, { topN: params.topN })],
-			meta: { dimension: dim }
-		};
-	}
-});
-const contentVelocityAnalyzer = defineAnalyzer({
-	id: "content-velocity",
-	buildSql(params) {
-		const days = Math.min(Math.max(Number(params.days ?? 90), 7), 365);
-		const { endDate } = periodOf(params);
-		const start = new Date(endDate);
-		start.setUTCDate(start.getUTCDate() - days);
-		const startDate = toIsoDate(start);
-		return {
-			sql: `
-    WITH src AS (
-      SELECT query, date
-      FROM read_parquet({{FILES}}, union_by_name = true)
-      WHERE date >= ? AND date <= ? AND impressions > 0
-    ),
-    first_seen AS (
-      SELECT query, MIN(date) AS first_date FROM src GROUP BY query
-    ),
-    per_week AS (
-      SELECT
-        strftime(CAST(date AS DATE), '%G-W%V') AS week,
-        MIN(date) AS week_start,
-        CAST(COUNT(DISTINCT query) AS DOUBLE) AS totalKeywords
-      FROM src
-      GROUP BY week
-    ),
-    new_per_week AS (
-      SELECT
-        strftime(CAST(first_date AS DATE), '%G-W%V') AS week,
-        CAST(COUNT(*) AS DOUBLE) AS newKeywords
-      FROM first_seen
-      GROUP BY week
-    )
-    SELECT
-      pw.week AS week,
-      COALESCE(npw.newKeywords, 0) AS newKeywords,
-      pw.totalKeywords AS totalKeywords
-    FROM per_week pw
-    LEFT JOIN new_per_week npw ON pw.week = npw.week
-    ORDER BY pw.week ASC
-  `,
-			params: [startDate, endDate],
-			current: {
-				table: "queries",
-				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: rowString(r.week),
-			newKeywords: rowNumber(r.newKeywords),
-			totalKeywords: rowNumber(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
-			}
-		};
-	}
-});
-const ctrAnomalyAnalyzer = defineAnalyzer({
-	id: "ctr-anomaly",
-	buildSql(params) {
-		const endDate = params.endDate ?? defaultEndDate();
-		const startDate = params.startDate ?? daysAgoUtc(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,
-        -- Normalize at the source CTE: union_by_name=true can coerce date to
-        -- VARCHAR across parquets with mixed schemas, which makes downstream
-        -- strftime(date, ...) binder-error.
-        CAST(date AS DATE) AS 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,
-        -- Impression-weighted rolling mean: day_position is already a recovered
-        -- 1-based daily weighted mean, so weighting by day impressions directly
-        -- is algebraically exact (no -1/+1 dance needed).
-        SUM(day_position * day_impressions) OVER w
-          / NULLIF(SUM(day_impressions) OVER w, 0) 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,
-        SUM(rolling_position * day_impressions) FILTER (WHERE rolling_n >= ${Number(minRollingN)})
-          / NULLIF(SUM(day_impressions) FILTER (WHERE rolling_n >= ${Number(minRollingN)}), 0) 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_queries",
-				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: rowString(r.keyword),
-			page: rowString(r.page),
-			breachDaysDown: rowNumber(r.breachDaysDown),
-			breachDaysUp: rowNumber(r.breachDaysUp),
-			clicksLost: rowNumber(r.clicksLost),
-			severity: rowNumber(r.severityRaw),
-			maxZ: rowNumber(r.maxZ),
-			baselineCtr: rowNumber(r.baselineCtr),
-			baselinePosition: rowNumber(r.baselinePosition),
-			totalImpressions: rowNumber(r.totalImpressions),
-			totalClicks: rowNumber(r.totalClicks),
-			series: parseJsonRows(r.seriesJson).map((s) => ({
-				date: rowString(s.date),
-				ctr: rowNumber(s.ctr),
-				position: rowNumber(s.position),
-				impressions: rowNumber(s.impressions),
-				rollingCtr: s.rollingCtr == null ? null : rowNumber(s.rollingCtr),
-				rollingStddev: s.rollingStddev == null ? null : rowNumber(s.rollingStddev),
-				z: rowNumber(s.z),
-				breach: rowBoolean(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
-			}
-		};
-	}
-});
-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,
-        (SUM(sum_position) / NULLIF(SUM(impressions), 0) + 1) 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: "queries",
-				partitions: enumeratePartitions(startDate, endDate)
-			}
-		};
-	},
-	reduceSql(rows, params) {
-		const arr = Array.isArray(rows) ? rows : [];
-		const { startDate, endDate } = periodOf(params);
-		const row = arr[0] ?? {};
-		const curve = parseJsonRows(row.curve_json).map((r) => ({
-			bucket: rowString(r.bucket),
-			avgCtr: rowNumber(r.avgCtr),
-			medianPosition: rowNumber(r.medianPosition),
-			keywordCount: rowNumber(r.keywordCount),
-			totalClicks: rowNumber(r.totalClicks),
-			totalImpressions: rowNumber(r.totalImpressions)
-		}));
-		const outliers = parseJsonRows(row.outliers_json).map((r) => ({
-			query: rowString(r.query),
-			clicks: rowNumber(r.clicks),
-			impressions: rowNumber(r.impressions),
-			ctr: rowNumber(r.ctr),
-			position: rowNumber(r.position),
-			expectedCtr: rowNumber(r.expectedCtr),
-			ctrDiff: rowNumber(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
-			}
-		};
-	}
-});
-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: "queries",
-					partitions: enumeratePartitions(startDate, endDate)
-				},
-				PAGE_KEYWORDS: {
-					table: "page_queries",
-					partitions: enumeratePartitions(startDate, endDate)
-				}
-			}
-		};
-	},
-	reduceSql(rows, params) {
-		const arr = Array.isArray(rows) ? rows : [];
-		const { startDate, endDate } = periodOf(params);
-		const row = arr[0] ?? {};
-		const pageTotals = typeof row.page_totals_json === "string" ? JSON.parse(row.page_totals_json) : row.page_totals_json ?? {};
-		const kwTotals = typeof row.kw_totals_json === "string" ? JSON.parse(row.kw_totals_json) : row.kw_totals_json ?? {};
-		const totalClicks = num(pageTotals.totalClicks);
-		const totalImpressions = num(pageTotals.totalImpressions);
-		const attributedClicks = num(kwTotals.attributedClicks);
-		const attributedImpressions = num(kwTotals.attributedImpressions);
-		const darkClicks = Math.max(0, totalClicks - attributedClicks);
-		const darkPercent = totalClicks > 0 ? darkClicks / totalClicks : 0;
-		return {
-			results: parseJsonRows(row.pages_json).map((r) => ({
-				url: rowString(r.url),
-				totalClicks: num(r.totalClicks),
-				attributedClicks: num(r.attributedClicks),
-				darkClicks: num(r.darkClicks),
-				darkPercent: num(r.darkPercent),
-				keywordCount: num(r.keywordCount)
-			})),
-			meta: {
-				summary: {
-					totalClicks,
-					attributedClicks,
-					darkClicks,
-					darkPercent,
-					totalImpressions,
-					attributedImpressions
-				},
-				startDate,
-				endDate
-			}
-		};
-	}
-});
-function requireBuilderState(input, tool) {
-	if (!input || typeof input !== "object" || !("dimensions" in input) || !Array.isArray(input.dimensions)) throw new Error(`${tool}: params.q is required (BuilderState)`);
-	return input;
-}
-function optionalBuilderState(input, tool, key) {
-	if (input == null) return null;
-	if (typeof input !== "object" || !("dimensions" in input) || !Array.isArray(input.dimensions)) throw new Error(`${tool}: params.${key} must be a BuilderState`);
-	return input;
-}
-const NUMERIC_METRIC_COLS = [
-	"clicks",
-	"impressions",
-	"ctr",
-	"position",
-	"prevClicks",
-	"prevImpressions",
-	"prevCtr",
-	"prevPosition",
-	"variantCount",
-	"totalCount"
-];
-function coerceNumericCols(row) {
-	const out = { ...row };
-	for (const col of NUMERIC_METRIC_COLS) if (col in out && out[col] != null) out[col] = Number(out[col]);
-	return out;
-}
-function shapeDataQuery(rows, extras, opts) {
-	let totalCount;
-	let cleaned;
-	let totals;
-	if (opts.hasPrev) {
-		cleaned = rows.map(coerceNumericCols);
-		totalCount = Number((extras?.count?.[0])?.total ?? cleaned.length);
-		const totalsRow = extras?.totals?.[0] ?? {};
-		totals = {
-			clicks: Number(totalsRow.clicks ?? 0),
-			impressions: Number(totalsRow.impressions ?? 0),
-			ctr: Number(totalsRow.ctr ?? 0),
-			position: Number(totalsRow.position ?? 0)
-		};
-	} else {
-		const first = rows[0];
-		totalCount = Number(first?.totalCount ?? 0);
-		totals = {
-			clicks: Number(first?.totalClicks ?? 0),
-			impressions: Number(first?.totalImpressions ?? 0),
-			ctr: Number(first?.totalCtr ?? 0),
-			position: Number(first?.totalPosition ?? 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 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 extraQueries = [...buildExtrasQueries(state, options).map((extra) => ({
-		name: extra.key,
-		sql: extra.sql,
-		params: extra.params
-	}))];
-	const tableKey = options.adapter.inferTable(state.dimensions);
-	if (prev) {
-		const totals = buildTotalsSql(state, options);
-		const comparison = resolveComparisonSQL(state, prev, options, params.comparisonFilter);
-		extraQueries.unshift({
-			name: "totals",
-			sql: totals.sql,
-			params: totals.params
-		});
-		extraQueries.push({
-			name: "count",
-			sql: comparison.countSql,
-			params: comparison.countParams
-		});
-		return {
-			tableKey,
-			sql: comparison.sql,
-			params: comparison.params,
-			extraQueries
-		};
-	}
-	const optimized = resolveToSQLOptimized(state, options);
-	return {
-		tableKey,
-		sql: optimized.sql,
-		params: optimized.params,
-		extraQueries
-	};
-}
-function totalsState(state) {
-	return {
-		...state,
-		dimensions: [],
-		orderBy: void 0,
-		rowLimit: 1
-	};
-}
-function readTotals(row) {
-	return {
-		clicks: Number(row?.clicks ?? 0),
-		impressions: Number(row?.impressions ?? 0),
-		ctr: Number(row?.ctr ?? 0),
-		position: Number(row?.position ?? 0)
-	};
-}
-function buildDataQueryRows(params) {
-	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 queries = {
-		main: state,
-		totals: totalsState(state)
-	};
-	const prev = optionalBuilderState(params.qc, "data-query", "qc");
-	if (prev) {
-		queries.prevMain = prev;
-		queries.prevTotals = totalsState(prev);
-	}
-	return queries;
-}
-function shapeDataQueryRowResults(rowMap, params) {
-	const main = (rowMap.main ?? []).map((r) => coerceNumericCols(r));
-	const totals = readTotals(rowMap.totals?.[0]);
-	if (params.qc == null) return {
-		results: main,
-		meta: {
-			totalCount: main.length,
-			totals
-		}
-	};
-	const state = requireBuilderState(params.q, "data-query");
-	const dims = state.dimensions;
-	const keyOf = (row) => dims.map((d) => String(row[d] ?? "")).join("");
-	const prevByKey = /* @__PURE__ */ new Map();
-	for (const r of rowMap.prevMain ?? []) prevByKey.set(keyOf(r), r);
-	const filter = params.comparisonFilter;
-	const merged = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const cur of main) {
-		const key = keyOf(cur);
-		seen.add(key);
-		const prev = prevByKey.get(key);
-		const row = {
-			...cur,
-			prevClicks: Number(prev?.clicks ?? 0),
-			prevImpressions: Number(prev?.impressions ?? 0),
-			prevCtr: Number(prev?.ctr ?? 0),
-			prevPosition: Number(prev?.position ?? 0)
-		};
-		if (passesComparisonFilter(filter, {
-			isNew: !prev,
-			isLost: false,
-			clicksChange: Number(cur.clicks ?? 0) - Number(prev?.clicks ?? 0)
-		})) merged.push(row);
-	}
-	for (const prev of rowMap.prevMain ?? []) {
-		const p = prev;
-		const key = keyOf(p);
-		if (seen.has(key)) continue;
-		const row = {
-			...p,
-			clicks: 0,
-			impressions: 0,
-			ctr: 0,
-			position: 0,
-			prevClicks: Number(p.clicks ?? 0),
-			prevImpressions: Number(p.impressions ?? 0),
-			prevCtr: Number(p.ctr ?? 0),
-			prevPosition: Number(p.position ?? 0)
-		};
-		if (passesComparisonFilter(filter, {
-			isNew: false,
-			isLost: true,
-			clicksChange: -Number(p.clicks ?? 0)
-		})) merged.push(row);
-	}
-	if (state.orderBy) {
-		const { column, dir } = state.orderBy;
-		merged.sort((a, b) => {
-			const av = Number(a[column]) || 0;
-			const bv = Number(b[column]) || 0;
-			return dir === "asc" ? av - bv : bv - av;
-		});
-	}
-	return {
-		results: merged.map((r) => coerceNumericCols(r)),
-		meta: {
-			totalCount: merged.length,
-			totals
-		}
-	};
-}
-function passesComparisonFilter(filter, ctx) {
-	switch (filter) {
-		case "new": return ctx.isNew;
-		case "lost": return ctx.isLost;
-		case "improving": return ctx.clicksChange > 0;
-		case "declining": return ctx.clicksChange < 0;
-		default: return true;
-	}
-}
-function buildDataDetailRows(params) {
-	const state = requireBuilderState(params.q, "data-detail");
-	if (!state.dimensions.includes("date")) throw new Error("data-detail: `date` dimension is required");
-	const queries = {
-		main: state,
-		totals: totalsState(state)
-	};
-	const prev = optionalBuilderState(params.qc, "data-detail", "qc");
-	if (prev) queries.prevTotals = totalsState(prev);
-	return queries;
-}
-function shapeDataDetailRowResults(rowMap, params) {
-	const { startDate, endDate } = extractDateRange(requireBuilderState(params.q, "data-detail").filter);
-	const coerced = (rowMap.main ?? []).map((r) => coerceNumericCols(r));
-	const daily = startDate && endDate ? padTimeseries(coerced, {
-		startDate,
-		endDate
-	}) : coerced;
-	const meta = { totals: readTotals(rowMap.totals?.[0]) };
-	if (rowMap.prevTotals) meta.previousTotals = readTotals(rowMap.prevTotals[0]);
-	return {
-		results: daily,
-		meta
-	};
-}
-function shapeDataQueryRows(rows, params, extras) {
-	return shapeDataQuery(rows, extras, { hasPrev: params.qc != null });
-}
-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 = resolveToSQLOptimized(state, options);
-	const prev = optionalBuilderState(params.qc, "data-detail", "qc");
-	const extraQueries = [];
-	if (prev) {
-		const previousTotals = buildTotalsSql(prev, options);
-		extraQueries.push({
-			name: "prevTotals",
-			sql: previousTotals.sql,
-			params: previousTotals.params
-		});
-	}
-	return {
-		tableKey: options.adapter.inferTable(state.dimensions),
-		sql: main.sql,
-		params: main.params,
-		extraQueries
-	};
-}
-function shapeDataDetailRows(rows, params, extras) {
-	const { startDate: rangeStart, endDate: rangeEnd } = extractDateRange(requireBuilderState(params.q, "data-detail").filter);
-	const first = rows[0];
-	const totals = {
-		clicks: Number(first?.totalClicks ?? 0),
-		impressions: Number(first?.totalImpressions ?? 0),
-		ctr: Number(first?.totalCtr ?? 0),
-		position: Number(first?.totalPosition ?? 0)
-	};
-	const coerced = rows.map((raw) => {
-		const { totalCount: _tc, totalClicks: _tclk, totalImpressions: _timp, totalCtr: _tctr, totalPosition: _tpos, sum_position: _sp, ...rest } = raw;
-		return coerceNumericCols(rest);
-	});
-	const daily = rangeStart && rangeEnd ? padTimeseries(coerced, {
-		startDate: rangeStart,
-		endDate: rangeEnd
-	}) : coerced;
-	const meta = { totals };
-	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",
-	sqlRequires: [
-		"executeSql",
-		"attachedTables",
-		"adapter"
-	],
-	buildSql(params, ctx) {
-		const plan = buildDataDetailPlan(params, {
-			adapter: requireAdapter(ctx, "data-detail"),
-			siteId: ctx.siteId
-		});
-		return {
-			sql: plan.sql,
-			params: plan.params,
-			current: {
-				table: plan.tableKey,
-				partitions: []
-			},
-			extraQueries: plan.extraQueries
-		};
-	},
-	reduceSql(rows, params, ctx) {
-		const { results, meta } = shapeDataDetailRows(Array.isArray(rows) ? rows : [], params, ctx.extras);
-		return {
-			results,
-			meta
-		};
-	},
-	buildRows(params) {
-		return buildDataDetailRows(params);
-	},
-	reduceRows(rows, params) {
-		const { results, meta } = shapeDataDetailRowResults(Array.isArray(rows) ? {} : rows, params);
-		return {
-			results,
-			meta
-		};
-	}
-});
-const dataQueryAnalyzer = defineAnalyzer({
-	id: "data-query",
-	sqlRequires: [
-		"executeSql",
-		"attachedTables",
-		"adapter"
-	],
-	buildSql(params, ctx) {
-		const plan = buildDataQueryPlan(params, {
-			adapter: requireAdapter(ctx, "data-query"),
-			siteId: ctx.siteId
-		});
-		return {
-			sql: plan.sql,
-			params: plan.params,
-			current: {
-				table: plan.tableKey,
-				partitions: []
-			},
-			extraQueries: plan.extraQueries
-		};
-	},
-	reduceSql(rows, params, ctx) {
-		const { results, meta } = shapeDataQueryRows(Array.isArray(rows) ? rows : [], params, ctx.extras);
-		return {
-			results,
-			meta
-		};
-	},
-	buildRows(params) {
-		return buildDataQueryRows(params);
-	},
-	reduceRows(rows, params) {
-		const { results, meta } = shapeDataQueryRowResults(Array.isArray(rows) ? {} : rows, params);
-		return {
-			results,
-			meta
-		};
-	}
-});
-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 paginateSortedInMemory(rows, input, compare) {
-	const limit = clampLimit(input.limit, rows.length);
-	const offset = clampOffset(input.offset);
-	const selectedCount = Math.min(rows.length, offset + limit);
-	if (limit === 0 || offset >= rows.length || selectedCount === 0) return [];
-	const fullSort = () => [...rows].sort(compare).slice(offset, offset + limit);
-	if (selectedCount >= rows.length / 2) return fullSort();
-	let invalidComparison = false;
-	const compareStable = (left, right) => {
-		const order = compare(left.value, right.value);
-		if (Number.isNaN(order)) {
-			invalidComparison = true;
-			return left.index - right.index;
-		}
-		return order || left.index - right.index;
-	};
-	const isWorse = (left, right) => compareStable(left, right) > 0;
-	const heap = [];
-	const siftUp = (start) => {
-		let index = start;
-		while (index > 0) {
-			const parent = index - 1 >>> 1;
-			if (!isWorse(heap[index], heap[parent])) break;
-			const swap = heap[parent];
-			heap[parent] = heap[index];
-			heap[index] = swap;
-			index = parent;
-		}
-	};
-	const siftDown = () => {
-		let index = 0;
-		for (;;) {
-			const left = index * 2 + 1;
-			if (left >= heap.length) return;
-			const right = left + 1;
-			let worse = left;
-			if (right < heap.length && isWorse(heap[right], heap[left])) worse = right;
-			if (!isWorse(heap[worse], heap[index])) return;
-			const swap = heap[index];
-			heap[index] = heap[worse];
-			heap[worse] = swap;
-			index = worse;
-		}
-	};
-	for (let index = 0; index < rows.length; index++) {
-		const candidate = {
-			value: rows[index],
-			index
-		};
-		if (heap.length < selectedCount) {
-			heap.push(candidate);
-			siftUp(heap.length - 1);
-		} else if (compareStable(candidate, heap[0]) < 0) {
-			heap[0] = candidate;
-			siftDown();
-		}
-	}
-	if (invalidComparison) return fullSort();
-	heap.sort(compareStable);
-	if (invalidComparison) return fullSort();
-	return heap.slice(offset, offset + limit).map((entry) => entry.value);
-}
-const sortResults = createMetricSorter("lostClicks", {
-	lostClicks: "desc",
-	declinePercent: "desc",
-	currentClicks: "asc"
-});
-function analyzeDecay(input, options = {}) {
-	const { minPreviousClicks = 50, threshold = .2, sortBy = "lostClicks" } = options;
-	const currentMap = buildPeriodMap(input.current, (r) => r.page, (r) => ({
-		clicks: num(r.clicks),
-		position: num(r.position)
-	}));
-	const previousMap = buildPeriodMap(input.previous, (r) => r.page, (r) => ({
-		clicks: num(r.clicks),
-		position: num(r.position)
-	}), (r) => num(r.clicks) >= minPreviousClicks);
-	const results = [];
-	for (const [page, prev] of previousMap) {
-		const curr = currentMap.get(page);
-		const currentClicks = curr?.clicks ?? 0;
-		const currentPosition = curr?.position ?? null;
-		const lostClicks = prev.clicks - currentClicks;
-		const declinePercent = prev.clicks > 0 ? lostClicks / prev.clicks : 0;
-		if (declinePercent >= threshold && lostClicks > 0) results.push({
-			page,
-			currentClicks,
-			previousClicks: prev.clicks,
-			lostClicks,
-			declinePercent,
-			currentPosition,
-			previousPosition: prev.position,
-			positionDrop: currentPosition != null ? currentPosition - prev.position : null
-		});
-	}
-	return sortResults(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;
-		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,
-          c.position AS currentPosition,
-          p.position AS previousPosition,
-          CASE WHEN c.position IS NOT NULL THEN (c.position - p.position) ELSE NULL END 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 2000
-    `,
-			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, params) {
-		const mapped = (Array.isArray(rows) ? rows : []).map((r) => ({
-			page: rowString(r.page),
-			currentClicks: num(r.currentClicks),
-			previousClicks: num(r.previousClicks),
-			lostClicks: num(r.lostClicks),
-			declinePercent: num(r.declinePercent),
-			currentPosition: r.currentPosition == null ? null : num(r.currentPosition),
-			previousPosition: num(r.previousPosition),
-			positionDrop: r.positionDrop == null ? null : num(r.positionDrop),
-			series: parseJsonRows(r.seriesJson).map((s) => ({
-				week: rowString(s.week),
-				clicks: num(s.clicks),
-				impressions: num(s.impressions)
-			}))
-		}));
-		return {
-			results: paginateInMemory(mapped, {
-				limit: params.limit ?? 2e3,
-				offset: params.offset
-			}),
-			meta: { total: mapped.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 }
-		};
-	}
-});
-const deviceGapAnalyzer = defineAnalyzer({
-	id: "device-gap",
-	buildSql(params) {
-		const { startDate, endDate } = periodOf(params);
-		return {
-			sql: `
-    WITH raw AS (
-      SELECT
-        date,
-        COALESCE(clicks_desktop, 0) AS c_desktop,
-        COALESCE(clicks_mobile, 0) AS c_mobile,
-        COALESCE(clicks_tablet, 0) AS c_tablet,
-        COALESCE(impressions_desktop, 0) AS i_desktop,
-        COALESCE(impressions_mobile, 0) AS i_mobile,
-        COALESCE(impressions_tablet, 0) AS i_tablet,
-        COALESCE(sum_position_desktop, 0) AS p_desktop,
-        COALESCE(sum_position_mobile, 0) AS p_mobile,
-        COALESCE(sum_position_tablet, 0) AS p_tablet
-      FROM read_parquet({{FILES}}, union_by_name = true)
-      WHERE date >= ? AND date <= ?
-    ),
-    device_long AS (
-      SELECT date, 'DESKTOP' AS device, c_desktop AS clicks, i_desktop AS impressions, p_desktop AS sum_position FROM raw
-      UNION ALL
-      SELECT date, 'MOBILE', c_mobile, i_mobile, p_mobile FROM raw
-      UNION ALL
-      SELECT date, 'TABLET', c_tablet, i_tablet, p_tablet FROM raw
-    )
-    SELECT
-      date,
-      device,
-      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 device_long
-    GROUP BY date, device
-    ORDER BY date ASC
-  `,
-			params: [startDate, endDate],
-			current: {
-				table: "dates",
-				partitions: enumeratePartitions(startDate, endDate)
-			}
-		};
-	},
-	reduceSql(rows, params) {
-		const arr = Array.isArray(rows) ? rows : [];
-		const { startDate, endDate } = periodOf(params);
-		const typed = arr.map((r) => ({
-			date: rowString(r.date),
-			device: rowString(r.device).toUpperCase(),
-			clicks: num(r.clicks),
-			impressions: num(r.impressions),
-			ctr: num(r.ctr),
-			position: num(r.position)
-		}));
-		const byDate = /* @__PURE__ */ new Map();
-		for (const r of typed) {
-			const entry = byDate.get(r.date) ?? {};
-			const metrics = {
-				clicks: r.clicks,
-				impressions: r.impressions,
-				ctr: r.ctr,
-				position: r.position
-			};
-			if (r.device === "DESKTOP") entry.desktop = metrics;
-			else if (r.device === "MOBILE") entry.mobile = metrics;
-			byDate.set(r.date, entry);
-		}
-		const zero = {
-			clicks: 0,
-			impressions: 0,
-			ctr: 0,
-			position: 0
-		};
-		const daily = [...byDate.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([date, sides]) => {
-			const d = sides.desktop ?? zero;
-			const m = sides.mobile ?? zero;
-			return {
-				date,
-				desktop: d,
-				mobile: m,
-				gaps: {
-					ctrGap: d.ctr - m.ctr,
-					positionGap: m.position - d.position
-				}
-			};
-		});
-		const weekly = (start, end) => {
-			const slice = daily.slice(start, end);
-			if (slice.length === 0) return {
-				ctr: 0,
-				pos: 0
-			};
-			const sum = slice.reduce((acc, d) => ({
-				ctr: acc.ctr + d.gaps.ctrGap,
-				pos: acc.pos + d.gaps.positionGap
-			}), {
-				ctr: 0,
-				pos: 0
-			});
-			return {
-				ctr: sum.ctr / slice.length,
-				pos: sum.pos / slice.length
-			};
-		};
-		const first = weekly(0, 7);
-		const last = weekly(Math.max(0, daily.length - 7), daily.length);
-		const classify = (firstVal, lastVal) => {
-			const diff = Math.abs(lastVal) - Math.abs(firstVal);
-			if (Math.abs(diff) < .005) return "stable";
-			return diff < 0 ? "improving" : "worsening";
-		};
-		return {
-			results: daily,
-			meta: {
-				summary: {
-					avgCtrGap: daily.reduce((s, d) => s + d.gaps.ctrGap, 0) / Math.max(1, daily.length),
-					avgPositionGap: daily.reduce((s, d) => s + d.gaps.positionGap, 0) / Math.max(1, daily.length),
-					ctrGapTrend: classify(first.ctr, last.ctr),
-					positionGapTrend: classify(first.pos, last.pos)
-				},
-				startDate,
-				endDate
-			}
-		};
-	}
-});
-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 ?? daysAgoUtc(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,
-      SUM((position - 1) * impressions) / NULLIF(SUM(impressions), 0) + 1 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: "queries",
-				partitions: enumeratePartitions(startDate, endDate)
-			}
-		};
-	},
-	reduceSql(rows) {
-		const clusters = (Array.isArray(rows) ? rows : []).map((r) => ({
-			clusterKey: rowString(r.clusterKey),
-			keywordCount: num(r.keywordCount),
-			totalImpressions: num(r.totalImpressions),
-			totalClicks: num(r.totalClicks),
-			ctr: num(r.ctr),
-			avgPosition: num(r.avgPosition),
-			keywords: parseJsonRows(r.keywords).slice(0, 25).map((k) => ({
-				query: rowString(k.query),
-				impressions: num(k.impressions),
-				clicks: num(k.clicks),
-				position: num(k.position)
-			}))
-		}));
-		const totalImpressions = clusters.reduce((s, c) => s + c.totalImpressions, 0);
-		const totalKeywords = clusters.reduce((s, c) => s + c.keywordCount, 0);
-		return {
-			results: clusters,
-			meta: {
-				total: clusters.length,
-				totalImpressions,
-				totalKeywords
-			}
-		};
-	}
-});
-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 })) 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_queries",
-				partitions: enumeratePartitions(startDate, endDate)
-			}
-		};
-	},
-	reduceSql(rows, params) {
-		const arr = Array.isArray(rows) ? rows : [];
-		const { startDate, endDate } = periodOf(params);
-		const row = arr[0] ?? {};
-		const distribution = parseJsonRows(row.distribution_json).sort((a, b) => num(a.sortKey) - num(b.sortKey)).map((r) => ({
-			bucket: rowString(r.bucket),
-			pageCount: num(r.pageCount)
-		}));
-		const fragile = parseJsonRows(row.fragile_json).map((r) => ({
-			url: rowString(r.url),
-			keywordCount: num(r.keywordCount),
-			clicks: num(r.clicks),
-			impressions: num(r.impressions)
-		}));
-		const authority = parseJsonRows(row.authority_json).map((r) => ({
-			url: rowString(r.url),
-			keywordCount: num(r.keywordCount),
-			clicks: num(r.clicks),
-			impressions: num(r.impressions)
-		}));
-		const stats = typeof row.stats_json === "string" ? JSON.parse(row.stats_json) : row.stats_json ?? {};
-		return {
-			results: distribution,
-			meta: {
-				fragilePages: fragile,
-				authorityPages: authority,
-				summary: {
-					totalPages: num(stats.totalPages),
-					avgKeywordsPerPage: num(stats.avgKeywordsPerPage),
-					fragileCount: num(stats.fragileCount),
-					authorityCount: num(stats.authorityCount)
-				},
-				startDate,
-				endDate
-			}
-		};
-	}
-});
-function downsampleLogRank(points) {
-	const toPoint = (p) => ({
-		rank: num(p.rank),
-		impressions: num(p.impressions),
-		clicks: num(p.clicks),
-		query: rowString(p.query)
-	});
-	if (points.length <= 80) return points.map(toPoint);
-	const sampled = points.slice(0, 10).map(toPoint);
-	let nextThreshold = 1.15;
-	for (let i = 10; i < points.length; i++) {
-		const point = points[i];
-		if (num(point.rank) >= nextThreshold) {
-			sampled.push(toPoint(point));
-			nextThreshold *= 1.15;
-		}
-	}
-	return sampled;
-}
-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 pq 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 pq
-    ),
-    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_queries",
-				partitions: enumeratePartitions(startDate, endDate)
-			}
-		};
-	},
-	reduceSql(rows) {
-		const results = (Array.isArray(rows) ? rows : []).map((r) => ({
-			page: rowString(r.page),
-			queryCount: num(r.queryCount),
-			totalImpressions: num(r.totalImpressions),
-			totalClicks: num(r.totalClicks),
-			slope: num(r.slope),
-			intercept: num(r.intercept),
-			r2: num(r.r2),
-			headImpressions: num(r.headImpressions),
-			headShare: num(r.headShare),
-			fingerprint: rowString(r.fingerprint),
-			points: downsampleLogRank(parseJsonRows(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 withCanonicalFields(r) {
-	return {
-		...r,
-		clicks: r.recentClicks,
-		impressions: r.recentImpressions,
-		ctr: r.recentImpressions > 0 ? r.recentClicks / r.recentImpressions : 0,
-		position: r.recentPosition,
-		prevClicks: r.baselineClicks,
-		prevImpressions: r.baselineImpressions,
-		prevPosition: r.baselinePosition
-	};
-}
-function selectMoversDirection(rising, declining, stable, params) {
-	if (params.direction) {
-		const selected = params.direction === "rising" ? rising : declining;
-		const total = selected.length;
-		const offset = params.offset ?? 0;
-		const limit = params.limit ?? total;
-		return {
-			results: selected.slice(offset, offset + limit),
-			meta: {
-				total,
-				rising: rising.length,
-				declining: declining.length,
-				stable: stable.length
-			}
-		};
-	}
-	const combined = [...rising, ...declining];
-	return {
-		results: combined,
-		meta: {
-			total: combined.length,
-			rising: rising.length,
-			declining: declining.length,
-			stable: stable.length
-		}
-	};
-}
-function analyzeMovers(input, options = {}) {
-	const { changeThreshold = .2, minImpressions = 50, sortBy = "clicksChange" } = options;
-	const normFactor = input.normalizationFactor ?? 1;
-	const baselineMap = buildPeriodMap(input.previous, (r) => r.query, (r) => ({
-		clicks: num(r.clicks) / normFactor,
-		impressions: num(r.impressions) / normFactor,
-		position: num(r.position),
-		page: r.page ?? null
-	}));
-	const pageMap = /* @__PURE__ */ new Map();
-	for (const row of input.current) if (!pageMap.has(row.query) && row.page) pageMap.set(row.query, row.page);
-	for (const row of input.previous) if (!pageMap.has(row.query) && row.page) pageMap.set(row.query, row.page);
-	const rising = [];
-	const declining = [];
-	const stable = [];
-	for (const row of input.current) {
-		const impressions = num(row.impressions);
-		const clicks = num(row.clicks);
-		const position = num(row.position);
-		if (impressions < minImpressions) continue;
-		const baseline = baselineMap.get(row.query);
-		const baselineClicksRaw = baseline?.clicks ?? 0;
-		const baselineImpressionsRaw = baseline?.impressions ?? 0;
-		const baselinePosition = baseline?.position ?? null;
-		const clicksChangePercent = percentDifference(clicks, baselineClicksRaw);
-		const impressionsChangePercent = percentDifference(impressions, baselineImpressionsRaw);
-		const data = {
-			keyword: row.query,
-			page: pageMap.get(row.query) ?? null,
-			recentClicks: clicks,
-			recentImpressions: impressions,
-			recentPosition: position,
-			baselineClicks: Math.round(baselineClicksRaw),
-			baselineImpressions: Math.round(baselineImpressionsRaw),
-			baselinePosition,
-			clicksChange: clicks - Math.round(baselineClicksRaw),
-			clicksChangePercent,
-			impressionsChangePercent,
-			positionChange: baselinePosition != null ? position - baselinePosition : null
-		};
-		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 ?? 0) - Math.abs(a.positionChange ?? 0);
-			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.direction ? 5e3 : 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,
-          p.position 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,
-          CASE WHEN p.position IS NOT NULL THEN (c.position - p.position) ELSE NULL END 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_queries",
-				partitions: enumeratePartitions(cur.startDate, cur.endDate)
-			},
-			previous: {
-				table: "page_queries",
-				partitions: enumeratePartitions(prev.startDate, prev.endDate)
-			}
-		};
-	},
-	reduceSql(rows, params) {
-		const normalized = (Array.isArray(rows) ? rows : []).map((r) => {
-			const recentClicks = num(r.recentClicks);
-			const recentImpressions = num(r.recentImpressions);
-			const recentPosition = num(r.recentPosition);
-			const baselineClicks = Math.round(num(r.baselineClicks));
-			const baselineImpressions = Math.round(num(r.baselineImpressions));
-			const baselinePosition = r.baselinePosition == null ? null : num(r.baselinePosition);
-			return {
-				keyword: rowString(r.keyword),
-				page: r.page == null ? null : rowString(r.page),
-				recentClicks,
-				recentImpressions,
-				recentPosition,
-				baselineClicks,
-				baselineImpressions,
-				baselinePosition,
-				clicksChange: num(r.clicksChange),
-				clicksChangePercent: num(r.clicksChangePercent),
-				impressionsChangePercent: num(r.impressionsChangePercent),
-				positionChange: r.positionChange == null ? null : num(r.positionChange),
-				direction: rowString(r.direction),
-				series: parseJsonRows(r.seriesJson).map((s) => ({
-					week: rowString(s.week),
-					clicks: num(s.clicks),
-					impressions: num(s.impressions)
-				}))
-			};
-		}).map(withCanonicalFields);
-		return selectMoversDirection(normalized.filter((r) => r.direction === "rising"), normalized.filter((r) => r.direction === "declining"), normalized.filter((r) => r.direction === "stable"), params);
-	},
-	buildRows(params) {
-		const { current, previous } = comparisonOf(params);
-		return {
-			current: queriesQueryState(current, params.limit),
-			previous: queriesQueryState(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 selectMoversDirection(result.rising.map((r) => withCanonicalFields({
-			...r,
-			direction: "rising"
-		})), result.declining.map((r) => withCanonicalFields({
-			...r,
-			direction: "declining"
-		})), [], params);
-	}
-});
-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 SORT_DIR = {
-	opportunityScore: "desc",
-	potentialClicks: "desc",
-	impressions: "desc",
-	position: "asc"
-};
-function analyzeOpportunity(keywords, options = {}) {
-	const minImpressions = options.minImpressions ?? 100;
-	const positionWeight = options.weights?.position ?? 1;
-	const impressionsWeight = options.weights?.impressions ?? 1;
-	const ctrGapWeight = options.weights?.ctrGap ?? 1;
-	const totalWeight = positionWeight + impressionsWeight + ctrGapWeight;
-	const sortBy = options.sortBy ?? "opportunityScore";
-	const results = [];
-	for (const row of keywords) {
-		const impressions = num(row.impressions);
-		if (impressions < minImpressions) continue;
-		const position = num(row.position);
-		const ctr = num(row.ctr);
-		const clicks = num(row.clicks);
-		const positionScore = calculatePositionScore(position);
-		const impressionScore = calculateImpressionScore(impressions);
-		const ctrGapScore = calculateCtrGapScore(ctr, position);
-		const weightedProduct = positionScore ** positionWeight * impressionScore ** impressionsWeight * ctrGapScore ** ctrGapWeight;
-		const opportunityScore = Math.round(weightedProduct ** (1 / totalWeight) * 100);
-		const potentialClicks = Math.round(impressions * getExpectedCtr(Math.min(3, position)));
-		results.push({
-			keyword: row.query,
-			page: row.page ?? null,
-			clicks,
-			impressions,
-			ctr,
-			position,
-			opportunityScore,
-			potentialClicks,
-			factors: {
-				positionScore,
-				impressionScore,
-				ctrGapScore
-			}
-		});
-	}
-	const direction = SORT_DIR[sortBy];
-	results.sort((left, right) => direction === "asc" ? left[sortBy] - right[sortBy] : right[sortBy] - left[sortBy]);
-	return options.limit ? results.slice(0, options.limit) : results;
-}
-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 = 3;
-		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_queries",
-				partitions: enumeratePartitions(startDate, endDate)
-			}
-		};
-	},
-	reduceSql(rows) {
-		const arr = Array.isArray(rows) ? rows : [];
-		return {
-			results: arr.map((r) => ({
-				keyword: r.keyword == null ? "" : String(r.keyword),
-				page: r.page == null ? null : String(r.page),
-				clicks: num(r.clicks),
-				impressions: num(r.impressions),
-				ctr: num(r.ctr),
-				position: num(r.position),
-				opportunityScore: num(r.opportunityScore),
-				potentialClicks: num(r.potentialClicks),
-				factors: {
-					positionScore: num(r.positionScore),
-					impressionScore: num(r.impressionScore),
-					ctrGapScore: num(r.ctrGapScore)
-				}
-			})),
-			meta: { total: arr.length }
-		};
-	},
-	buildRows(params) {
-		return { queries: queriesQueryState(periodOf(params), params.limit) };
-	},
-	reduceRows(rows, params) {
-		const results = analyzeOpportunity((Array.isArray(rows) ? rows : []) ?? [], { minImpressions: params.minImpressions });
-		const paged = paginateSortedInMemory(results, {
-			limit: params.limit,
-			offset: params.offset
-		}, (left, right) => right.opportunityScore - left.opportunityScore);
-		return {
-			results: paged,
-			meta: {
-				total: results.length,
-				returned: paged.length
-			}
-		};
-	}
-});
-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: "queries",
-				partitions: enumeratePartitions(startDate, endDate)
-			}
-		};
-	},
-	reduceSql(rows, params) {
-		const arr = Array.isArray(rows) ? rows : [];
-		const { startDate, endDate } = periodOf(params);
-		return {
-			results: arr.map((r) => ({
-				date: rowString(r.date),
-				pos_1_3: num(r.pos_1_3),
-				pos_4_10: num(r.pos_4_10),
-				pos_11_20: num(r.pos_11_20),
-				pos_20_plus: num(r.pos_20_plus),
-				total: num(r.total)
-			})),
-			meta: {
-				total: arr.length,
-				startDate,
-				endDate
-			}
-		};
-	}
-});
-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,
-        -- Normalize at the source CTE: union_by_name=true can coerce date to
-        -- VARCHAR across parquets with mixed schemas, which makes downstream
-        -- strftime(date, ...) binder-error.
-        CAST(date AS DATE) AS 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_queries",
-				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 = rowString(r.page);
-			const date = rowString(r.date);
-			allDates.add(date);
-			const entry = byPage.get(page) ?? {
-				page,
-				avgVolatility: num(r.pageAvgVolatility),
-				peakVolatility: num(r.pagePeakVolatility),
-				totalImpressions: num(r.pageTotalImpressions),
-				days: []
-			};
-			entry.days.push({
-				date,
-				queryCount: num(r.queryCount),
-				dayImpressions: num(r.dayImpressions),
-				avgPosition: num(r.avgPosition),
-				posStddev: num(r.posStddev),
-				bestPosition: num(r.bestPosition),
-				worstPosition: num(r.worstPosition),
-				dodShift: num(r.dodShift),
-				volatility: num(r.volatility)
-			});
-			byPage.set(page, entry);
-		}
-		const pages = [...byPage.values()].sort((a, b) => b.avgVolatility - a.avgVolatility);
-		const dates = [...allDates].sort();
-		const maxVolatility = pages.reduce((m, p) => Math.max(m, p.peakVolatility), 0);
-		return {
-			results: pages,
-			meta: {
-				total: pages.length,
-				dates,
-				maxVolatility
-			}
-		};
-	}
-});
-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_queries",
-				partitions: enumeratePartitions(cur.startDate, cur.endDate)
-			},
-			previous: {
-				table: "page_queries",
-				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: rowString(r.source_page),
-			targetPage: rowString(r.target_page),
-			weight: num(r.weight),
-			queryCount: num(r.query_count),
-			exactCount: num(r.exact_count),
-			fuzzyCount: num(r.query_count) - num(r.exact_count),
-			examples: parseJsonRows(r.examplesJson).slice(0, 8).map((e) => ({
-				sourceQuery: rowString(e.sourceQuery),
-				targetQuery: rowString(e.targetQuery),
-				absorbed: num(e.absorbed),
-				matchType: rowString(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 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(CAST(date AS 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: rowString(r.month),
-			value: num(r.value),
-			vsAverage: num(r.vsAverage),
-			isPeak: rowBoolean(r.isPeak),
-			isTrough: rowBoolean(r.isTrough)
-		}));
-		const first = arr[0];
-		const strength = first ? num(first.strength) : 0;
-		const monthCount = first ? num(first.monthCount) : 0;
-		const peakMonths = [...new Set(breakdown.filter((m) => m.isPeak).map((m) => m.month.substring(5, 7)))];
-		const troughMonths = [...new Set(breakdown.filter((m) => m.isTrough).map((m) => m.month.substring(5, 7)))];
-		const hasSeasonality = peakMonths.length > 0 || troughMonths.length > 0 || strength > .3;
-		const insufficientData = monthCount < 12;
-		return {
-			results: breakdown,
-			meta: {
-				total: breakdown.length,
-				hasSeasonality,
-				strength,
-				peakMonths,
-				troughMonths,
-				insufficientData
-			}
-		};
-	},
-	buildRows(params) {
-		return { dates: datesQueryState(periodOf(params), params.limit) };
-	},
-	reduceRows(rows, params) {
-		const result = analyzeSeasonality(Array.isArray(rows) ? rows : [], { metric: params.metric });
-		return {
-			results: result.monthlyBreakdown,
-			meta: { strength: result.strength }
-		};
-	}
-});
-const stlDecomposeAnalyzer = defineAnalyzer({
-	id: "stl-decompose",
-	buildSql(params) {
-		const endDate = params.endDate ?? defaultEndDate();
-		const startDate = params.startDate ?? daysAgoUtc(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,
-        -- Normalize at the source CTE: union_by_name=true can coerce date to
-        -- VARCHAR across parquets with mixed schemas, which makes downstream
-        -- strftime(date, ...) binder-error.
-        CAST(date AS DATE) AS 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_queries",
-				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: rowString(r.keyword),
-			page: rowString(r.page),
-			totalImpressions: num(r.totalImpressions),
-			days: num(r.days),
-			seasonalStrength: num(r.seasonalStrength),
-			trendStrength: num(r.trendStrength),
-			residualAnomalies: num(r.residualAnomalies),
-			trendSlope: num(r.trendSlope),
-			series: parseJsonRows(r.seriesJson).map((s) => ({
-				date: rowString(s.date),
-				observed: num(s.observed),
-				trend: s.trend == null ? null : num(s.trend),
-				seasonal: s.seasonal == null ? null : num(s.seasonal),
-				residual: s.residual == null ? null : num(s.residual),
-				anomaly: rowBoolean(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;
-function paginateStrikingDistance(results, options) {
-	return paginateSortedInMemory(results, {
-		limit: options.limit ?? 1e3,
-		offset: options.offset
-	}, (left, right) => right.potentialClicks - left.potentialClicks);
-}
-function filterStrikingDistance(rows, options = {}) {
-	const minPosition = options.minPosition ?? 4;
-	const maxPosition = options.maxPosition ?? 20;
-	const minImpressions = options.minImpressions ?? 100;
-	const maxCtr = options.maxCtr ?? .05;
-	const results = [];
-	for (const row of rows) {
-		const position = num(row.position);
-		const impressions = num(row.impressions);
-		const ctr = num(row.ctr);
-		const clicks = num(row.clicks);
-		if (position < minPosition || position > maxPosition) continue;
-		if (impressions < minImpressions) continue;
-		if (ctr > maxCtr) continue;
-		results.push({
-			keyword: String(row.query ?? ""),
-			page: row.page == null ? null : String(row.page),
-			clicks,
-			impressions,
-			ctr,
-			position,
-			potentialClicks: Math.round(impressions * .15)
-		});
-	}
-	return results;
-}
-const strikingDistanceAnalyzer = defineAnalyzer({
-	id: "striking-distance",
-	reduce(rows, params) {
-		const results = filterStrikingDistance(Array.isArray(rows) ? rows : [], params);
-		const paged = paginateStrikingDistance(results, params);
-		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_queries",
-				partitions: enumeratePartitions(startDate, endDate)
-			}
-		};
-	},
-	buildRows(params) {
-		return { queries: queriesQueryState(periodOf(params), params.limit ?? DEFAULT_ROW_LIMIT$1) };
-	}
-});
-const survivalAnalyzer = defineAnalyzer({
-	id: "survival",
-	buildSql(params) {
-		const endDate = params.endDate ?? defaultEndDate();
-		const startDate = params.startDate ?? daysAgoUtc(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_queries",
-				partitions: enumeratePartitions(startDate, endDate)
-			}
-		};
-	},
-	reduceSql(rows, params) {
-		const arr = Array.isArray(rows) ? rows : [];
-		const endDate = params.endDate ?? defaultEndDate();
-		const startDate = params.startDate ?? daysAgoUtc(183);
-		const windowDays = Math.round((new Date(endDate).getTime() - new Date(startDate).getTime()) / MS_PER_DAY) + 1;
-		const results = arr.map((r) => {
-			const curve = parseJsonRows(r.curveJson).map((p) => ({
-				tenure: num(p.tenure),
-				survival: num(p.survival),
-				atRisk: num(p.atRisk),
-				events: num(p.events)
-			}));
-			let medianTenure = 0;
-			for (let i = 0; i < curve.length; i++) {
-				const cur = curve[i];
-				if (cur.survival <= .5) {
-					if (i === 0) medianTenure = cur.tenure;
-					else {
-						const prev = curve[i - 1];
-						const span = prev.survival - cur.survival;
-						const frac = span > 0 ? (prev.survival - .5) / span : 0;
-						medianTenure = prev.tenure + frac * (cur.tenure - prev.tenure);
-					}
-					break;
-				}
-			}
-			const last = curve[curve.length - 1];
-			if (medianTenure === 0 && last && last.survival > .5) medianTenure = last.tenure;
-			return {
-				cohort: rowString(r.cohort),
-				episodeCount: num(r.episodeCount),
-				censoringRate: num(r.censoringRate),
-				medianTenure,
-				curve
-			};
-		});
-		return {
-			results,
-			meta: {
-				totalEpisodes: results.find((r) => r.cohort === "__all__")?.episodeCount ?? 0,
-				cohortCount: results.filter((r) => r.cohort !== "__all__").length,
-				windowDays
-			}
-		};
-	}
-});
-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" ? "queries" : "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 = parseJsonRows(r.seriesJson).map((s) => ({
-				week: rowString(s.week),
-				clicks: num(s.clicks),
-				impressions: num(s.impressions)
-			}));
-			return {
-				[dim === "keywords" ? "query" : "page"]: rowString(r.entity),
-				totalClicks: num(r.totalClicks),
-				totalImpressions: num(r.totalImpressions),
-				weeksWithData: num(r.weeksWithData),
-				slope: num(r.slope),
-				growthRatio: num(r.growthRatio),
-				avgPosition: num(r.avgPosition),
-				trend: rowString(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;
-function analyzeZeroClick(rows, options = {}) {
-	const minImpressions = options.minImpressions ?? 1e3;
-	const maxCtr = options.maxCtr ?? .03;
-	const maxPosition = options.maxPosition ?? 10;
-	const queryMap = /* @__PURE__ */ new Map();
-	for (const row of rows) {
-		if (row.impressions < minImpressions || row.position > maxPosition || row.ctr > maxCtr) continue;
-		const existing = queryMap.get(row.query);
-		if (!existing || row.position < existing.position) queryMap.set(row.query, { ...row });
-	}
-	return [...queryMap.values()].sort((left, right) => right.impressions - left.impressions);
-}
-const defaultAnalyzerRegistry = createAnalyzerRegistry({ defined: [
-	bayesianCtrAnalyzer,
-	bipartitePagerankAnalyzer,
-	brandAnalyzer,
-	cannibalizationAnalyzer,
-	changePointAnalyzer,
-	clusteringAnalyzer,
-	concentrationAnalyzer,
-	contentVelocityAnalyzer,
-	ctrAnomalyAnalyzer,
-	ctrCurveAnalyzer,
-	darkTrafficAnalyzer,
-	dataDetailAnalyzer,
-	dataQueryAnalyzer,
-	decayAnalyzer,
-	deviceGapAnalyzer,
-	intentAtlasAnalyzer,
-	keywordBreadthAnalyzer,
-	longTailAnalyzer,
-	moversAnalyzer,
-	opportunityAnalyzer,
-	positionDistributionAnalyzer,
-	positionVolatilityAnalyzer,
-	queryMigrationAnalyzer,
-	seasonalityAnalyzer,
-	stlDecomposeAnalyzer,
-	strikingDistanceAnalyzer,
-	survivalAnalyzer,
-	trendsAnalyzer,
-	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_queries",
-					partitions: enumeratePartitions(startDate, endDate)
-				}
-			};
-		},
-		reduceSql(rows, params) {
-			const arr = Array.isArray(rows) ? rows : [];
-			const minImpressions = params.minImpressions ?? 1e3;
-			const maxCtr = params.maxCtr ?? .03;
-			const maxPosition = params.maxPosition ?? 10;
-			return {
-				results: arr.map((r) => ({
-					query: r.query == null ? "" : String(r.query),
-					page: r.page == null ? "" : String(r.page),
-					clicks: num(r.clicks),
-					impressions: num(r.impressions),
-					ctr: num(r.ctr),
-					position: num(r.position),
-					missedClicks: num(r.missedClicks)
-				})),
-				meta: {
-					total: arr.length,
-					minImpressions,
-					maxCtr,
-					maxPosition
-				}
-			};
-		},
-		buildRows(params) {
-			const period = periodOf(params);
-			const limit = params.limit ?? DEFAULT_ROW_LIMIT;
-			return { rows: gsc.select(query, page).where(between(date, period.startDate, period.endDate)).limit(limit).getState() };
-		},
-		reduceRows(rows, params) {
-			const results = analyzeZeroClick(Array.isArray(rows) ? rows : [], {
-				minImpressions: params.minImpressions ?? 1e3,
-				maxCtr: params.maxCtr ?? .03,
-				maxPosition: params.maxPosition ?? 10
-			});
-			const paged = paginateSortedInMemory(results, {
-				limit: params.limit,
-				offset: params.offset
-			}, (left, right) => right.impressions - left.impressions);
-			return {
-				results: paged,
-				meta: {
-					total: results.length,
-					returned: paged.length
-				}
-			};
-		}
-	})
-] });
-export { defaultAnalyzerRegistry };
+import { ROW_ANALYZERS, SQL_ANALYZERS, defaultAnalyzerRegistry } from "./_chunks/default-registry.mjs";
+export { ROW_ANALYZERS, SQL_ANALYZERS, defaultAnalyzerRegistry };