@gscdump/analysis 0.7.1 → 0.7.6

package/dist/index.mjs

@@ -1,11 +1,13 @@
+import { AnalyzerCapabilityError, createAnalyzerRegistry, createAnalyzerRegistry as createAnalyzerRegistry$1, defineAnalyzer, defineAnalyzer as defineAnalyzer$1, runAnalyzerFromSource, runAnalyzerFromSource as runAnalyzerFromSource$1 } from "@gscdump/engine/analyzer";
+import { num, num as num$1 } from "@gscdump/engine/analysis-types";
+import { comparisonOf, comparisonOf as comparisonOf$1, defaultEndDate, padTimeseries, padTimeseries as padTimeseries$1, periodOf, periodOf as periodOf$1, resolveWindow, windowToComparisonPeriod, windowToPeriod } from "@gscdump/engine/period";
 import { enumeratePartitions } from "@gscdump/engine/planner";
 import { METRIC_EXPR } from "@gscdump/engine/sql-fragments";
-import { between, date, extractMetricFilters, extractSpecialOperatorFilters, gsc, page, query } from "gscdump/query";
+import { between, date, extractDateRange, gsc, page, query } from "gscdump/query";
+import { ENGINE_QUERY_CAPABILITIES, createAttachedTableSource, createEngineQuerySource, queryComparisonRows, queryRows, queryRows as queryRows$1, rewriteForTableSource, runAnalyzerWithEngine, typedQuery, typedQuery as typedQuery$1 } from "@gscdump/engine/source";
 import { MS_PER_DAY, daysAgo, toIsoDate } from "gscdump";
-import { createEngine as createBrowserQuerySource } from "@gscdump/engine-wasm";
-import { assertDimensionsSupported, getDimensionFilters, getFilterDimensions, isSqlQuerySource, matchesDimensionFilter, matchesMetricFilter, matchesTopLevelPage, metricValue } from "@gscdump/engine/resolver";
-import { buildLogicalPlan } from "gscdump/query/plan";
-import { createEngine as createSqliteQuerySource } from "@gscdump/engine-sqlite";
+import { buildExtrasQueries, buildTotalsSql, isSqlQuerySource, mergeExtras, pgResolverAdapter, resolveComparisonSQL, resolveToSQL, resolveToSQLOptimized } from "@gscdump/engine/resolver";
+import { canProxyToGsc } from "@gscdump/engine-gsc-api";
 function clamp01(value) {
 	if (value < 0) return 0;
 	if (value > 1) return 1;
@@ -20,82 +22,8 @@ function percentDifference(current, previous) {
 	if (previous === 0) return current > 0 ? 100 : 0;
 	return (current - previous) / previous * 100;
 }
-var AnalyzerCapabilityError = class extends Error {
-	constructor(tool, missing) {
-		super(`analyzer "${tool}" requires capabilities [${missing.join(", ")}] not provided by source`);
-		this.tool = tool;
-		this.missing = missing;
-		this.name = "AnalyzerCapabilityError";
-	}
-};
-function sourceCapabilities(source) {
-	const caps = /* @__PURE__ */ new Set();
-	if (source.executeSql) caps.add("executeSql");
-	if (source.capabilities.fileSets) caps.add("partitionedParquet");
-	if (source.capabilities.regex) caps.add("regex");
-	if (source.capabilities.windowTotals) caps.add("windowTotals");
-	if (source.capabilities.comparisonJoin) caps.add("comparisonJoin");
-	if (source.capabilities.attachedTables) caps.add("attachedTables");
-	return caps;
-}
-function assertSatisfies(analyzer, caps) {
-	const missing = analyzer.requires.filter((c) => !caps.has(c));
-	if (missing.length > 0) throw new AnalyzerCapabilityError(analyzer.id, missing);
-}
-async function runAnalyzerFromSource(source, params, registry) {
-	const caps = sourceCapabilities(source);
-	const analyzer = registry.resolveAnalyzer(params.type, caps.has("executeSql") || caps.has("attachedTables"));
-	if (!analyzer) throw new AnalyzerCapabilityError(params.type, ["executeSql"]);
-	assertSatisfies(analyzer, caps);
-	const plan = analyzer.build(params);
-	if (plan.kind === "rows") return runRowsPlanAgainstSource(source, analyzer, plan, params);
-	return runSqlPlanAgainstSource(source, analyzer, plan, params);
-}
-async function runRowsPlanAgainstSource(source, analyzer, plan, params) {
-	const entries = Object.entries(plan.queries);
-	const resolved = await Promise.all(entries.map(async ([k, q]) => [k, await source.queryRows(q.state)]));
-	const rowMap = Object.fromEntries(resolved);
-	const { results, meta } = analyzer.reduce(rowMap, { params });
-	return {
-		results,
-		meta: {
-			tool: params.type,
-			...meta
-		}
-	};
-}
-function fileSetsFor(plan) {
-	const fileSets = { FILES: plan.current };
-	if (plan.previous) fileSets.FILES_PREV = plan.previous;
-	if (plan.extraFiles) for (const [key, fs] of Object.entries(plan.extraFiles)) fileSets[`FILES_${key}`] = fs;
-	return fileSets;
-}
-async function runSqlPlanAgainstSource(source, analyzer, plan, params) {
-	if (!source.executeSql) throw new AnalyzerCapabilityError(analyzer.id, ["executeSql"]);
-	if (plan.requiresAttachedTables && !source.capabilities.attachedTables) throw new AnalyzerCapabilityError(analyzer.id, ["attachedTables"]);
-	const fileSets = source.capabilities.fileSets ? fileSetsFor(plan) : void 0;
-	const rows = await source.executeSql(plan.sql, plan.params, fileSets ? { fileSets } : void 0);
-	const extras = {};
-	if (plan.extraQueries) for (const q of plan.extraQueries) {
-		const extraRows = await source.executeSql(q.sql, q.params, fileSets ? { fileSets } : void 0);
-		extras[q.name] = extraRows;
-	}
-	const { results, meta } = analyzer.reduce(rows, {
-		params,
-		extras
-	});
-	const sourceMeta = source.capabilities.localSource ? { source: "local" } : {};
-	return {
-		results,
-		meta: {
-			tool: params.type,
-			...sourceMeta,
-			...meta
-		}
-	};
-}
 async function analyzeFromSource(source, params, registry) {
-	return runAnalyzerFromSource(source, params, registry);
+	return runAnalyzerFromSource$1(source, params, registry);
 }
 const DEFAULT_SOURCES = [
 	"striking-distance",
@@ -360,48 +288,6 @@ async function analyzeActionPriority(analyzer, options = {}) {
 async function analyzeActionPriorityFromSource(source, registry, options = {}) {
 	return analyzeActionPriority({ analyze: (params) => analyzeFromSource(source, params, registry) }, options);
 }
-function createAnalyzerRegistry(init = {}) {
-	const byId = /* @__PURE__ */ new Map();
-	for (const a of init.rows ?? []) {
-		const entry = byId.get(a.id) ?? {};
-		entry.rows = a;
-		byId.set(a.id, entry);
-	}
-	for (const a of init.sql ?? []) {
-		const entry = byId.get(a.id) ?? {};
-		entry.sql = a;
-		byId.set(a.id, entry);
-	}
-	const listAnalyzerIds = () => [...byId.keys()].sort();
-	const getAnalyzerVariants = (id) => byId.get(id);
-	const resolveAnalyzer = (id, sourceSupportsSql) => {
-		const variants = byId.get(id);
-		if (!variants) return void 0;
-		if (sourceSupportsSql) return variants.sql ?? variants.rows;
-		return variants.rows;
-	};
-	const listAnalyzersFor = (sourceSupportsSql) => {
-		const out = [];
-		for (const id of listAnalyzerIds()) {
-			const a = resolveAnalyzer(id, sourceSupportsSql);
-			if (a) out.push(a);
-		}
-		return out;
-	};
-	const listAnalyzerIdsFor = (source) => {
-		const sourceSupportsSql = typeof source.executeSql === "function";
-		const out = [];
-		for (const id of listAnalyzerIds()) if (resolveAnalyzer(id, sourceSupportsSql)) out.push(id);
-		return out;
-	};
-	return {
-		listAnalyzerIds,
-		getAnalyzerVariants,
-		resolveAnalyzer,
-		listAnalyzersFor,
-		listAnalyzerIdsFor
-	};
-}
 const DEFAULT_LIMIT$1 = 25e3;
 function keywordsQueryState(period, limit = DEFAULT_LIMIT$1) {
 	return gsc.select(query, page).where(between(date, period.startDate, period.endDate)).limit(limit).getState();
@@ -412,244 +298,10 @@ function pagesQueryState(period, limit = DEFAULT_LIMIT$1) {
 function datesQueryState(period, limit = DEFAULT_LIMIT$1) {
 	return gsc.select(date).where(between(date, period.startDate, period.endDate)).limit(limit).getState();
 }
-const DEFAULT_SQL_REQUIRES = ["executeSql", "partitionedParquet"];
-function defineAnalyzer(opts) {
-	const { id, reduce, reduceSql, reduceRows, buildSql, buildRows, sqlRequires = DEFAULT_SQL_REQUIRES, rowsRequires = [] } = opts;
-	const sqlReducer = reduceSql ?? reduce;
-	const rowsReducer = reduceRows ?? reduce;
-	if (buildSql && !sqlReducer) throw new Error(`defineAnalyzer(${id}): buildSql requires reduce or reduceSql`);
-	if (buildRows && !rowsReducer) throw new Error(`defineAnalyzer(${id}): buildRows requires reduce or reduceRows`);
-	const wrap = (fn) => (rows, params, ctx) => {
-		return fn(Array.isArray(rows) ? rows : pickSingle(rows) ?? rows, params, ctx);
-	};
-	return {
-		id,
-		sql: buildSql && sqlReducer ? {
-			id,
-			requires: sqlRequires,
-			build(params) {
-				const spec = buildSql(params);
-				return {
-					kind: "sql",
-					sql: spec.sql,
-					params: spec.params,
-					current: spec.current,
-					previous: spec.previous,
-					extraFiles: spec.extraFiles,
-					extraQueries: spec.extraQueries,
-					requiresAttachedTables: spec.requiresAttachedTables
-				};
-			},
-			reduce(rows, ctx) {
-				const { results, meta } = wrap(sqlReducer)(rows, ctx.params, { extras: ctx.extras });
-				return {
-					results,
-					meta
-				};
-			}
-		} : void 0,
-		rows: buildRows && rowsReducer ? {
-			id,
-			requires: rowsRequires,
-			build(params) {
-				const queries = buildRows(params);
-				return {
-					kind: "rows",
-					queries: Object.fromEntries(Object.entries(queries).map(([k, state]) => [k, { state }]))
-				};
-			},
-			reduce(rows, ctx) {
-				const { results, meta } = wrap(rowsReducer)(rows, ctx.params, {});
-				return {
-					results,
-					meta
-				};
-			}
-		} : void 0
-	};
-}
-function pickSingle(rows) {
-	const keys = Object.keys(rows);
-	return keys.length === 1 ? rows[keys[0]] : void 0;
-}
-function defaultEndDate() {
-	return daysAgo(3);
-}
-function defaultStartDate() {
-	return daysAgo(31);
-}
-function periodOf(params) {
-	return {
-		startDate: params.startDate || defaultStartDate(),
-		endDate: params.endDate || defaultEndDate()
-	};
-}
-function comparisonOf(params) {
-	if (!params.prevStartDate || !params.prevEndDate) throw new Error(`${params.type} analysis requires prevStartDate and prevEndDate`);
-	return {
-		current: periodOf(params),
-		previous: {
-			startDate: params.prevStartDate,
-			endDate: params.prevEndDate
-		}
-	};
-}
-function parseIso(s) {
-	return /* @__PURE__ */ new Date(`${s}T00:00:00Z`);
-}
-function addDays(d, n) {
-	return new Date(d.getTime() + n * MS_PER_DAY);
-}
-function daysBetween(start, end) {
-	return Math.round((parseIso(end).getTime() - parseIso(start).getTime()) / MS_PER_DAY) + 1;
-}
-function resolveWindow(opts) {
-	const anchor = opts.anchor ? parseIso(opts.anchor) : /* @__PURE__ */ new Date();
-	const anchorIso = toIsoDate(anchor);
-	let start;
-	let end;
-	switch (opts.preset) {
-		case "last-7d":
-			end = anchorIso;
-			start = toIsoDate(addDays(anchor, -6));
-			break;
-		case "last-28d":
-			end = anchorIso;
-			start = toIsoDate(addDays(anchor, -27));
-			break;
-		case "last-30d":
-			end = anchorIso;
-			start = toIsoDate(addDays(anchor, -29));
-			break;
-		case "last-90d":
-			end = anchorIso;
-			start = toIsoDate(addDays(anchor, -89));
-			break;
-		case "last-180d":
-			end = anchorIso;
-			start = toIsoDate(addDays(anchor, -179));
-			break;
-		case "last-365d":
-			end = anchorIso;
-			start = toIsoDate(addDays(anchor, -364));
-			break;
-		case "mtd":
-			end = anchorIso;
-			start = toIsoDate(new Date(Date.UTC(anchor.getUTCFullYear(), anchor.getUTCMonth(), 1)));
-			break;
-		case "ytd":
-			end = anchorIso;
-			start = toIsoDate(new Date(Date.UTC(anchor.getUTCFullYear(), 0, 1)));
-			break;
-		case "custom":
-			if (!opts.start || !opts.end) throw new Error("resolveWindow: preset=custom requires start and end");
-			start = opts.start;
-			end = opts.end;
-			break;
-	}
-	const days = daysBetween(start, end);
-	const result = {
-		start,
-		end,
-		days
-	};
-	const mode = opts.comparison ?? "none";
-	if (mode === "prev-period") {
-		const prevEnd = toIsoDate(addDays(parseIso(start), -1));
-		result.comparison = {
-			start: toIsoDate(addDays(parseIso(prevEnd), -(days - 1))),
-			end: prevEnd
-		};
-	} else if (mode === "yoy") {
-		const prevEnd = toIsoDate(addDays(parseIso(end), -365));
-		result.comparison = {
-			start: toIsoDate(addDays(parseIso(start), -365)),
-			end: prevEnd
-		};
-	}
-	return result;
-}
-function windowToPeriod(w) {
-	return {
-		startDate: w.start,
-		endDate: w.end
-	};
-}
-function windowToComparisonPeriod(w) {
-	if (!w.comparison) return void 0;
-	return {
-		current: {
-			startDate: w.start,
-			endDate: w.end
-		},
-		previous: {
-			startDate: w.comparison.start,
-			endDate: w.comparison.end
-		}
-	};
-}
-const DEFAULT_FILL = {
-	clicks: 0,
-	impressions: 0,
-	ctr: 0,
-	position: 0
-};
-function padTimeseries(rows, options) {
-	const { startDate, endDate } = options;
-	const dateKey = options.dateKey ?? "date";
-	const fill = options.fill ?? DEFAULT_FILL;
-	const byDate = /* @__PURE__ */ new Map();
-	for (const row of rows) {
-		const d = String(row[dateKey]);
-		const bucket = byDate.get(d);
-		if (bucket) bucket.push(row);
-		else byDate.set(d, [row]);
-	}
-	const result = [];
-	const start = /* @__PURE__ */ new Date(`${startDate}T00:00:00Z`);
-	const end = /* @__PURE__ */ new Date(`${endDate}T00:00:00Z`);
-	if (Number.isNaN(start.getTime()) || Number.isNaN(end.getTime())) throw new Error(`padTimeseries: invalid date range ${startDate}..${endDate}`);
-	for (let cursorMs = start.getTime(), endMs = end.getTime(); cursorMs <= endMs; cursorMs += MS_PER_DAY) {
-		const dateStr = toIsoDate(new Date(cursorMs));
-		const existing = byDate.get(dateStr);
-		if (existing) result.push(...existing);
-		else result.push({
-			...fill,
-			[dateKey]: dateStr
-		});
-	}
-	return result;
-}
-function num(v) {
-	if (typeof v === "number") return v;
-	if (typeof v === "bigint") return Number(v);
-	if (v == null) return 0;
-	return Number(v);
-}
-function buildPeriodMap(rows, key, value, filter) {
-	const out = /* @__PURE__ */ new Map();
-	for (const row of rows) {
-		if (filter && !filter(row)) continue;
-		out.set(key(row), value(row));
-	}
-	return out;
-}
-function createSorter(getValue, defaultMetric, defaultOrder = "desc") {
-	return (items, sortBy = defaultMetric, sortOrder = defaultOrder) => {
-		const mult = sortOrder === "desc" ? -1 : 1;
-		return [...items].sort((a, b) => (getValue(a, sortBy) - getValue(b, sortBy)) * mult);
-	};
-}
-function createMetricSorter(defaultMetric, orderByMetric) {
-	return (items, sortBy = defaultMetric) => {
-		const mult = orderByMetric[sortBy] === "desc" ? -1 : 1;
-		return [...items].sort((a, b) => (a[sortBy] - b[sortBy]) * mult);
-	};
-}
 function escapeRegexAlt(s) {
 	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function str$6(v) {
+function str$23(v) {
 	return v == null ? "" : String(v);
 }
 function analyzeBrandSegmentation(keywords, options) {
@@ -658,12 +310,12 @@ function analyzeBrandSegmentation(keywords, options) {
 	const brand = [];
 	const nonBrand = [];
 	for (const row of keywords) {
-		if (num(row.impressions) < minImpressions) continue;
+		if (num$1(row.impressions) < minImpressions) continue;
 		if (lowerBrandTerms.some((term) => row.query.toLowerCase().includes(term))) brand.push(row);
 		else nonBrand.push(row);
 	}
-	const brandClicks = brand.reduce((sum, k) => sum + num(k.clicks), 0);
-	const nonBrandClicks = nonBrand.reduce((sum, k) => sum + num(k.clicks), 0);
+	const brandClicks = brand.reduce((sum, k) => sum + num$1(k.clicks), 0);
+	const nonBrandClicks = nonBrand.reduce((sum, k) => sum + num$1(k.clicks), 0);
 	const totalClicks = brandClicks + nonBrandClicks;
 	return {
 		brand,
@@ -672,16 +324,16 @@ function analyzeBrandSegmentation(keywords, options) {
 			brandClicks,
 			nonBrandClicks,
 			brandShare: totalClicks > 0 ? brandClicks / totalClicks : 0,
-			brandImpressions: brand.reduce((sum, k) => sum + num(k.impressions), 0),
-			nonBrandImpressions: nonBrand.reduce((sum, k) => sum + num(k.impressions), 0)
+			brandImpressions: brand.reduce((sum, k) => sum + num$1(k.impressions), 0),
+			nonBrandImpressions: nonBrand.reduce((sum, k) => sum + num$1(k.impressions), 0)
 		}
 	};
 }
-const brandAnalyzer = defineAnalyzer({
+const brandAnalyzer = defineAnalyzer$1({
 	id: "brand",
 	buildSql(params) {
 		if (!params.brandTerms?.length) throw new Error("Brand analysis requires brandTerms");
-		const { startDate, endDate } = periodOf(params);
+		const { startDate, endDate } = periodOf$1(params);
 		const minImpressions = params.minImpressions ?? 10;
 		const limit = params.limit ?? 1e4;
 		const regex = `(${params.brandTerms.map((t) => escapeRegexAlt(t.toLowerCase())).join("|")})`;
@@ -721,13 +373,13 @@ const brandAnalyzer = defineAnalyzer({
 	},
 	reduceSql(rows) {
 		const normalized = (Array.isArray(rows) ? rows : []).map((r) => ({
-			query: str$6(r.query),
-			page: r.page == null ? void 0 : str$6(r.page),
-			clicks: num(r.clicks),
-			impressions: num(r.impressions),
-			ctr: num(r.ctr),
-			position: num(r.position),
-			segment: str$6(r.segment)
+			query: str$23(r.query),
+			page: r.page == null ? void 0 : str$23(r.page),
+			clicks: num$1(r.clicks),
+			impressions: num$1(r.impressions),
+			ctr: num$1(r.ctr),
+			position: num$1(r.position),
+			segment: str$23(r.segment)
 		}));
 		let brandClicks = 0;
 		let nonBrandClicks = 0;
@@ -756,7 +408,7 @@ const brandAnalyzer = defineAnalyzer({
 		};
 	},
 	buildRows(params) {
-		return { keywords: keywordsQueryState(periodOf(params), params.limit) };
+		return { keywords: keywordsQueryState(periodOf$1(params), params.limit) };
 	},
 	reduceRows(rows, params) {
 		if (!params.brandTerms?.length) throw new Error("Brand analysis requires brandTerms");
@@ -776,6 +428,26 @@ const brandAnalyzer = defineAnalyzer({
 		};
 	}
 });
+function buildPeriodMap(rows, key, value, filter) {
+	const out = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		if (filter && !filter(row)) continue;
+		out.set(key(row), value(row));
+	}
+	return out;
+}
+function createSorter(getValue, defaultMetric, defaultOrder = "desc") {
+	return (items, sortBy = defaultMetric, sortOrder = defaultOrder) => {
+		const mult = sortOrder === "desc" ? -1 : 1;
+		return [...items].sort((a, b) => (getValue(a, sortBy) - getValue(b, sortBy)) * mult);
+	};
+}
+function createMetricSorter(defaultMetric, orderByMetric) {
+	return (items, sortBy = defaultMetric) => {
+		const mult = orderByMetric[sortBy] === "desc" ? -1 : 1;
+		return [...items].sort((a, b) => (a[sortBy] - b[sortBy]) * mult);
+	};
+}
 const sortRowResults$1 = createSorter((item, metric) => {
 	switch (metric) {
 		case "clicks": return item.totalClicks;
@@ -784,10 +456,10 @@ const sortRowResults$1 = createSorter((item, metric) => {
 		case "pageCount": return item.pages.length;
 	}
 }, "clicks");
-function str$5(v) {
+function str$22(v) {
 	return v == null ? "" : String(v);
 }
-function parseJsonList$4(v) {
+function parseJsonList$16(v) {
 	if (Array.isArray(v)) return v;
 	if (typeof v === "string" && v.length > 0) {
 		const parsed = JSON.parse(v);
@@ -827,10 +499,10 @@ function analyzeCannibalization(rows, options = {}) {
 	}
 	return sortRowResults$1(results, sortBy, sortOrder);
 }
-const cannibalizationAnalyzer = defineAnalyzer({
+const cannibalizationAnalyzer = defineAnalyzer$1({
 	id: "cannibalization",
 	buildSql(params) {
-		const { startDate, endDate } = periodOf(params);
+		const { startDate, endDate } = periodOf$1(params);
 		const minImpressions = params.minImpressions ?? 50;
 		const minCompetitors = 2;
 		const minQueryImpressions = (params.minImpressions ?? 50) * 2;
@@ -947,25 +619,25 @@ const cannibalizationAnalyzer = defineAnalyzer({
 	},
 	reduceSql(rows) {
 		const events = (Array.isArray(rows) ? rows : []).map((r) => ({
-			keyword: str$5(r.keyword),
-			totalImpressions: num(r.totalImpressions),
-			totalClicks: num(r.totalClicks),
-			competitorCount: num(r.competitorCount),
-			leaderUrl: str$5(r.leaderUrl),
-			leaderCtr: num(r.leaderCtr),
-			leaderPosition: num(r.leaderPosition),
-			hhi: num(r.hhi),
-			fragmentation: num(r.fragmentation),
-			stolenClicks: num(r.stolenClicks),
-			severity: num(r.severity),
-			competitors: parseJsonList$4(r.competitors).map((c) => ({
-				url: str$5(c.url),
-				clicks: num(c.clicks),
-				impressions: num(c.impressions),
-				ctr: num(c.ctr),
-				position: num(c.position),
-				share: num(c.share),
-				rank: num(c.rank)
+			keyword: str$22(r.keyword),
+			totalImpressions: num$1(r.totalImpressions),
+			totalClicks: num$1(r.totalClicks),
+			competitorCount: num$1(r.competitorCount),
+			leaderUrl: str$22(r.leaderUrl),
+			leaderCtr: num$1(r.leaderCtr),
+			leaderPosition: num$1(r.leaderPosition),
+			hhi: num$1(r.hhi),
+			fragmentation: num$1(r.fragmentation),
+			stolenClicks: num$1(r.stolenClicks),
+			severity: num$1(r.severity),
+			competitors: parseJsonList$16(r.competitors).map((c) => ({
+				url: str$22(c.url),
+				clicks: num$1(c.clicks),
+				impressions: num$1(c.impressions),
+				ctr: num$1(c.ctr),
+				position: num$1(c.position),
+				share: num$1(c.share),
+				rank: num$1(c.rank)
 			}))
 		}));
 		const nodeAgg = /* @__PURE__ */ new Map();
@@ -1022,7 +694,7 @@ const cannibalizationAnalyzer = defineAnalyzer({
 		};
 	},
 	buildRows(params) {
-		return { rows: keywordsQueryState(periodOf(params), params.limit) };
+		return { rows: keywordsQueryState(periodOf$1(params), params.limit) };
 	},
 	reduceRows(rows, params) {
 		const results = analyzeCannibalization(Array.isArray(rows) ? rows : [], {
@@ -1057,10 +729,10 @@ const INTENT_PREFIXES = [
 	"near me"
 ];
 const WHITESPACE_RE$1 = /\s+/;
-function str$4(v) {
+function str$21(v) {
 	return v == null ? "" : String(v);
 }
-function parseJsonList$3(v) {
+function parseJsonList$15(v) {
 	if (Array.isArray(v)) return v;
 	if (typeof v === "string" && v.length > 0) {
 		const parsed = JSON.parse(v);
@@ -1080,7 +752,7 @@ function extractWordPrefix(keyword, wordCount = 2) {
 }
 function analyzeClustering(keywords, options = {}) {
 	const { minClusterSize = 2, minImpressions = 10, clusterBy = "both" } = options;
-	const filtered = keywords.filter((k) => num(k.impressions) >= minImpressions);
+	const filtered = keywords.filter((k) => num$1(k.impressions) >= minImpressions);
 	const clusterMap = /* @__PURE__ */ new Map();
 	const clusteredKeywords = /* @__PURE__ */ new Set();
 	if (clusterBy === "intent" || clusterBy === "both") for (const kw of filtered) {
@@ -1117,9 +789,9 @@ function analyzeClustering(keywords, options = {}) {
 	const clusters = [];
 	for (const [name, data] of clusterMap) {
 		if (data.keywords.length < minClusterSize) continue;
-		const totalClicks = data.keywords.reduce((sum, k) => sum + num(k.clicks), 0);
-		const totalImpressions = data.keywords.reduce((sum, k) => sum + num(k.impressions), 0);
-		const avgPosition = data.keywords.reduce((sum, k) => sum + num(k.position), 0) / data.keywords.length;
+		const totalClicks = data.keywords.reduce((sum, k) => sum + num$1(k.clicks), 0);
+		const totalImpressions = data.keywords.reduce((sum, k) => sum + num$1(k.impressions), 0);
+		const avgPosition = data.keywords.reduce((sum, k) => sum + num$1(k.position), 0) / data.keywords.length;
 		clusters.push({
 			clusterName: name,
 			clusterType: data.type,
@@ -1136,10 +808,10 @@ function analyzeClustering(keywords, options = {}) {
 		unclustered: filtered.filter((kw) => !clusteredKeywords.has(kw.query))
 	};
 }
-const clusteringAnalyzer = defineAnalyzer({
+const clusteringAnalyzer = defineAnalyzer$1({
 	id: "clustering",
 	buildSql(params) {
-		const { startDate, endDate } = periodOf(params);
+		const { startDate, endDate } = periodOf$1(params);
 		const minImpressions = params.minImpressions ?? 10;
 		const minClusterSize = params.minClusterSize ?? 2;
 		const clusterBy = params.clusterBy ?? "both";
@@ -1205,18 +877,18 @@ const clusteringAnalyzer = defineAnalyzer({
 	},
 	reduceSql(rows) {
 		const clusters = (Array.isArray(rows) ? rows : []).map((r) => ({
-			clusterName: str$4(r.clusterName),
-			clusterType: str$4(r.clusterType),
-			keywordCount: num(r.keywordCount),
-			totalClicks: num(r.totalClicks),
-			totalImpressions: num(r.totalImpressions),
-			avgPosition: num(r.avgPosition),
-			keywords: parseJsonList$3(r.keywords).map((k) => ({
-				query: str$4(k.query),
-				clicks: num(k.clicks),
-				impressions: num(k.impressions),
-				ctr: num(k.ctr),
-				position: num(k.position)
+			clusterName: str$21(r.clusterName),
+			clusterType: str$21(r.clusterType),
+			keywordCount: num$1(r.keywordCount),
+			totalClicks: num$1(r.totalClicks),
+			totalImpressions: num$1(r.totalImpressions),
+			avgPosition: num$1(r.avgPosition),
+			keywords: parseJsonList$15(r.keywords).map((k) => ({
+				query: str$21(k.query),
+				clicks: num$1(k.clicks),
+				impressions: num$1(k.impressions),
+				ctr: num$1(k.ctr),
+				position: num$1(k.position)
 			}))
 		}));
 		return {
@@ -1228,7 +900,7 @@ const clusteringAnalyzer = defineAnalyzer({
 		};
 	},
 	buildRows(params) {
-		return { keywords: keywordsQueryState(periodOf(params), params.limit) };
+		return { keywords: keywordsQueryState(periodOf$1(params), params.limit) };
 	},
 	reduceRows(rows, params) {
 		const result = analyzeClustering(Array.isArray(rows) ? rows : [], {
@@ -1242,10 +914,10 @@ const clusteringAnalyzer = defineAnalyzer({
 		};
 	}
 });
-function str$3(v) {
+function str$20(v) {
 	return v == null ? "" : String(v);
 }
-function parseJsonList$2(v) {
+function parseJsonList$14(v) {
 	if (Array.isArray(v)) return v;
 	if (typeof v === "string" && v.length > 0) {
 		const parsed = JSON.parse(v);
@@ -1306,19 +978,19 @@ function analyzeConcentration(items, options = {}) {
 function analyzePageConcentration(pages, options) {
 	return analyzeConcentration(pages.map((p) => ({
 		key: p.page,
-		clicks: num(p.clicks)
+		clicks: num$1(p.clicks)
 	})), options);
 }
 function analyzeKeywordConcentration(keywords, options) {
 	return analyzeConcentration(keywords.map((k) => ({
 		key: k.query,
-		clicks: num(k.clicks)
+		clicks: num$1(k.clicks)
 	})), options);
 }
-const concentrationAnalyzer = defineAnalyzer({
+const concentrationAnalyzer = defineAnalyzer$1({
 	id: "concentration",
 	buildSql(params) {
-		const { startDate, endDate } = periodOf(params);
+		const { startDate, endDate } = periodOf$1(params);
 		const dim = params.dimension || "pages";
 		const topN = params.topN ?? 10;
 		const table = dim === "keywords" ? "keywords" : "pages";
@@ -1393,20 +1065,20 @@ const concentrationAnalyzer = defineAnalyzer({
 	},
 	reduceSql(rows, params) {
 		const r = (Array.isArray(rows) ? rows : [])[0] ?? {};
-		const topRaw = parseJsonList$2(r.topNItems);
+		const topRaw = parseJsonList$14(r.topNItems);
 		return {
 			results: [{
-				giniCoefficient: num(r.giniCoefficient),
-				hhi: num(r.hhi),
-				topNConcentration: num(r.topNConcentration),
+				giniCoefficient: num$1(r.giniCoefficient),
+				hhi: num$1(r.hhi),
+				topNConcentration: num$1(r.topNConcentration),
 				topNItems: topRaw.map((t) => ({
-					key: str$3(t.key),
-					clicks: num(t.clicks),
-					share: num(t.share)
+					key: str$20(t.key),
+					clicks: num$1(t.clicks),
+					share: num$1(t.share)
 				})),
-				totalItems: num(r.totalItems),
-				totalClicks: num(r.totalClicks),
-				riskLevel: str$3(r.riskLevel)
+				totalItems: num$1(r.totalItems),
+				totalClicks: num$1(r.totalClicks),
+				riskLevel: str$20(r.riskLevel)
 			}],
 			meta: {
 				total: 1,
@@ -1416,7 +1088,7 @@ const concentrationAnalyzer = defineAnalyzer({
 	},
 	buildRows(params) {
 		const dim = params.dimension || "pages";
-		const period = periodOf(params);
+		const period = periodOf$1(params);
 		const out = {};
 		if (dim === "pages") out.pages = pagesQueryState(period, params.limit);
 		else out.keywords = keywordsQueryState(period, params.limit);
@@ -1436,10 +1108,10 @@ const sortResults$2 = createMetricSorter("lostClicks", {
 	declinePercent: "desc",
 	currentClicks: "asc"
 });
-function str$2(v) {
+function str$19(v) {
 	return v == null ? "" : String(v);
 }
-function parseJsonList$1(v) {
+function parseJsonList$13(v) {
 	if (Array.isArray(v)) return v;
 	if (typeof v === "string" && v.length > 0) {
 		const parsed = JSON.parse(v);
@@ -1450,13 +1122,13 @@ function parseJsonList$1(v) {
 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)
+		clicks: num$1(r.clicks),
+		position: num$1(r.position)
 	}));
 	const previousMap = buildPeriodMap(input.previous, (r) => r.page, (r) => ({
-		clicks: num(r.clicks),
-		position: num(r.position)
-	}), (r) => num(r.clicks) >= minPreviousClicks);
+		clicks: num$1(r.clicks),
+		position: num$1(r.position)
+	}), (r) => num$1(r.clicks) >= minPreviousClicks);
 	const results = [];
 	for (const [page, prev] of previousMap) {
 		const curr = currentMap.get(page) || {
@@ -1478,10 +1150,10 @@ function analyzeDecay(input, options = {}) {
 	}
 	return sortResults$2(results, sortBy);
 }
-const decayAnalyzer = defineAnalyzer({
+const decayAnalyzer = defineAnalyzer$1({
 	id: "decay",
 	buildSql(params) {
-		const { current: cur, previous: prev } = comparisonOf(params);
+		const { current: cur, previous: prev } = comparisonOf$1(params);
 		const minPreviousClicks = params.minPreviousClicks ?? 50;
 		const threshold = params.threshold ?? .2;
 		const limit = params.limit ?? 2e3;
@@ -1576,25 +1248,25 @@ const decayAnalyzer = defineAnalyzer({
 		const arr = Array.isArray(rows) ? rows : [];
 		return {
 			results: arr.map((r) => ({
-				page: str$2(r.page),
-				currentClicks: num(r.currentClicks),
-				previousClicks: num(r.previousClicks),
-				lostClicks: num(r.lostClicks),
-				declinePercent: num(r.declinePercent),
-				currentPosition: num(r.currentPosition),
-				previousPosition: num(r.previousPosition),
-				positionDrop: num(r.positionDrop),
-				series: parseJsonList$1(r.seriesJson).map((s) => ({
-					week: str$2(s.week),
-					clicks: num(s.clicks),
-					impressions: num(s.impressions)
+				page: str$19(r.page),
+				currentClicks: num$1(r.currentClicks),
+				previousClicks: num$1(r.previousClicks),
+				lostClicks: num$1(r.lostClicks),
+				declinePercent: num$1(r.declinePercent),
+				currentPosition: num$1(r.currentPosition),
+				previousPosition: num$1(r.previousPosition),
+				positionDrop: num$1(r.positionDrop),
+				series: parseJsonList$13(r.seriesJson).map((s) => ({
+					week: str$19(s.week),
+					clicks: num$1(s.clicks),
+					impressions: num$1(s.impressions)
 				}))
 			})),
 			meta: { total: arr.length }
 		};
 	},
 	buildRows(params) {
-		const { current, previous } = comparisonOf(params);
+		const { current, previous } = comparisonOf$1(params);
 		return {
 			current: pagesQueryState(current, params.limit),
 			previous: pagesQueryState(previous, params.limit)
@@ -1618,10 +1290,10 @@ const decayAnalyzer = defineAnalyzer({
 		};
 	}
 });
-function str$1(v) {
+function str$18(v) {
 	return v == null ? "" : String(v);
 }
-function parseJsonList(v) {
+function parseJsonList$12(v) {
 	if (Array.isArray(v)) return v;
 	if (typeof v === "string" && v.length > 0) {
 		const parsed = JSON.parse(v);
@@ -1633,9 +1305,9 @@ 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),
+		clicks: num$1(r.clicks) / normFactor,
+		impressions: num$1(r.impressions) / normFactor,
+		position: num$1(r.position),
 		page: r.page ?? null
 	}));
 	const pageMap = /* @__PURE__ */ new Map();
@@ -1645,9 +1317,9 @@ function analyzeMovers(input, options = {}) {
 	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);
+		const impressions = num$1(row.impressions);
+		const clicks = num$1(row.clicks);
+		const position = num$1(row.position);
 		if (impressions < minImpressions) continue;
 		const baseline = baselineMap.get(row.query) || {
 			clicks: 0,
@@ -1695,10 +1367,10 @@ function analyzeMovers(input, options = {}) {
 		stable
 	};
 }
-const moversAnalyzer = defineAnalyzer({
+const moversAnalyzer = defineAnalyzer$1({
 	id: "movers",
 	buildSql(params) {
-		const { current: cur, previous: prev } = comparisonOf(params);
+		const { current: cur, previous: prev } = comparisonOf$1(params);
 		const minImpressions = params.minImpressions ?? 50;
 		const changeThreshold = params.changeThreshold ?? .2;
 		const limit = params.limit ?? 2e3;
@@ -1808,23 +1480,23 @@ const moversAnalyzer = defineAnalyzer({
 	},
 	reduceSql(rows) {
 		const normalized = (Array.isArray(rows) ? rows : []).map((r) => ({
-			keyword: str$1(r.keyword),
-			page: r.page == null ? null : str$1(r.page),
-			recentClicks: num(r.recentClicks),
-			recentImpressions: num(r.recentImpressions),
-			recentPosition: num(r.recentPosition),
-			baselineClicks: Math.round(num(r.baselineClicks)),
-			baselineImpressions: Math.round(num(r.baselineImpressions)),
-			baselinePosition: num(r.baselinePosition),
-			clicksChange: num(r.clicksChange),
-			clicksChangePercent: num(r.clicksChangePercent),
-			impressionsChangePercent: num(r.impressionsChangePercent),
-			positionChange: num(r.positionChange),
-			direction: str$1(r.direction),
-			series: parseJsonList(r.seriesJson).map((s) => ({
-				week: str$1(s.week),
-				clicks: num(s.clicks),
-				impressions: num(s.impressions)
+			keyword: str$18(r.keyword),
+			page: r.page == null ? null : str$18(r.page),
+			recentClicks: num$1(r.recentClicks),
+			recentImpressions: num$1(r.recentImpressions),
+			recentPosition: num$1(r.recentPosition),
+			baselineClicks: Math.round(num$1(r.baselineClicks)),
+			baselineImpressions: Math.round(num$1(r.baselineImpressions)),
+			baselinePosition: num$1(r.baselinePosition),
+			clicksChange: num$1(r.clicksChange),
+			clicksChangePercent: num$1(r.clicksChangePercent),
+			impressionsChangePercent: num$1(r.impressionsChangePercent),
+			positionChange: num$1(r.positionChange),
+			direction: str$18(r.direction),
+			series: parseJsonList$12(r.seriesJson).map((s) => ({
+				week: str$18(s.week),
+				clicks: num$1(s.clicks),
+				impressions: num$1(s.impressions)
 			}))
 		}));
 		const rising = normalized.filter((r) => r.direction === "rising");
@@ -1842,7 +1514,7 @@ const moversAnalyzer = defineAnalyzer({
 		};
 	},
 	buildRows(params) {
-		const { current, previous } = comparisonOf(params);
+		const { current, previous } = comparisonOf$1(params);
 		return {
 			current: keywordsQueryState(current, params.limit),
 			previous: keywordsQueryState(previous, params.limit)
@@ -1934,10 +1606,10 @@ const sortResults$1 = createMetricSorter("opportunityScore", {
 	impressions: "desc",
 	position: "asc"
 });
-const opportunityAnalyzer = defineAnalyzer({
+const opportunityAnalyzer = defineAnalyzer$1({
 	id: "opportunity",
 	buildSql(params) {
-		const { startDate, endDate } = periodOf(params);
+		const { startDate, endDate } = periodOf$1(params);
 		const minImpressions = params.minImpressions ?? 100;
 		const w1 = 1;
 		const w2 = 1;
@@ -2028,23 +1700,23 @@ const opportunityAnalyzer = defineAnalyzer({
 			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),
+				clicks: num$1(r.clicks),
+				impressions: num$1(r.impressions),
+				ctr: num$1(r.ctr),
+				position: num$1(r.position),
+				opportunityScore: num$1(r.opportunityScore),
+				potentialClicks: num$1(r.potentialClicks),
 				factors: {
-					positionScore: num(r.positionScore),
-					impressionScore: num(r.impressionScore),
-					ctrGapScore: num(r.ctrGapScore)
+					positionScore: num$1(r.positionScore),
+					impressionScore: num$1(r.impressionScore),
+					ctrGapScore: num$1(r.ctrGapScore)
 				}
 			})),
 			meta: { total: arr.length }
 		};
 	},
 	buildRows(params) {
-		return { keywords: keywordsQueryState(periodOf(params), params.limit) };
+		return { keywords: keywordsQueryState(periodOf$1(params), params.limit) };
 	},
 	reduceRows(rows, params) {
 		const keywords = (Array.isArray(rows) ? rows : []) ?? [];
@@ -2055,10 +1727,10 @@ const opportunityAnalyzer = defineAnalyzer({
 		const sortBy = "opportunityScore";
 		const results = [];
 		for (const row of keywords) {
-			const impressions = num(row.impressions);
-			const position = num(row.position);
-			const ctr = num(row.ctr);
-			const clicks = num(row.clicks);
+			const impressions = num$1(row.impressions);
+			const position = num$1(row.position);
+			const ctr = num$1(row.ctr);
+			const clicks = num$1(row.clicks);
 			if (impressions < minImpressions) continue;
 			const positionScore = calculatePositionScore(position);
 			const impressionScore = calculateImpressionScore(impressions);
@@ -2097,10 +1769,10 @@ const opportunityAnalyzer = defineAnalyzer({
 		};
 	}
 });
-function str(v) {
+function str$17(v) {
 	return v == null ? "" : String(v);
 }
-function bool(v) {
+function bool$2(v) {
 	return v === true || v === 1 || v === "true";
 }
 function calculateCV(values) {
@@ -2154,10 +1826,10 @@ function analyzeSeasonality(dates, options = {}) {
 		insufficientData
 	};
 }
-const seasonalityAnalyzer = defineAnalyzer({
+const seasonalityAnalyzer = defineAnalyzer$1({
 	id: "seasonality",
 	buildSql(params) {
-		const { startDate, endDate } = periodOf(params);
+		const { startDate, endDate } = periodOf$1(params);
 		return {
 			sql: `
       WITH monthly AS (
@@ -2196,15 +1868,15 @@ const seasonalityAnalyzer = defineAnalyzer({
 	reduceSql(rows) {
 		const arr = Array.isArray(rows) ? rows : [];
 		const breakdown = arr.map((r) => ({
-			month: str(r.month),
-			value: num(r.value),
-			vsAverage: num(r.vsAverage),
-			isPeak: bool(r.isPeak),
-			isTrough: bool(r.isTrough)
+			month: str$17(r.month),
+			value: num$1(r.value),
+			vsAverage: num$1(r.vsAverage),
+			isPeak: bool$2(r.isPeak),
+			isTrough: bool$2(r.isTrough)
 		}));
 		const first = arr[0];
-		const strength = first ? num(first.strength) : 0;
-		const monthCount = first ? num(first.monthCount) : 0;
+		const strength = first ? num$1(first.strength) : 0;
+		const monthCount = first ? num$1(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;
@@ -2222,7 +1894,7 @@ const seasonalityAnalyzer = defineAnalyzer({
 		};
 	},
 	buildRows(params) {
-		return { dates: datesQueryState(periodOf(params), params.limit) };
+		return { dates: datesQueryState(periodOf$1(params), params.limit) };
 	},
 	reduceRows(rows, params) {
 		const result = analyzeSeasonality(Array.isArray(rows) ? rows : [], { metric: params.metric });
@@ -2233,7 +1905,7 @@ const seasonalityAnalyzer = defineAnalyzer({
 	}
 });
 const DEFAULT_ROW_LIMIT$1 = 25e3;
-const strikingDistanceAnalyzer = defineAnalyzer({
+const strikingDistanceAnalyzer = defineAnalyzer$1({
 	id: "striking-distance",
 	reduce(rows, params) {
 		const arr = Array.isArray(rows) ? rows : [];
@@ -2244,10 +1916,10 @@ const strikingDistanceAnalyzer = defineAnalyzer({
 		const limit = params.limit ?? 1e3;
 		const results = [];
 		for (const row of arr) {
-			const position = num(row.position);
-			const impressions = num(row.impressions);
-			const ctr = num(row.ctr);
-			const clicks = num(row.clicks);
+			const position = num$1(row.position);
+			const impressions = num$1(row.impressions);
+			const ctr = num$1(row.ctr);
+			const clicks = num$1(row.clicks);
 			if (position < minPosition || position > maxPosition) continue;
 			if (impressions < minImpressions) continue;
 			if (ctr > maxCtr) continue;
@@ -2275,7 +1947,7 @@ const strikingDistanceAnalyzer = defineAnalyzer({
 		};
 	},
 	buildSql(params) {
-		const { startDate, endDate } = periodOf(params);
+		const { startDate, endDate } = periodOf$1(params);
 		return {
 			sql: `
     SELECT
@@ -2297,15 +1969,15 @@ const strikingDistanceAnalyzer = defineAnalyzer({
 		};
 	},
 	buildRows(params) {
-		return { keywords: keywordsQueryState(periodOf(params), params.limit ?? DEFAULT_ROW_LIMIT$1) };
+		return { keywords: keywordsQueryState(periodOf$1(params), params.limit ?? DEFAULT_ROW_LIMIT$1) };
 	}
 });
 const DEFAULT_ROW_LIMIT = 25e3;
 const sortRowResults = createSorter((item) => item.impressions, "impressions");
-const zeroClickAnalyzer = defineAnalyzer({
+const zeroClickAnalyzer = defineAnalyzer$1({
 	id: "zero-click",
 	buildSql(params) {
-		const { startDate, endDate } = periodOf(params);
+		const { startDate, endDate } = periodOf$1(params);
 		const minImpressions = params.minImpressions ?? 1e3;
 		const maxCtr = params.maxCtr ?? .03;
 		const maxPosition = params.maxPosition ?? 10;
@@ -2365,11 +2037,11 @@ const zeroClickAnalyzer = defineAnalyzer({
 			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)
+				clicks: num$1(r.clicks),
+				impressions: num$1(r.impressions),
+				ctr: num$1(r.ctr),
+				position: num$1(r.position),
+				missedClicks: num$1(r.missedClicks)
 			})),
 			meta: {
 				total: arr.length,
@@ -2380,7 +2052,7 @@ const zeroClickAnalyzer = defineAnalyzer({
 		};
 	},
 	buildRows(params) {
-		const period = periodOf(params);
+		const period = periodOf$1(params);
 		const limit = params.limit ?? DEFAULT_ROW_LIMIT;
 		return { rows: gsc.select(query, page).where(between(date, period.startDate, period.endDate)).limit(limit).getState() };
 	},
@@ -2430,142 +2102,1487 @@ const ROW_ANALYZERS = [
 	cannibalizationAnalyzer.rows,
 	zeroClickAnalyzer.rows
 ];
-const SYNONYMS = {
-	checker: "validator",
-	tester: "validator",
-	verifier: "validator",
-	verify: "validate",
-	check: "validate",
-	test: "validate",
-	checking: "validate",
-	testing: "validate",
-	creator: "generator",
-	builder: "generator",
-	maker: "generator",
-	create: "generate",
-	build: "generate",
-	make: "generate",
-	lookup: "search",
-	finder: "search",
-	find: "search",
-	online: "",
-	free: ""
-};
-const NO_STRIP_S = new Set([
-	"css",
-	"js",
-	"ts",
-	"os",
-	"as",
-	"is",
-	"us",
-	"has",
-	"was",
-	"its",
-	"this",
-	"yes",
-	"no",
-	"bus",
-	"gas",
-	"dns",
-	"rss",
-	"sms",
-	"gps",
-	"aws",
-	"sas",
-	"cms",
-	"ios",
-	"less",
-	"loss",
-	"miss",
-	"pass",
-	"class",
-	"access",
-	"process",
-	"express",
-	"address",
-	"cross",
-	"press",
-	"stress",
-	"progress",
-	"success",
-	"business",
-	"wordpress",
-	"status",
-	"radius",
-	"nexus",
-	"focus",
-	"bonus",
-	"campus",
-	"census",
-	"corpus",
-	"nucleus",
-	"stimulus",
-	"terminus",
-	"versus",
-	"virus",
-	"surplus",
-	"cactus",
-	"analysis",
-	"basis",
-	"thesis",
-	"crisis",
-	"axis",
-	"genesis",
-	"synopsis",
-	"diagnosis",
-	"emphasis",
-	"hypothesis",
-	"synthesis",
-	"parenthesis",
-	"redis",
-	"apis",
-	"chaos",
-	"demos",
-	"logos",
-	"photos",
-	"videos",
-	"nuxtjs",
-	"nextjs",
-	"nodejs",
-	"reactjs",
-	"vuejs",
-	"angularjs",
-	"expressjs",
-	"nestjs",
-	"threejs",
-	"alpinejs",
-	"solidjs",
-	"sveltejs",
-	"dejs",
-	"bunjs",
-	"denojs",
-	"canvas",
-	"atlas",
-	"alias",
-	"bias",
-	"perhaps",
-	"whereas",
-	"kubernetes",
-	"sass",
-	"postgres",
-	"always",
-	"across",
-	"previous",
-	"various",
-	"serious",
-	"famous",
-	"anonymous",
-	"continuous",
-	"dangerous",
-	"generous",
-	"obvious",
-	"numerous",
-	"curious",
-	"nervous",
-	"conscious"
-]);
-function depluralize(token) {
+function num$6(v) {
+	if (typeof v === "number") return v;
+	if (typeof v === "bigint") return Number(v);
+	if (v == null) return 0;
+	const n = Number(v);
+	return Number.isFinite(n) ? n : 0;
+}
+function str$16(v) {
+	return v == null ? "" : String(v);
+}
+const bayesianCtrAnalyzer = defineAnalyzer$1({
+	id: "bayesian-ctr",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf$1(params);
+		const minImpressions = params.minImpressions ?? 50;
+		const limit = params.limit ?? 300;
+		const priorMinEntities = 5;
+		return {
+			sql: `
+    WITH entity AS (
+      SELECT
+        query,
+        url,
+        ${METRIC_EXPR.clicks} AS clicks,
+        ${METRIC_EXPR.impressions} AS impressions,
+        ${METRIC_EXPR.ctr} AS observed_ctr,
+        ${METRIC_EXPR.position} AS position,
+        CAST(ROUND(LEAST(${METRIC_EXPR.position}, 30)) AS INTEGER) AS bucket
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ?
+        AND query IS NOT NULL AND query <> ''
+        AND url IS NOT NULL AND url <> ''
+      GROUP BY query, url
+      HAVING SUM(impressions) >= ?
+        AND ${METRIC_EXPR.position} <= 30
+    ),
+    bucket_mu AS (
+      SELECT
+        bucket,
+        COUNT(*) AS n_entities,
+        SUM(observed_ctr * impressions) / NULLIF(SUM(impressions), 0) AS mu,
+        SUM(impressions) AS total_impressions
+      FROM entity
+      GROUP BY bucket
+    ),
+    bucket_var AS (
+      SELECT
+        e.bucket,
+        GREATEST(
+          SUM(e.impressions * POWER(e.observed_ctr - b.mu, 2))
+            / NULLIF(SUM(e.impressions), 0),
+          1e-9
+        ) AS v
+      FROM entity e
+      JOIN bucket_mu b USING (bucket)
+      GROUP BY e.bucket
+    ),
+    priors AS (
+      SELECT
+        m.bucket,
+        m.n_entities,
+        m.mu,
+        v.v,
+        CASE
+          WHEN m.n_entities >= ${Number(priorMinEntities)}
+            AND v.v > 0
+            AND m.mu > 0 AND m.mu < 1
+            AND (m.mu * (1.0 - m.mu) / v.v - 1.0) > 0
+          THEN GREATEST(0.5, m.mu * (m.mu * (1.0 - m.mu) / v.v - 1.0))
+          ELSE 2.0
+        END AS alpha,
+        CASE
+          WHEN m.n_entities >= ${Number(priorMinEntities)}
+            AND v.v > 0
+            AND m.mu > 0 AND m.mu < 1
+            AND (m.mu * (1.0 - m.mu) / v.v - 1.0) > 0
+          THEN GREATEST(0.5, (1.0 - m.mu) * (m.mu * (1.0 - m.mu) / v.v - 1.0))
+          ELSE 48.0
+        END AS beta
+      FROM bucket_mu m
+      JOIN bucket_var v USING (bucket)
+    ),
+    posterior AS (
+      SELECT
+        e.query,
+        e.url,
+        e.clicks,
+        e.impressions,
+        e.observed_ctr,
+        e.position,
+        e.bucket,
+        p.alpha AS prior_alpha,
+        p.beta AS prior_beta,
+        p.mu AS bucket_prior_mean,
+        p.alpha + e.clicks AS alpha_post,
+        p.beta + (e.impressions - e.clicks) AS beta_post
+      FROM entity e
+      JOIN priors p USING (bucket)
+    ),
+    scored AS (
+      SELECT *,
+        alpha_post / (alpha_post + beta_post) AS posterior_mean,
+        SQRT((alpha_post * beta_post)
+          / (POWER(alpha_post + beta_post, 2) * (alpha_post + beta_post + 1))) AS posterior_sd
+      FROM posterior
+    )
+    SELECT
+      query AS keyword,
+      url AS page,
+      clicks,
+      impressions,
+      observed_ctr AS observedCtr,
+      position,
+      bucket,
+      prior_alpha AS priorAlpha,
+      prior_beta AS priorBeta,
+      bucket_prior_mean AS bucketPriorMean,
+      posterior_mean AS posteriorMean,
+      posterior_sd AS posteriorSd,
+      GREATEST(0.0, posterior_mean - 1.96 * posterior_sd) AS ciLow,
+      LEAST(1.0, posterior_mean + 1.96 * posterior_sd) AS ciHigh,
+      posterior_mean - observed_ctr AS shrinkageDelta,
+      (posterior_mean - observed_ctr) * impressions AS expectedClicksDelta,
+      ABS(observed_ctr - posterior_mean) / NULLIF(posterior_sd, 0) AS significance,
+      CASE
+        WHEN observed_ctr > LEAST(1.0, posterior_mean + 1.96 * posterior_sd) THEN 'overperforming'
+        WHEN observed_ctr < GREATEST(0.0, posterior_mean - 1.96 * posterior_sd) THEN 'underperforming'
+        ELSE 'expected'
+      END AS classification
+    FROM scored
+    ORDER BY significance DESC NULLS LAST
+    LIMIT ${Number(limit)}
+  `,
+			params: [
+				startDate,
+				endDate,
+				minImpressions
+			],
+			current: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const minImpressions = params.minImpressions ?? 50;
+		const results = arr.map((r) => ({
+			keyword: str$16(r.keyword),
+			page: str$16(r.page),
+			clicks: num$6(r.clicks),
+			impressions: num$6(r.impressions),
+			observedCtr: num$6(r.observedCtr),
+			position: num$6(r.position),
+			bucket: num$6(r.bucket),
+			priorAlpha: num$6(r.priorAlpha),
+			priorBeta: num$6(r.priorBeta),
+			bucketPriorMean: num$6(r.bucketPriorMean),
+			posteriorMean: num$6(r.posteriorMean),
+			posteriorSd: num$6(r.posteriorSd),
+			ciLow: num$6(r.ciLow),
+			ciHigh: num$6(r.ciHigh),
+			shrinkageDelta: num$6(r.shrinkageDelta),
+			expectedClicksDelta: num$6(r.expectedClicksDelta),
+			significance: num$6(r.significance),
+			classification: str$16(r.classification)
+		}));
+		const under = results.filter((r) => r.classification === "underperforming").length;
+		const over = results.filter((r) => r.classification === "overperforming").length;
+		return {
+			results,
+			meta: {
+				total: results.length,
+				underperforming: under,
+				overperforming: over,
+				expected: results.length - under - over,
+				minImpressions
+			}
+		};
+	}
+});
+const BIPARTITE_PAGERANK_ITERATIONS = 25;
+const BIPARTITE_PAGERANK_DAMPING = .85;
+function str$15(v) {
+	return v == null ? "" : String(v);
+}
+function parseJsonList$11(v) {
+	if (Array.isArray(v)) return v;
+	if (typeof v === "string" && v.length > 0) {
+		const parsed = JSON.parse(v);
+		return Array.isArray(parsed) ? parsed : [];
+	}
+	return [];
+}
+const bipartitePagerankAnalyzer = defineAnalyzer$1({
+	id: "bipartite-pagerank",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf$1(params);
+		const minImpressions = params.minImpressions ?? 50;
+		const topQueries = 1e3;
+		const topUrls = 500;
+		const limit = params.limit ?? 50;
+		const bridgingEdgeThreshold = .05;
+		const anchoringEdgeThreshold = .05;
+		const iterations = BIPARTITE_PAGERANK_ITERATIONS;
+		const d = BIPARTITE_PAGERANK_DAMPING;
+		const iterCtes = [];
+		for (let i = 1; i <= iterations; i++) iterCtes.push(`
+    ranks_${i} AS (
+      SELECT
+        'q' AS kind,
+        e.qid AS id,
+        (1.0 - ${d}) / (SELECT n FROM query_count)
+          + ${d} * SUM(e.w_u_to_q * r.rank) AS rank
+      FROM u_to_q_weights e
+      JOIN ranks_${i - 1} r ON r.kind = 'u' AND r.id = e.uid
+      GROUP BY e.qid
+      UNION ALL
+      SELECT
+        'u' AS kind,
+        e.uid AS id,
+        (1.0 - ${d}) / (SELECT n FROM url_count)
+          + ${d} * SUM(e.w_q_to_u * r.rank) AS rank
+      FROM q_to_u_weights e
+      JOIN ranks_${i - 1} r ON r.kind = 'q' AND r.id = e.qid
+      GROUP BY e.uid
+    )`);
+		const deltaParts = [];
+		for (let i = 1; i <= iterations; i++) deltaParts.push(`
+      SELECT ${i} AS step,
+        (SELECT COALESCE(SUM(ABS(a.rank - b.rank)), 0.0)
+         FROM ranks_${i} a
+         JOIN ranks_${i - 1} b USING (kind, id)) AS l1`);
+		return {
+			sql: `
+    WITH edges0 AS (
+      SELECT
+        query AS qid,
+        url   AS uid,
+        CAST(SUM(impressions) AS DOUBLE) AS impressions
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ?
+        AND query IS NOT NULL AND query <> ''
+        AND url   IS NOT NULL AND url   <> ''
+      GROUP BY query, url
+      HAVING SUM(impressions) >= ?
+    ),
+    -- Top-N caps per side keep the iteration tractable.
+    query_totals AS (
+      SELECT qid, SUM(impressions) AS tot
+      FROM edges0 GROUP BY qid
+    ),
+    url_totals AS (
+      SELECT uid, SUM(impressions) AS tot
+      FROM edges0 GROUP BY uid
+    ),
+    top_queries AS (
+      SELECT qid FROM query_totals
+      ORDER BY tot DESC, qid ASC LIMIT ${Number(topQueries)}
+    ),
+    top_urls AS (
+      SELECT uid FROM url_totals
+      ORDER BY tot DESC, uid ASC LIMIT ${Number(topUrls)}
+    ),
+    edges AS (
+      SELECT e.qid, e.uid, e.impressions
+      FROM edges0 e
+      JOIN top_queries tq USING (qid)
+      JOIN top_urls    tu USING (uid)
+    ),
+    query_nodes AS (SELECT DISTINCT qid FROM edges),
+    url_nodes   AS (SELECT DISTINCT uid FROM edges),
+    query_count AS (SELECT GREATEST(COUNT(*), 1) AS n FROM query_nodes),
+    url_count   AS (SELECT GREATEST(COUNT(*), 1) AS n FROM url_nodes),
+    -- Row-stochastic transition weights in each direction. For q->u the
+    -- weights out of a query sum to 1; symmetric for u->q.
+    q_out AS (SELECT qid, SUM(impressions) AS s FROM edges GROUP BY qid),
+    u_out AS (SELECT uid, SUM(impressions) AS s FROM edges GROUP BY uid),
+    q_to_u_weights AS (
+      SELECT e.qid, e.uid,
+        e.impressions / NULLIF(q.s, 0) AS w_q_to_u
+      FROM edges e JOIN q_out q USING (qid)
+    ),
+    u_to_q_weights AS (
+      SELECT e.qid, e.uid,
+        e.impressions / NULLIF(u.s, 0) AS w_u_to_q
+      FROM edges e JOIN u_out u USING (uid)
+    ),
+    -- Seed: uniform distribution per side. Total mass = 2 (one unit per side).
+    ranks_0 AS (
+      SELECT 'q' AS kind, q.qid AS id, 1.0 / (SELECT n FROM query_count) AS rank
+      FROM query_nodes q
+      UNION ALL
+      SELECT 'u' AS kind, u.uid AS id, 1.0 / (SELECT n FROM url_count) AS rank
+      FROM url_nodes u
+    ),
+    ${iterCtes.join(",\n")},
+    final_ranks AS (SELECT * FROM ranks_${iterations}),
+    -- Hub/anchor diagnostics computed from raw edge mass (not rank). A
+    -- query "bridges" URLs it sends >= ${bridgingEdgeThreshold} of its mass
+    -- to; a URL "anchors" queries that contribute >= ${anchoringEdgeThreshold}
+    -- of its incoming mass.
+    q_bridging AS (
+      SELECT qid, COUNT(*) AS bridging
+      FROM q_to_u_weights
+      WHERE w_q_to_u >= ${bridgingEdgeThreshold}
+      GROUP BY qid
+    ),
+    u_anchoring AS (
+      SELECT uid, COUNT(*) AS anchoring
+      FROM u_to_q_weights
+      WHERE w_u_to_q >= ${anchoringEdgeThreshold}
+      GROUP BY uid
+    ),
+    q_degree AS (
+      SELECT qid, COUNT(*) AS degree, SUM(impressions) AS impressions
+      FROM edges GROUP BY qid
+    ),
+    u_degree AS (
+      SELECT uid, COUNT(*) AS degree, SUM(impressions) AS impressions
+      FROM edges GROUP BY uid
+    ),
+    deltas AS (
+      ${deltaParts.join("\n      UNION ALL\n")}
+    ),
+    query_rows AS (
+      SELECT
+        'query' AS kind, f.id, f.rank,
+        COALESCE(b.bridging, 0)      AS bridging,
+        0                             AS anchoring,
+        COALESCE(qd.degree, 0)       AS degree,
+        COALESCE(qd.impressions, 0)  AS impressions
+      FROM final_ranks f
+      LEFT JOIN q_bridging b ON b.qid = f.id
+      LEFT JOIN q_degree   qd ON qd.qid = f.id
+      WHERE f.kind = 'q'
+      ORDER BY f.rank DESC
+      LIMIT ${Number(limit)}
+    ),
+    url_rows AS (
+      SELECT
+        'url' AS kind, f.id, f.rank,
+        0                             AS bridging,
+        COALESCE(a.anchoring, 0)     AS anchoring,
+        COALESCE(ud.degree, 0)       AS degree,
+        COALESCE(ud.impressions, 0)  AS impressions
+      FROM final_ranks f
+      LEFT JOIN u_anchoring a ON a.uid = f.id
+      LEFT JOIN u_degree   ud ON ud.uid = f.id
+      WHERE f.kind = 'u'
+      ORDER BY f.rank DESC
+      LIMIT ${Number(limit)}
+    ),
+    nodes AS (
+      SELECT * FROM query_rows
+      UNION ALL
+      SELECT * FROM url_rows
+    ),
+    counts AS (
+      SELECT
+        (SELECT n FROM query_count) AS q_count,
+        (SELECT n FROM url_count)   AS u_count
+    ),
+    deltas_json AS (
+      SELECT to_json(list({ 'step': step, 'l1': l1 } ORDER BY step)) AS dj
+      FROM deltas
+    )
+    SELECT
+      n.kind,
+      n.id,
+      n.rank,
+      n.bridging,
+      n.anchoring,
+      n.degree,
+      n.impressions,
+      c.q_count AS queryCount,
+      c.u_count AS urlCount,
+      dj.dj     AS deltasJson
+    FROM nodes n
+    CROSS JOIN counts c
+    CROSS JOIN deltas_json dj
+    ORDER BY n.kind, n.rank DESC
+  `,
+			params: [
+				startDate,
+				endDate,
+				minImpressions
+			],
+			current: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const iterations = BIPARTITE_PAGERANK_ITERATIONS;
+		const d = BIPARTITE_PAGERANK_DAMPING;
+		const results = arr.map((r) => ({
+			kind: str$15(r.kind),
+			id: str$15(r.id),
+			rank: num$1(r.rank),
+			bridging: num$1(r.bridging),
+			anchoring: num$1(r.anchoring),
+			degree: num$1(r.degree),
+			impressions: num$1(r.impressions)
+		}));
+		const first = arr[0] ?? {};
+		const queryCount = num$1(first.queryCount);
+		const urlCount = num$1(first.urlCount);
+		const deltas = parseJsonList$11(first.deltasJson).map((e) => ({
+			step: num$1(e.step),
+			l1: num$1(e.l1)
+		}));
+		const convergenceDelta = deltas.length > 0 ? deltas[deltas.length - 1].l1 : 0;
+		return {
+			results,
+			meta: {
+				total: results.length,
+				convergenceDelta,
+				iterations,
+				damping: d,
+				queryCount,
+				urlCount,
+				deltas
+			}
+		};
+	}
+});
+function num$5(v) {
+	if (typeof v === "number") return v;
+	if (typeof v === "bigint") return Number(v);
+	if (v == null) return 0;
+	const n = Number(v);
+	return Number.isFinite(n) ? n : 0;
+}
+function str$14(v) {
+	return v == null ? "" : String(v);
+}
+function parseJsonList$10(v) {
+	if (Array.isArray(v)) return v;
+	if (typeof v === "string" && v.length > 0) {
+		const parsed = JSON.parse(v);
+		return Array.isArray(parsed) ? parsed : [];
+	}
+	return [];
+}
+const changePointAnalyzer = defineAnalyzer$1({
+	id: "change-point",
+	buildSql(params) {
+		const endDate = params.endDate ?? defaultEndDate();
+		const startDate = params.startDate ?? daysAgo(93);
+		const minDays = 21;
+		const minSide = 7;
+		const threshold = params.threshold ?? 10;
+		const minImpressions = params.minImpressions ?? 50;
+		const metric = params.metric === "clicks" || params.metric === "impressions" ? params.metric : "position";
+		const limit = params.limit ?? 100;
+		const valueExpr = metric === "position" ? METRIC_EXPR.position : `CAST(SUM(${metric}) AS DOUBLE)`;
+		return {
+			sql: `
+    WITH daily AS (
+      SELECT
+        query,
+        url AS page,
+        date,
+        ${METRIC_EXPR.clicks} AS clicks,
+        ${METRIC_EXPR.impressions} AS impressions,
+        ${valueExpr} AS value
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ?
+        AND query IS NOT NULL AND query <> ''
+        AND url IS NOT NULL AND url <> ''
+      GROUP BY query, url, date
+      HAVING SUM(impressions) >= 1
+    ),
+    entity_stats AS (
+      SELECT query, page,
+        COUNT(*) AS n_total,
+        SUM(impressions) AS total_impressions,
+        SUM(value) AS sum_total,
+        SUM(value * value) AS sumsq_total
+      FROM daily
+      GROUP BY query, page
+      HAVING COUNT(*) >= ${Number(minDays)}
+        AND SUM(impressions) >= ?
+    ),
+    filtered AS (
+      SELECT d.*,
+        e.n_total, e.sum_total, e.sumsq_total, e.total_impressions
+      FROM daily d
+      JOIN entity_stats e USING (query, page)
+    ),
+    cumulated AS (
+      SELECT *,
+        COUNT(*) OVER w AS n_left,
+        SUM(value) OVER w AS sum_left,
+        SUM(value * value) OVER w AS sumsq_left
+      FROM filtered
+      WINDOW w AS (
+        PARTITION BY query, page
+        ORDER BY date
+        ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
+      )
+    ),
+    llr_scored AS (
+      SELECT *,
+        (n_total - n_left) AS n_right,
+        (sum_total - sum_left) AS sum_right,
+        (sumsq_total - sumsq_left) AS sumsq_right,
+        GREATEST(
+          (sumsq_left / NULLIF(n_left, 0))
+            - (sum_left / NULLIF(n_left, 0)) * (sum_left / NULLIF(n_left, 0)),
+          1e-9
+        ) AS var_left,
+        GREATEST(
+          ((sumsq_total - sumsq_left) / NULLIF(n_total - n_left, 0))
+            - ((sum_total - sum_left) / NULLIF(n_total - n_left, 0))
+              * ((sum_total - sum_left) / NULLIF(n_total - n_left, 0)),
+          1e-9
+        ) AS var_right,
+        GREATEST(
+          (sumsq_total / NULLIF(n_total, 0))
+            - (sum_total / NULLIF(n_total, 0)) * (sum_total / NULLIF(n_total, 0)),
+          1e-9
+        ) AS var_single
+      FROM cumulated
+    ),
+    llr AS (
+      SELECT *,
+        CASE
+          WHEN n_left >= ${Number(minSide)} AND (n_total - n_left) >= ${Number(minSide)}
+          THEN n_total * LN(var_single)
+            - n_left * LN(var_left)
+            - (n_total - n_left) * LN(var_right)
+          ELSE NULL
+        END AS llr
+      FROM llr_scored
+    ),
+    best AS (
+      SELECT query, page, n_total, total_impressions,
+        arg_max(date, llr) AS change_date,
+        MAX(llr) AS best_llr,
+        arg_max(sum_left / NULLIF(n_left, 0), llr) AS left_mean,
+        arg_max((sum_total - sum_left) / NULLIF(n_total - n_left, 0), llr) AS right_mean,
+        arg_max(sqrt(var_left), llr) AS left_std,
+        arg_max(sqrt(var_right), llr) AS right_std
+      FROM llr
+      WHERE llr IS NOT NULL
+      GROUP BY query, page, n_total, total_impressions
+      HAVING MAX(llr) > ${Number(threshold)}
+    ),
+    series AS (
+      SELECT query, page,
+        to_json(list({
+          'date': strftime(date, '%Y-%m-%d'),
+          'value': value
+        } ORDER BY date)) AS seriesJson
+      FROM daily
+      GROUP BY query, page
+    )
+    SELECT
+      b.query AS keyword,
+      b.page,
+      CAST(b.n_total AS DOUBLE) AS totalDays,
+      CAST(b.total_impressions AS DOUBLE) AS totalImpressions,
+      strftime(b.change_date, '%Y-%m-%d') AS changeDate,
+      b.best_llr AS llr,
+      b.left_mean AS leftMean,
+      b.right_mean AS rightMean,
+      (b.right_mean - b.left_mean) AS delta,
+      b.left_std AS leftStddev,
+      b.right_std AS rightStddev,
+      s.seriesJson
+    FROM best b
+    LEFT JOIN series s USING (query, page)
+    ORDER BY b.best_llr DESC
+    LIMIT ${Number(limit)}
+  `,
+			params: [
+				startDate,
+				endDate,
+				minImpressions
+			],
+			current: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const threshold = params.threshold ?? 10;
+		const metric = params.metric === "clicks" || params.metric === "impressions" ? params.metric : "position";
+		const lowerIsBetter = metric === "position";
+		const results = arr.map((r) => {
+			const delta = num$5(r.delta);
+			const improved = lowerIsBetter ? delta < 0 : delta > 0;
+			return {
+				keyword: str$14(r.keyword),
+				page: str$14(r.page),
+				totalDays: num$5(r.totalDays),
+				totalImpressions: num$5(r.totalImpressions),
+				changeDate: str$14(r.changeDate),
+				llr: num$5(r.llr),
+				leftMean: num$5(r.leftMean),
+				rightMean: num$5(r.rightMean),
+				delta,
+				leftStddev: num$5(r.leftStddev),
+				rightStddev: num$5(r.rightStddev),
+				direction: improved ? "improved" : "worsened",
+				series: parseJsonList$10(r.seriesJson).map((s) => ({
+					date: str$14(s.date),
+					value: num$5(s.value)
+				}))
+			};
+		});
+		return {
+			results,
+			meta: {
+				total: results.length,
+				metric,
+				threshold,
+				improved: results.filter((r) => r.direction === "improved").length,
+				worsened: results.filter((r) => r.direction === "worsened").length
+			}
+		};
+	}
+});
+function num$4(v) {
+	if (typeof v === "number") return v;
+	if (typeof v === "bigint") return Number(v);
+	if (v == null) return 0;
+	const n = Number(v);
+	return Number.isFinite(n) ? n : 0;
+}
+function str$13(v) {
+	return v == null ? "" : String(v);
+}
+const contentVelocityAnalyzer = defineAnalyzer$1({
+	id: "content-velocity",
+	buildSql(params) {
+		const days = Math.min(Math.max(Number(params.days ?? 90), 7), 365);
+		const { endDate } = periodOf$1(params);
+		const start = new Date(endDate);
+		start.setUTCDate(start.getUTCDate() - days);
+		const startDate = toIsoDate(start);
+		return {
+			sql: `
+    WITH src AS (
+      SELECT query, date
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ? AND impressions > 0
+    ),
+    first_seen AS (
+      SELECT query, MIN(date) AS first_date FROM src GROUP BY query
+    ),
+    per_week AS (
+      SELECT
+        strftime(CAST(date AS DATE), '%G-W%V') AS week,
+        MIN(date) AS week_start,
+        CAST(COUNT(DISTINCT query) AS DOUBLE) AS totalKeywords
+      FROM src
+      GROUP BY week
+    ),
+    new_per_week AS (
+      SELECT
+        strftime(CAST(first_date AS DATE), '%G-W%V') AS week,
+        CAST(COUNT(*) AS DOUBLE) AS newKeywords
+      FROM first_seen
+      GROUP BY week
+    )
+    SELECT
+      pw.week AS week,
+      COALESCE(npw.newKeywords, 0) AS newKeywords,
+      pw.totalKeywords AS totalKeywords
+    FROM per_week pw
+    LEFT JOIN new_per_week npw ON pw.week = npw.week
+    ORDER BY pw.week ASC
+  `,
+			params: [startDate, endDate],
+			current: {
+				table: "keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const days = Math.min(Math.max(Number(params.days ?? 90), 7), 365);
+		const { endDate } = periodOf$1(params);
+		const startDateD = new Date(endDate);
+		startDateD.setUTCDate(startDateD.getUTCDate() - days);
+		const startDate = toIsoDate(startDateD);
+		const weekly = arr.map((r) => ({
+			week: str$13(r.week),
+			newKeywords: num$4(r.newKeywords),
+			totalKeywords: num$4(r.totalKeywords)
+		}));
+		const total = weekly.reduce((s, w) => s + w.newKeywords, 0);
+		const avg = weekly.length > 0 ? total / weekly.length : 0;
+		const mid = Math.floor(weekly.length / 2);
+		const firstAvg = mid > 0 ? weekly.slice(0, mid).reduce((s, w) => s + w.newKeywords, 0) / mid : 0;
+		const diff = (weekly.length - mid > 0 ? weekly.slice(mid).reduce((s, w) => s + w.newKeywords, 0) / (weekly.length - mid) : 0) - firstAvg;
+		const threshold = Math.max(1, avg * .15);
+		return {
+			results: weekly,
+			meta: {
+				summary: {
+					totalNewKeywords: total,
+					avgPerWeek: avg,
+					trend: diff > threshold ? "accelerating" : diff < -threshold ? "decelerating" : "stable"
+				},
+				days,
+				startDate,
+				endDate
+			}
+		};
+	}
+});
+function num$3(v) {
+	if (typeof v === "number") return v;
+	if (typeof v === "bigint") return Number(v);
+	if (v == null) return 0;
+	const n = Number(v);
+	return Number.isFinite(n) ? n : 0;
+}
+function str$12(v) {
+	return v == null ? "" : String(v);
+}
+function bool$1(v) {
+	return v === true || v === 1 || v === "true";
+}
+function parseJsonList$9(v) {
+	if (Array.isArray(v)) return v;
+	if (typeof v === "string" && v.length > 0) {
+		const parsed = JSON.parse(v);
+		return Array.isArray(parsed) ? parsed : [];
+	}
+	return [];
+}
+const ctrAnomalyAnalyzer = defineAnalyzer$1({
+	id: "ctr-anomaly",
+	buildSql(params) {
+		const endDate = params.endDate ?? defaultEndDate();
+		const startDate = params.startDate ?? daysAgo(93);
+		const minDailyImpressions = params.minImpressions ?? 5;
+		const minRollingN = 14;
+		const zThreshold = params.threshold ?? 2;
+		const maxPositionDelta = 1.5;
+		const minBreachDays = 2;
+		const limit = params.limit ?? 200;
+		return {
+			sql: `
+    WITH daily AS (
+      SELECT
+        query,
+        url AS page,
+        date,
+        ${METRIC_EXPR.clicks} AS day_clicks,
+        ${METRIC_EXPR.impressions} AS day_impressions,
+        ${METRIC_EXPR.ctr} AS day_ctr,
+        ${METRIC_EXPR.position} AS day_position
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ?
+        AND query IS NOT NULL AND query <> ''
+        AND url IS NOT NULL AND url <> ''
+      GROUP BY query, url, date
+      HAVING SUM(impressions) >= ?
+    ),
+    rolled AS (
+      SELECT *,
+        AVG(day_ctr)           OVER w AS rolling_ctr,
+        STDDEV_POP(day_ctr)    OVER w AS rolling_stddev,
+        AVG(day_position)      OVER w AS rolling_position,
+        COUNT(*)               OVER w AS rolling_n
+      FROM daily
+      WINDOW w AS (
+        PARTITION BY query, page
+        ORDER BY date
+        ROWS BETWEEN 28 PRECEDING AND 1 PRECEDING
+      )
+    ),
+    flagged AS (
+      SELECT *,
+        CASE
+          WHEN rolling_n >= ${Number(minRollingN)} AND rolling_stddev > 0
+            THEN (day_ctr - rolling_ctr) / rolling_stddev
+          ELSE 0.0
+        END AS z_score,
+        CASE
+          WHEN rolling_position IS NULL THEN 0.0
+          ELSE ABS(day_position - rolling_position)
+        END AS position_delta
+      FROM rolled
+    ),
+    breaches AS (
+      SELECT *,
+        CASE
+          WHEN ABS(z_score) >= ${zThreshold}
+            AND position_delta <= ${maxPositionDelta}
+            AND rolling_n >= ${Number(minRollingN)}
+          THEN true ELSE false
+        END AS is_breach
+      FROM flagged
+    ),
+    per_entity AS (
+      SELECT
+        query, page,
+        COUNT(*) FILTER (WHERE is_breach AND z_score < 0) AS breach_days_down,
+        COUNT(*) FILTER (WHERE is_breach AND z_score > 0) AS breach_days_up,
+        SUM(CASE
+          WHEN is_breach AND z_score < 0
+            THEN (rolling_ctr - day_ctr) * day_impressions
+          ELSE 0.0
+        END) AS clicks_lost,
+        SUM(CASE
+          WHEN is_breach AND z_score < 0
+            THEN ABS(z_score) * day_impressions
+          ELSE 0.0
+        END) AS severity_raw,
+        MAX(CASE WHEN is_breach THEN ABS(z_score) ELSE 0.0 END) AS max_z,
+        AVG(rolling_ctr) FILTER (WHERE rolling_n >= ${Number(minRollingN)}) AS baseline_ctr,
+        AVG(rolling_position) FILTER (WHERE rolling_n >= ${Number(minRollingN)}) AS baseline_position,
+        SUM(day_impressions) AS total_impressions,
+        SUM(day_clicks) AS total_clicks
+      FROM breaches
+      GROUP BY query, page
+      HAVING COUNT(*) FILTER (WHERE is_breach AND z_score < 0) >= ${Number(minBreachDays)}
+    ),
+    series AS (
+      SELECT query, page,
+        to_json(list({
+          'date': strftime(date, '%Y-%m-%d'),
+          'ctr': day_ctr,
+          'position': day_position,
+          'impressions': day_impressions,
+          'rollingCtr': rolling_ctr,
+          'rollingStddev': rolling_stddev,
+          'z': z_score,
+          'breach': is_breach AND z_score < 0
+        } ORDER BY date)) AS seriesJson
+      FROM breaches
+      GROUP BY query, page
+    )
+    SELECT
+      e.query AS keyword,
+      e.page,
+      CAST(e.breach_days_down AS DOUBLE) AS breachDaysDown,
+      CAST(e.breach_days_up AS DOUBLE) AS breachDaysUp,
+      CAST(ROUND(e.clicks_lost) AS DOUBLE) AS clicksLost,
+      e.severity_raw AS severityRaw,
+      e.max_z AS maxZ,
+      e.baseline_ctr AS baselineCtr,
+      e.baseline_position AS baselinePosition,
+      e.total_impressions AS totalImpressions,
+      e.total_clicks AS totalClicks,
+      s.seriesJson
+    FROM per_entity e
+    LEFT JOIN series s USING (query, page)
+    ORDER BY clicksLost DESC
+    LIMIT ${Number(limit)}
+  `,
+			params: [
+				startDate,
+				endDate,
+				minDailyImpressions
+			],
+			current: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const minRollingN = 14;
+		const zThreshold = params.threshold ?? 2;
+		const anomalies = arr.map((r) => ({
+			keyword: str$12(r.keyword),
+			page: str$12(r.page),
+			breachDaysDown: num$3(r.breachDaysDown),
+			breachDaysUp: num$3(r.breachDaysUp),
+			clicksLost: num$3(r.clicksLost),
+			severity: num$3(r.severityRaw),
+			maxZ: num$3(r.maxZ),
+			baselineCtr: num$3(r.baselineCtr),
+			baselinePosition: num$3(r.baselinePosition),
+			totalImpressions: num$3(r.totalImpressions),
+			totalClicks: num$3(r.totalClicks),
+			series: parseJsonList$9(r.seriesJson).map((s) => ({
+				date: str$12(s.date),
+				ctr: num$3(s.ctr),
+				position: num$3(s.position),
+				impressions: num$3(s.impressions),
+				rollingCtr: s.rollingCtr == null ? null : num$3(s.rollingCtr),
+				rollingStddev: s.rollingStddev == null ? null : num$3(s.rollingStddev),
+				z: num$3(s.z),
+				breach: bool$1(s.breach)
+			}))
+		}));
+		const totalClicksLost = anomalies.reduce((s, a) => s + a.clicksLost, 0);
+		const totalBreachDays = anomalies.reduce((s, a) => s + a.breachDaysDown, 0);
+		return {
+			results: anomalies,
+			meta: {
+				total: anomalies.length,
+				totalClicksLost,
+				totalBreachDays,
+				zThreshold,
+				minRollingN
+			}
+		};
+	}
+});
+function num$2(v) {
+	if (typeof v === "number") return v;
+	if (typeof v === "bigint") return Number(v);
+	if (v == null) return 0;
+	const n = Number(v);
+	return Number.isFinite(n) ? n : 0;
+}
+function str$11(v) {
+	return v == null ? "" : String(v);
+}
+function parseJsonList$8(v) {
+	if (Array.isArray(v)) return v;
+	if (typeof v === "string" && v.length > 0) {
+		const parsed = JSON.parse(v);
+		return Array.isArray(parsed) ? parsed : [];
+	}
+	return [];
+}
+const ctrCurveAnalyzer = defineAnalyzer$1({
+	id: "ctr-curve",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf$1(params);
+		return {
+			sql: `
+    WITH src AS (
+      SELECT
+        query,
+        clicks,
+        impressions,
+        sum_position,
+        (sum_position / NULLIF(impressions, 0) + 1) AS avg_pos
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ? AND impressions > 0
+    ),
+    curve AS (
+      SELECT
+        CASE
+          WHEN avg_pos <= 1.5 THEN '1'
+          WHEN avg_pos <= 2.5 THEN '2'
+          WHEN avg_pos <= 3.5 THEN '3'
+          WHEN avg_pos <= 5.5 THEN '4-5'
+          WHEN avg_pos <= 10.5 THEN '6-10'
+          WHEN avg_pos <= 20.5 THEN '11-20'
+          ELSE '20+'
+        END AS bucket,
+        AVG(CAST(clicks AS DOUBLE) / NULLIF(impressions, 0)) AS avgCtr,
+        AVG(avg_pos) AS medianPosition,
+        CAST(COUNT(DISTINCT query) AS DOUBLE) AS keywordCount,
+        ${METRIC_EXPR.clicks} AS totalClicks,
+        ${METRIC_EXPR.impressions} AS totalImpressions
+      FROM src
+      GROUP BY bucket
+    ),
+    ks AS (
+      SELECT
+        query,
+        ${METRIC_EXPR.clicks} AS clicks,
+        ${METRIC_EXPR.impressions} AS impressions,
+        ${METRIC_EXPR.ctr} AS ctr,
+        ${METRIC_EXPR.position} AS position,
+        CASE
+          WHEN ${METRIC_EXPR.position} <= 3.5 THEN 'top3'
+          WHEN ${METRIC_EXPR.position} <= 10.5 THEN 'page1'
+          WHEN ${METRIC_EXPR.position} <= 20.5 THEN 'page2'
+          ELSE 'deep'
+        END AS band
+      FROM src
+      GROUP BY query
+      HAVING SUM(impressions) >= 20
+    ),
+    band_avg AS (
+      SELECT band, AVG(ctr) AS band_avg_ctr FROM ks GROUP BY band
+    ),
+    outliers AS (
+      SELECT
+        ks.query, ks.clicks, ks.impressions, ks.ctr, ks.position,
+        ba.band_avg_ctr AS expectedCtr,
+        ks.ctr - ba.band_avg_ctr AS ctrDiff
+      FROM ks JOIN band_avg ba ON ks.band = ba.band
+      ORDER BY ABS(ks.ctr - ba.band_avg_ctr) DESC
+      LIMIT 50
+    )
+    SELECT
+      (SELECT to_json(list({
+        'bucket': bucket,
+        'avgCtr': avgCtr,
+        'medianPosition': medianPosition,
+        'keywordCount': keywordCount,
+        'totalClicks': totalClicks,
+        'totalImpressions': totalImpressions
+      })) FROM curve) AS curve_json,
+      (SELECT to_json(list({
+        'query': query,
+        'clicks': clicks,
+        'impressions': impressions,
+        'ctr': ctr,
+        'position': position,
+        'expectedCtr': expectedCtr,
+        'ctrDiff': ctrDiff
+      })) FROM outliers) AS outliers_json
+  `,
+			params: [startDate, endDate],
+			current: {
+				table: "keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const { startDate, endDate } = periodOf$1(params);
+		const row = arr[0] ?? {};
+		const curve = parseJsonList$8(row.curve_json).map((r) => ({
+			bucket: str$11(r.bucket),
+			avgCtr: num$2(r.avgCtr),
+			medianPosition: num$2(r.medianPosition),
+			keywordCount: num$2(r.keywordCount),
+			totalClicks: num$2(r.totalClicks),
+			totalImpressions: num$2(r.totalImpressions)
+		}));
+		const outliers = parseJsonList$8(row.outliers_json).map((r) => ({
+			query: str$11(r.query),
+			clicks: num$2(r.clicks),
+			impressions: num$2(r.impressions),
+			ctr: num$2(r.ctr),
+			position: num$2(r.position),
+			expectedCtr: num$2(r.expectedCtr),
+			ctrDiff: num$2(r.ctrDiff)
+		}));
+		return {
+			results: curve,
+			meta: {
+				overperforming: outliers.filter((o) => o.ctrDiff > 0).slice(0, 25),
+				underperforming: outliers.filter((o) => o.ctrDiff < 0).slice(0, 25),
+				startDate,
+				endDate
+			}
+		};
+	}
+});
+function str$10(v) {
+	return v == null ? "" : String(v);
+}
+function parseJsonList$7(v) {
+	if (Array.isArray(v)) return v;
+	if (typeof v === "string" && v.length > 0) {
+		const parsed = JSON.parse(v);
+		return Array.isArray(parsed) ? parsed : [];
+	}
+	return [];
+}
+const darkTrafficAnalyzer = defineAnalyzer$1({
+	id: "dark-traffic",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf$1(params);
+		return {
+			sql: `
+    WITH page_totals AS (
+      SELECT SUM(clicks) AS total_clicks, SUM(impressions) AS total_impressions
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ?
+    ),
+    kw_totals AS (
+      SELECT SUM(clicks) AS total_clicks, SUM(impressions) AS total_impressions
+      FROM read_parquet({{FILES_KEYWORDS}}, union_by_name = true)
+      WHERE date >= ? AND date <= ?
+    ),
+    per_page AS (
+      SELECT url, SUM(clicks) AS page_clicks
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ?
+      GROUP BY url
+      HAVING SUM(clicks) > 0
+    ),
+    per_page_kw AS (
+      SELECT url, SUM(clicks) AS attributed_clicks, COUNT(DISTINCT query) AS kw_count
+      FROM read_parquet({{FILES_PAGE_KEYWORDS}}, union_by_name = true)
+      WHERE date >= ? AND date <= ?
+      GROUP BY url
+    ),
+    page_rows AS (
+      SELECT
+        p.url AS url,
+        CAST(p.page_clicks AS DOUBLE) AS totalClicks,
+        CAST(COALESCE(k.attributed_clicks, 0) AS DOUBLE) AS attributedClicks,
+        CAST(p.page_clicks - COALESCE(k.attributed_clicks, 0) AS DOUBLE) AS darkClicks,
+        CAST(p.page_clicks - COALESCE(k.attributed_clicks, 0) AS DOUBLE)
+          / NULLIF(p.page_clicks, 0) AS darkPercent,
+        CAST(COALESCE(k.kw_count, 0) AS DOUBLE) AS keywordCount
+      FROM per_page p
+      LEFT JOIN per_page_kw k ON p.url = k.url
+      WHERE p.page_clicks - COALESCE(k.attributed_clicks, 0) > 0
+      ORDER BY darkClicks DESC
+      LIMIT 50
+    )
+    SELECT
+      (SELECT to_json({
+        'totalClicks': CAST(total_clicks AS DOUBLE),
+        'totalImpressions': CAST(total_impressions AS DOUBLE)
+      }) FROM page_totals) AS page_totals_json,
+      (SELECT to_json({
+        'attributedClicks': CAST(total_clicks AS DOUBLE),
+        'attributedImpressions': CAST(total_impressions AS DOUBLE)
+      }) FROM kw_totals) AS kw_totals_json,
+      (SELECT to_json(list({
+        'url': url,
+        'totalClicks': totalClicks,
+        'attributedClicks': attributedClicks,
+        'darkClicks': darkClicks,
+        'darkPercent': darkPercent,
+        'keywordCount': keywordCount
+      })) FROM page_rows) AS pages_json
+  `,
+			params: [
+				startDate,
+				endDate,
+				startDate,
+				endDate,
+				startDate,
+				endDate,
+				startDate,
+				endDate
+			],
+			current: {
+				table: "pages",
+				partitions: enumeratePartitions(startDate, endDate)
+			},
+			extraFiles: {
+				KEYWORDS: {
+					table: "keywords",
+					partitions: enumeratePartitions(startDate, endDate)
+				},
+				PAGE_KEYWORDS: {
+					table: "page_keywords",
+					partitions: enumeratePartitions(startDate, endDate)
+				}
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const { startDate, endDate } = periodOf$1(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$1(pageTotals.totalClicks);
+		const totalImpressions = num$1(pageTotals.totalImpressions);
+		const attributedClicks = num$1(kwTotals.attributedClicks);
+		const attributedImpressions = num$1(kwTotals.attributedImpressions);
+		const darkClicks = Math.max(0, totalClicks - attributedClicks);
+		const darkPercent = totalClicks > 0 ? darkClicks / totalClicks : 0;
+		return {
+			results: parseJsonList$7(row.pages_json).map((r) => ({
+				url: str$10(r.url),
+				totalClicks: num$1(r.totalClicks),
+				attributedClicks: num$1(r.attributedClicks),
+				darkClicks: num$1(r.darkClicks),
+				darkPercent: num$1(r.darkPercent),
+				keywordCount: num$1(r.keywordCount)
+			})),
+			meta: {
+				summary: {
+					totalClicks,
+					attributedClicks,
+					darkClicks,
+					darkPercent,
+					totalImpressions,
+					attributedImpressions
+				},
+				startDate,
+				endDate
+			}
+		};
+	}
+});
+function requireBuilderState(input, tool) {
+	if (!input || typeof input !== "object" || !("dimensions" in input) || !Array.isArray(input.dimensions)) throw new Error(`${tool}: params.q is required (BuilderState)`);
+	return input;
+}
+function optionalBuilderState(input, tool, key) {
+	if (input == null) return null;
+	if (typeof input !== "object" || !("dimensions" in input) || !Array.isArray(input.dimensions)) throw new Error(`${tool}: params.${key} must be a BuilderState`);
+	return input;
+}
+const NUMERIC_METRIC_COLS = [
+	"clicks",
+	"impressions",
+	"ctr",
+	"position",
+	"prevClicks",
+	"prevImpressions",
+	"prevCtr",
+	"prevPosition",
+	"variantCount",
+	"totalCount"
+];
+function coerceNumericCols(row) {
+	const out = { ...row };
+	for (const col of NUMERIC_METRIC_COLS) if (col in out && out[col] != null) out[col] = Number(out[col]);
+	return out;
+}
+function shapeDataQuery(rows, extras, opts) {
+	let totalCount;
+	let cleaned;
+	if (opts.hasPrev) {
+		cleaned = rows.map(coerceNumericCols);
+		totalCount = Number((extras?.count?.[0])?.total ?? cleaned.length);
+	} else {
+		const first = rows[0];
+		totalCount = Number(first?.totalCount ?? 0);
+		cleaned = rows.map((raw) => {
+			const { totalCount: _tc, totalClicks: _tclk, totalImpressions: _timp, totalCtr: _tctr, totalPosition: _tpos, sum_position: _sp, ...rest } = raw;
+			return coerceNumericCols(rest);
+		});
+	}
+	const totalsRow = extras?.totals?.[0] ?? {};
+	const totals = {
+		clicks: Number(totalsRow.clicks ?? 0),
+		impressions: Number(totalsRow.impressions ?? 0),
+		ctr: Number(totalsRow.ctr ?? 0),
+		position: Number(totalsRow.position ?? 0)
+	};
+	const extrasResults = [];
+	if (extras?.canonicalExtras) extrasResults.push({
+		key: "canonicalExtras",
+		results: extras.canonicalExtras
+	});
+	return {
+		results: mergeExtras(cleaned, extrasResults),
+		meta: {
+			totalCount,
+			totals
+		}
+	};
+}
+function buildDataQueryPlan(params, options) {
+	const state = requireBuilderState(params.q, "data-query");
+	if (state.dimensions.includes("date")) throw new Error("data-query: date dimension not supported; use data-detail");
+	const prev = optionalBuilderState(params.qc, "data-query", "qc");
+	const totals = buildTotalsSql(state, options);
+	const extras = buildExtrasQueries(state, options);
+	const extraQueries = [{
+		name: "totals",
+		sql: totals.sql,
+		params: totals.params
+	}, ...extras.map((extra) => ({
+		name: extra.key,
+		sql: extra.sql,
+		params: extra.params
+	}))];
+	const tableKey = options.adapter.inferTable(state.dimensions);
+	if (prev) {
+		const comparison = resolveComparisonSQL(state, prev, options, params.comparisonFilter);
+		extraQueries.push({
+			name: "count",
+			sql: comparison.countSql,
+			params: comparison.countParams
+		});
+		return {
+			tableKey,
+			sql: comparison.sql,
+			params: comparison.params,
+			extraQueries,
+			shape: (rows, _params, resolvedExtras) => shapeDataQuery(rows, resolvedExtras, { hasPrev: true })
+		};
+	}
+	const optimized = resolveToSQLOptimized(state, options);
+	return {
+		tableKey,
+		sql: optimized.sql,
+		params: optimized.params,
+		extraQueries,
+		shape: (rows, _params, resolvedExtras) => shapeDataQuery(rows, resolvedExtras, { hasPrev: false })
+	};
+}
+function buildDataDetailPlan(params, options) {
+	const state = requireBuilderState(params.q, "data-detail");
+	if (!state.dimensions.includes("date")) throw new Error("data-detail: `date` dimension is required");
+	const main = resolveToSQL(state, options);
+	const totals = buildTotalsSql(state, options);
+	const prev = optionalBuilderState(params.qc, "data-detail", "qc");
+	const extraQueries = [{
+		name: "totals",
+		sql: totals.sql,
+		params: totals.params
+	}];
+	if (prev) {
+		const previousTotals = buildTotalsSql(prev, options);
+		extraQueries.push({
+			name: "prevTotals",
+			sql: previousTotals.sql,
+			params: previousTotals.params
+		});
+	}
+	const tableKey = options.adapter.inferTable(state.dimensions);
+	const { startDate: rangeStart, endDate: rangeEnd } = extractDateRange(state.filter);
+	return {
+		tableKey,
+		sql: main.sql,
+		params: main.params,
+		extraQueries,
+		shape: (rows, _params, extras) => {
+			const coerced = rows.map(coerceNumericCols);
+			const daily = rangeStart && rangeEnd ? padTimeseries$1(coerced, {
+				startDate: rangeStart,
+				endDate: rangeEnd
+			}) : coerced;
+			const totalsRow = extras?.totals?.[0] ?? {};
+			const meta = { totals: {
+				clicks: Number(totalsRow.clicks ?? 0),
+				impressions: Number(totalsRow.impressions ?? 0),
+				ctr: Number(totalsRow.ctr ?? 0),
+				position: Number(totalsRow.position ?? 0)
+			} };
+			if (extras?.prevTotals) {
+				const previousTotalsRow = extras.prevTotals[0] ?? {};
+				meta.previousTotals = {
+					clicks: Number(previousTotalsRow.clicks ?? 0),
+					impressions: Number(previousTotalsRow.impressions ?? 0),
+					ctr: Number(previousTotalsRow.ctr ?? 0),
+					position: Number(previousTotalsRow.position ?? 0)
+				};
+			}
+			return {
+				results: daily,
+				meta
+			};
+		}
+	};
+}
+const SYNONYMS = {
+	checker: "validator",
+	tester: "validator",
+	verifier: "validator",
+	verify: "validate",
+	check: "validate",
+	test: "validate",
+	checking: "validate",
+	testing: "validate",
+	creator: "generator",
+	builder: "generator",
+	maker: "generator",
+	create: "generate",
+	build: "generate",
+	make: "generate",
+	lookup: "search",
+	finder: "search",
+	find: "search",
+	online: "",
+	free: ""
+};
+const NO_STRIP_S = new Set([
+	"css",
+	"js",
+	"ts",
+	"os",
+	"as",
+	"is",
+	"us",
+	"has",
+	"was",
+	"its",
+	"this",
+	"yes",
+	"no",
+	"bus",
+	"gas",
+	"dns",
+	"rss",
+	"sms",
+	"gps",
+	"aws",
+	"sas",
+	"cms",
+	"ios",
+	"less",
+	"loss",
+	"miss",
+	"pass",
+	"class",
+	"access",
+	"process",
+	"express",
+	"address",
+	"cross",
+	"press",
+	"stress",
+	"progress",
+	"success",
+	"business",
+	"wordpress",
+	"status",
+	"radius",
+	"nexus",
+	"focus",
+	"bonus",
+	"campus",
+	"census",
+	"corpus",
+	"nucleus",
+	"stimulus",
+	"terminus",
+	"versus",
+	"virus",
+	"surplus",
+	"cactus",
+	"analysis",
+	"basis",
+	"thesis",
+	"crisis",
+	"axis",
+	"genesis",
+	"synopsis",
+	"diagnosis",
+	"emphasis",
+	"hypothesis",
+	"synthesis",
+	"parenthesis",
+	"redis",
+	"apis",
+	"chaos",
+	"demos",
+	"logos",
+	"photos",
+	"videos",
+	"nuxtjs",
+	"nextjs",
+	"nodejs",
+	"reactjs",
+	"vuejs",
+	"angularjs",
+	"expressjs",
+	"nestjs",
+	"threejs",
+	"alpinejs",
+	"solidjs",
+	"sveltejs",
+	"dejs",
+	"bunjs",
+	"denojs",
+	"canvas",
+	"atlas",
+	"alias",
+	"bias",
+	"perhaps",
+	"whereas",
+	"kubernetes",
+	"sass",
+	"postgres",
+	"always",
+	"across",
+	"previous",
+	"various",
+	"serious",
+	"famous",
+	"anonymous",
+	"continuous",
+	"dangerous",
+	"generous",
+	"obvious",
+	"numerous",
+	"curious",
+	"nervous",
+	"conscious"
+]);
+function depluralize(token) {
 	if (token.length <= 3) return token;
 	if (NO_STRIP_S.has(token)) return token;
 	if (token.endsWith("ies") && token.length > 4) return `${token.slice(0, -3)}y`;
@@ -2574,124 +3591,1599 @@ function depluralize(token) {
 	if (token.endsWith("s") && !token.endsWith("ss")) return token.slice(0, -1);
 	return token;
 }
-const SEPARATOR_RE = /[-_/.@#:+]+/g;
-const WHITESPACE_RE = /\s+/g;
-function normalizeQuery(query) {
-	return query.toLowerCase().replace(SEPARATOR_RE, " ").replace(WHITESPACE_RE, " ").trim().split(" ").filter(Boolean).map((token) => SYNONYMS[token] ?? token).filter(Boolean).map(depluralize).sort().join(" ");
+const SEPARATOR_RE = /[-_/.@#:+]+/g;
+const WHITESPACE_RE = /\s+/g;
+function normalizeQuery(query) {
+	return query.toLowerCase().replace(SEPARATOR_RE, " ").replace(WHITESPACE_RE, " ").trim().split(" ").filter(Boolean).map((token) => SYNONYMS[token] ?? token).filter(Boolean).map(depluralize).sort().join(" ");
+}
+const dataDetailAnalyzer = defineAnalyzer$1({
+	id: "data-detail",
+	buildSql(params) {
+		const plan = buildDataDetailPlan(params, { adapter: pgResolverAdapter });
+		return {
+			sql: plan.sql,
+			params: plan.params,
+			current: {
+				table: plan.tableKey,
+				partitions: []
+			},
+			requiresAttachedTables: true,
+			extraQueries: plan.extraQueries
+		};
+	},
+	reduceSql(rows, params, ctx) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const { results, meta } = buildDataDetailPlan(params, { adapter: pgResolverAdapter }).shape(arr, params, ctx.extras);
+		return {
+			results,
+			meta
+		};
+	}
+});
+const dataQueryAnalyzer = defineAnalyzer$1({
+	id: "data-query",
+	buildSql(params) {
+		const plan = buildDataQueryPlan(params, { adapter: pgResolverAdapter });
+		return {
+			sql: plan.sql,
+			params: plan.params,
+			current: {
+				table: plan.tableKey,
+				partitions: []
+			},
+			requiresAttachedTables: true,
+			extraQueries: plan.extraQueries
+		};
+	},
+	reduceSql(rows, params, ctx) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const { results, meta } = buildDataQueryPlan(params, { adapter: pgResolverAdapter }).shape(arr, params, ctx.extras);
+		return {
+			results,
+			meta
+		};
+	}
+});
+function str$9(v) {
+	return v == null ? "" : String(v);
+}
+const deviceGapAnalyzer = defineAnalyzer$1({
+	id: "device-gap",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf$1(params);
+		return {
+			sql: `
+    SELECT
+      date,
+      device,
+      ${METRIC_EXPR.clicks} AS clicks,
+      ${METRIC_EXPR.impressions} AS impressions,
+      ${METRIC_EXPR.ctr} AS ctr,
+      ${METRIC_EXPR.position} AS position
+    FROM read_parquet({{FILES}}, union_by_name = true)
+    WHERE date >= ? AND date <= ?
+    GROUP BY date, device
+    ORDER BY date ASC
+  `,
+			params: [startDate, endDate],
+			current: {
+				table: "devices",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const { startDate, endDate } = periodOf$1(params);
+		const typed = arr.map((r) => ({
+			date: str$9(r.date),
+			device: str$9(r.device).toUpperCase(),
+			clicks: num$1(r.clicks),
+			impressions: num$1(r.impressions),
+			ctr: num$1(r.ctr),
+			position: num$1(r.position)
+		}));
+		const byDate = /* @__PURE__ */ new Map();
+		for (const r of typed) {
+			const entry = byDate.get(r.date) ?? {};
+			const metrics = {
+				clicks: r.clicks,
+				impressions: r.impressions,
+				ctr: r.ctr,
+				position: r.position
+			};
+			if (r.device === "DESKTOP") entry.desktop = metrics;
+			else if (r.device === "MOBILE") entry.mobile = metrics;
+			byDate.set(r.date, entry);
+		}
+		const zero = {
+			clicks: 0,
+			impressions: 0,
+			ctr: 0,
+			position: 0
+		};
+		const daily = [...byDate.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([date, sides]) => {
+			const d = sides.desktop ?? zero;
+			const m = sides.mobile ?? zero;
+			return {
+				date,
+				desktop: d,
+				mobile: m,
+				gaps: {
+					ctrGap: d.ctr - m.ctr,
+					positionGap: m.position - d.position
+				}
+			};
+		});
+		const weekly = (start, end) => {
+			const slice = daily.slice(start, end);
+			if (slice.length === 0) return {
+				ctr: 0,
+				pos: 0
+			};
+			const sum = slice.reduce((acc, d) => ({
+				ctr: acc.ctr + d.gaps.ctrGap,
+				pos: acc.pos + d.gaps.positionGap
+			}), {
+				ctr: 0,
+				pos: 0
+			});
+			return {
+				ctr: sum.ctr / slice.length,
+				pos: sum.pos / slice.length
+			};
+		};
+		const first = weekly(0, 7);
+		const last = weekly(Math.max(0, daily.length - 7), daily.length);
+		const classify = (firstVal, lastVal) => {
+			const diff = Math.abs(lastVal) - Math.abs(firstVal);
+			if (Math.abs(diff) < .005) return "stable";
+			return diff < 0 ? "improving" : "worsening";
+		};
+		return {
+			results: daily,
+			meta: {
+				summary: {
+					avgCtrGap: daily.reduce((s, d) => s + d.gaps.ctrGap, 0) / Math.max(1, daily.length),
+					avgPositionGap: daily.reduce((s, d) => s + d.gaps.positionGap, 0) / Math.max(1, daily.length),
+					ctrGapTrend: classify(first.ctr, last.ctr),
+					positionGapTrend: classify(first.pos, last.pos)
+				},
+				startDate,
+				endDate
+			}
+		};
+	}
+});
+function str$8(v) {
+	return v == null ? "" : String(v);
+}
+function parseJsonList$6(v) {
+	if (Array.isArray(v)) return v;
+	if (typeof v === "string" && v.length > 0) {
+		const parsed = JSON.parse(v);
+		return Array.isArray(parsed) ? parsed : [];
+	}
+	return [];
+}
+const INTENT_ATLAS_STOP_WORDS = [
+	"the",
+	"a",
+	"an",
+	"is",
+	"are",
+	"was",
+	"were",
+	"be",
+	"been",
+	"of",
+	"to",
+	"in",
+	"for",
+	"on",
+	"and",
+	"or",
+	"with",
+	"at",
+	"by",
+	"from",
+	"into",
+	"about",
+	"as",
+	"so",
+	"than",
+	"then",
+	"that",
+	"this",
+	"my",
+	"your",
+	"our",
+	"their",
+	"his",
+	"her",
+	"its",
+	"me",
+	"you",
+	"what",
+	"how",
+	"why",
+	"when",
+	"where",
+	"who",
+	"which",
+	"do",
+	"does"
+];
+const intentAtlasAnalyzer = defineAnalyzer$1({
+	id: "intent-atlas",
+	buildSql(params) {
+		const endDate = params.endDate ?? defaultEndDate();
+		const startDate = params.startDate ?? daysAgo(90);
+		const minQueryImpressions = params.minImpressions ?? 20;
+		const minClusterSize = params.minClusterSize ?? 3;
+		const minTokenImpressions = 50;
+		const limit = params.limit ?? 200;
+		const stopList = INTENT_ATLAS_STOP_WORDS.map((w) => `'${w}'`).join(", ");
+		return {
+			sql: `
+    WITH queries AS (
+      SELECT
+        query,
+        ${METRIC_EXPR.impressions} AS impressions,
+        ${METRIC_EXPR.clicks} AS clicks,
+        ${METRIC_EXPR.position} AS position
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ?
+        AND query IS NOT NULL AND query <> ''
+      GROUP BY query
+      HAVING SUM(impressions) >= ?
+    ),
+    tokens AS (
+      SELECT q.query, q.impressions, q.clicks, q.position,
+        LOWER(t.token) AS token
+      FROM queries q,
+        unnest(regexp_split_to_array(LOWER(q.query), '\\s+')) AS t(token)
+      WHERE LENGTH(t.token) >= 3
+        AND LOWER(t.token) NOT IN (${stopList})
+    ),
+    token_weights AS (
+      SELECT token,
+        SUM(impressions) AS token_impressions,
+        COUNT(DISTINCT query) AS query_count
+      FROM tokens
+      GROUP BY token
+      HAVING SUM(impressions) >= ${Number(minTokenImpressions)}
+    ),
+    ranked_tokens AS (
+      SELECT t.query, t.token, tw.token_impressions,
+        ROW_NUMBER() OVER (
+          PARTITION BY t.query
+          ORDER BY tw.token_impressions DESC, t.token ASC
+        ) AS rnk
+      FROM tokens t
+      JOIN token_weights tw USING (token)
+    ),
+    cluster_keys AS (
+      SELECT query,
+        array_to_string(list(token ORDER BY token), ' + ') AS cluster_key
+      FROM ranked_tokens
+      WHERE rnk <= 2
+      GROUP BY query
+      HAVING COUNT(*) >= 2
+    ),
+    clustered AS (
+      SELECT q.query, q.impressions, q.clicks, q.position, ck.cluster_key
+      FROM queries q
+      JOIN cluster_keys ck USING (query)
+    )
+    SELECT
+      cluster_key AS clusterKey,
+      COUNT(*) AS keywordCount,
+      SUM(impressions) AS totalImpressions,
+      SUM(clicks) AS totalClicks,
+      SUM(clicks) / NULLIF(SUM(impressions), 0) AS ctr,
+      AVG(position) AS avgPosition,
+      to_json(list({
+        'query': query,
+        'impressions': impressions,
+        'clicks': clicks,
+        'position': position
+      } ORDER BY impressions DESC)) AS keywords
+    FROM clustered
+    GROUP BY cluster_key
+    HAVING COUNT(*) >= ${Number(minClusterSize)}
+    ORDER BY totalImpressions DESC
+    LIMIT ${Number(limit)}
+  `,
+			params: [
+				startDate,
+				endDate,
+				minQueryImpressions
+			],
+			current: {
+				table: "keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows) {
+		const clusters = (Array.isArray(rows) ? rows : []).map((r) => ({
+			clusterKey: str$8(r.clusterKey),
+			keywordCount: num$1(r.keywordCount),
+			totalImpressions: num$1(r.totalImpressions),
+			totalClicks: num$1(r.totalClicks),
+			ctr: num$1(r.ctr),
+			avgPosition: num$1(r.avgPosition),
+			keywords: parseJsonList$6(r.keywords).slice(0, 25).map((k) => ({
+				query: str$8(k.query),
+				impressions: num$1(k.impressions),
+				clicks: num$1(k.clicks),
+				position: num$1(k.position)
+			}))
+		}));
+		const totalImpressions = clusters.reduce((s, c) => s + c.totalImpressions, 0);
+		const totalKeywords = clusters.reduce((s, c) => s + c.keywordCount, 0);
+		return {
+			results: clusters,
+			meta: {
+				total: clusters.length,
+				totalImpressions,
+				totalKeywords
+			}
+		};
+	}
+});
+function str$7(v) {
+	return v == null ? "" : String(v);
+}
+function parseJsonList$5(v) {
+	if (Array.isArray(v)) return v;
+	if (typeof v === "string" && v.length > 0) {
+		const parsed = JSON.parse(v);
+		return Array.isArray(parsed) ? parsed : [];
+	}
+	return [];
+}
+const keywordBreadthAnalyzer = defineAnalyzer$1({
+	id: "keyword-breadth",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf$1(params);
+		return {
+			sql: `
+    WITH per_page AS (
+      SELECT
+        url,
+        CAST(COUNT(DISTINCT query) AS DOUBLE) AS keywordCount,
+        ${METRIC_EXPR.clicks} AS clicks,
+        ${METRIC_EXPR.impressions} AS impressions
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ? AND impressions > 0
+      GROUP BY url
+    ),
+    bucketed AS (
+      SELECT
+        CASE
+          WHEN keywordCount = 1 THEN '1'
+          WHEN keywordCount BETWEEN 2 AND 5 THEN '2-5'
+          WHEN keywordCount BETWEEN 6 AND 15 THEN '6-15'
+          WHEN keywordCount BETWEEN 16 AND 50 THEN '16-50'
+          ELSE '50+'
+        END AS bucket,
+        MIN(keywordCount) AS sort_key,
+        CAST(COUNT(*) AS DOUBLE) AS pageCount
+      FROM per_page
+      GROUP BY bucket
+    ),
+    fragile AS (
+      SELECT url, keywordCount, clicks, impressions
+      FROM per_page
+      WHERE keywordCount <= 2 AND clicks >= 5
+      ORDER BY clicks DESC
+      LIMIT 20
+    ),
+    authority AS (
+      SELECT url, keywordCount, clicks, impressions
+      FROM per_page
+      WHERE keywordCount >= 20
+      ORDER BY keywordCount DESC
+      LIMIT 20
+    ),
+    stats AS (
+      SELECT
+        CAST(COUNT(*) AS DOUBLE) AS totalPages,
+        CAST(AVG(keywordCount) AS DOUBLE) AS avgKeywordsPerPage,
+        CAST(SUM(CASE WHEN keywordCount <= 2 THEN 1 ELSE 0 END) AS DOUBLE) AS fragileCount,
+        CAST(SUM(CASE WHEN keywordCount >= 20 THEN 1 ELSE 0 END) AS DOUBLE) AS authorityCount
+      FROM per_page
+    )
+    SELECT
+      (SELECT to_json(list({ 'bucket': bucket, 'pageCount': pageCount, 'sortKey': sort_key })
+        ORDER BY sort_key ASC) FROM bucketed) AS distribution_json,
+      (SELECT to_json(list({ 'url': url, 'keywordCount': keywordCount, 'clicks': clicks, 'impressions': impressions })) FROM fragile) AS fragile_json,
+      (SELECT to_json(list({ 'url': url, 'keywordCount': keywordCount, 'clicks': clicks, 'impressions': impressions })) FROM authority) AS authority_json,
+      (SELECT to_json({
+        'totalPages': totalPages,
+        'avgKeywordsPerPage': avgKeywordsPerPage,
+        'fragileCount': fragileCount,
+        'authorityCount': authorityCount
+      }) FROM stats) AS stats_json
+  `,
+			params: [startDate, endDate],
+			current: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const { startDate, endDate } = periodOf$1(params);
+		const row = arr[0] ?? {};
+		const distribution = parseJsonList$5(row.distribution_json).sort((a, b) => num$1(a.sortKey) - num$1(b.sortKey)).map((r) => ({
+			bucket: str$7(r.bucket),
+			pageCount: num$1(r.pageCount)
+		}));
+		const fragile = parseJsonList$5(row.fragile_json).map((r) => ({
+			url: str$7(r.url),
+			keywordCount: num$1(r.keywordCount),
+			clicks: num$1(r.clicks),
+			impressions: num$1(r.impressions)
+		}));
+		const authority = parseJsonList$5(row.authority_json).map((r) => ({
+			url: str$7(r.url),
+			keywordCount: num$1(r.keywordCount),
+			clicks: num$1(r.clicks),
+			impressions: num$1(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$1(stats.totalPages),
+					avgKeywordsPerPage: num$1(stats.avgKeywordsPerPage),
+					fragileCount: num$1(stats.fragileCount),
+					authorityCount: num$1(stats.authorityCount)
+				},
+				startDate,
+				endDate
+			}
+		};
+	}
+});
+function str$6(v) {
+	return v == null ? "" : String(v);
+}
+function parseJsonList$4(v) {
+	if (Array.isArray(v)) return v;
+	if (typeof v === "string" && v.length > 0) {
+		const parsed = JSON.parse(v);
+		return Array.isArray(parsed) ? parsed : [];
+	}
+	return [];
+}
+function downsampleLogRank(points) {
+	const all = points.map((p) => ({
+		rank: num$1(p.rank),
+		impressions: num$1(p.impressions),
+		clicks: num$1(p.clicks),
+		query: str$6(p.query)
+	}));
+	if (all.length <= 80) return all;
+	const top = all.slice(0, 10);
+	const rest = all.slice(10);
+	const stepped = [];
+	let nextThreshold = 1.15;
+	for (const p of rest) if (p.rank >= nextThreshold) {
+		stepped.push(p);
+		nextThreshold *= 1.15;
+	}
+	return [...top, ...stepped];
+}
+const longTailAnalyzer = defineAnalyzer$1({
+	id: "long-tail",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf$1(params);
+		const minQueries = 10;
+		const minQueryImpressions = params.minImpressions ?? 5;
+		const limit = params.limit ?? 100;
+		return {
+			sql: `
+    WITH page_queries AS (
+      SELECT
+        url AS page,
+        query,
+        ${METRIC_EXPR.impressions} AS impressions,
+        ${METRIC_EXPR.clicks} AS clicks
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ?
+        AND query IS NOT NULL AND query <> ''
+        AND url IS NOT NULL AND url <> ''
+      GROUP BY url, query
+      HAVING SUM(impressions) >= ?
+    ),
+    ranked AS (
+      SELECT
+        page, query, impressions, clicks,
+        ROW_NUMBER() OVER (PARTITION BY page ORDER BY impressions DESC, query ASC) AS rnk
+      FROM page_queries
+    ),
+    log_space AS (
+      SELECT *,
+        LN(rnk) AS log_rank,
+        LN(impressions) AS log_impr
+      FROM ranked
+    ),
+    fit AS (
+      SELECT
+        page,
+        COUNT(*) AS query_count,
+        SUM(impressions) AS total_impressions,
+        SUM(clicks) AS total_clicks,
+        REGR_SLOPE(log_impr, log_rank) AS slope,
+        REGR_INTERCEPT(log_impr, log_rank) AS intercept,
+        REGR_R2(log_impr, log_rank) AS r2,
+        MAX(impressions) AS head_impressions,
+        MAX(CASE WHEN rnk = 1 THEN impressions END) / NULLIF(SUM(impressions), 0) AS head_share
+      FROM log_space
+      GROUP BY page
+      HAVING COUNT(*) >= ${Number(minQueries)}
+    ),
+    scatter AS (
+      SELECT
+        l.page,
+        to_json(list({
+          'rank': l.rnk,
+          'impressions': l.impressions,
+          'clicks': l.clicks,
+          'query': l.query
+        } ORDER BY l.rnk)) AS pointsJson
+      FROM log_space l
+      JOIN fit f USING (page)
+      GROUP BY l.page
+    )
+    SELECT
+      f.page,
+      f.query_count AS queryCount,
+      f.total_impressions AS totalImpressions,
+      f.total_clicks AS totalClicks,
+      f.slope AS slope,
+      f.intercept AS intercept,
+      f.r2 AS r2,
+      f.head_impressions AS headImpressions,
+      f.head_share AS headShare,
+      s.pointsJson AS pointsJson,
+      CASE
+        WHEN f.slope > -0.6 THEN 'flat-tail'
+        WHEN f.slope > -1.2 THEN 'balanced'
+        ELSE 'head-heavy'
+      END AS fingerprint
+    FROM fit f
+    LEFT JOIN scatter s USING (page)
+    ORDER BY f.total_impressions DESC
+    LIMIT ${Number(limit)}
+  `,
+			params: [
+				startDate,
+				endDate,
+				minQueryImpressions
+			],
+			current: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows) {
+		const results = (Array.isArray(rows) ? rows : []).map((r) => ({
+			page: str$6(r.page),
+			queryCount: num$1(r.queryCount),
+			totalImpressions: num$1(r.totalImpressions),
+			totalClicks: num$1(r.totalClicks),
+			slope: num$1(r.slope),
+			intercept: num$1(r.intercept),
+			r2: num$1(r.r2),
+			headImpressions: num$1(r.headImpressions),
+			headShare: num$1(r.headShare),
+			fingerprint: str$6(r.fingerprint),
+			points: downsampleLogRank(parseJsonList$4(r.pointsJson))
+		}));
+		const counts = {
+			"flat-tail": 0,
+			"balanced": 0,
+			"head-heavy": 0
+		};
+		for (const r of results) counts[r.fingerprint]++;
+		return {
+			results,
+			meta: {
+				total: results.length,
+				fingerprints: counts,
+				avgSlope: results.length > 0 ? results.reduce((s, r) => s + r.slope, 0) / results.length : 0
+			}
+		};
+	}
+});
+function str$5(v) {
+	return v == null ? "" : String(v);
+}
+const positionDistributionAnalyzer = defineAnalyzer$1({
+	id: "position-distribution",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf$1(params);
+		return {
+			sql: `
+    WITH pos AS (
+      SELECT
+        date,
+        (sum_position / NULLIF(impressions, 0) + 1) AS avg_pos
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ? AND impressions > 0
+    )
+    SELECT
+      date,
+      CAST(SUM(CASE WHEN avg_pos <= 3 THEN 1 ELSE 0 END) AS DOUBLE) AS pos_1_3,
+      CAST(SUM(CASE WHEN avg_pos > 3 AND avg_pos <= 10 THEN 1 ELSE 0 END) AS DOUBLE) AS pos_4_10,
+      CAST(SUM(CASE WHEN avg_pos > 10 AND avg_pos <= 20 THEN 1 ELSE 0 END) AS DOUBLE) AS pos_11_20,
+      CAST(SUM(CASE WHEN avg_pos > 20 THEN 1 ELSE 0 END) AS DOUBLE) AS pos_20_plus,
+      CAST(COUNT(*) AS DOUBLE) AS total
+    FROM pos
+    GROUP BY date
+    ORDER BY date ASC
+  `,
+			params: [startDate, endDate],
+			current: {
+				table: "keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const { startDate, endDate } = periodOf$1(params);
+		return {
+			results: arr.map((r) => ({
+				date: str$5(r.date),
+				pos_1_3: num$1(r.pos_1_3),
+				pos_4_10: num$1(r.pos_4_10),
+				pos_11_20: num$1(r.pos_11_20),
+				pos_20_plus: num$1(r.pos_20_plus),
+				total: num$1(r.total)
+			})),
+			meta: {
+				total: arr.length,
+				startDate,
+				endDate
+			}
+		};
+	}
+});
+function str$4(v) {
+	return v == null ? "" : String(v);
+}
+const positionVolatilityAnalyzer = defineAnalyzer$1({
+	id: "position-volatility",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf$1(params);
+		const topN = params.topN ?? 30;
+		const minDayImpressions = params.minImpressions ?? 10;
+		const minDays = params.minWeeksWithData ?? 7;
+		return {
+			sql: `
+    WITH query_day AS (
+      SELECT
+        url AS page,
+        query,
+        date,
+        ${METRIC_EXPR.impressions} AS q_impressions,
+        ${METRIC_EXPR.position} AS q_position
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ?
+        AND query IS NOT NULL AND query <> ''
+        AND url IS NOT NULL AND url <> ''
+      GROUP BY url, query, date
+      HAVING SUM(impressions) >= 1
+    ),
+    daily AS (
+      SELECT
+        page, date,
+        COUNT(*) AS query_count,
+        SUM(q_impressions) AS day_impressions,
+        SUM(q_position * q_impressions) / NULLIF(SUM(q_impressions), 0) AS avg_position,
+        COALESCE(STDDEV_POP(q_position), 0.0) AS pos_stddev,
+        MIN(q_position) AS best_position,
+        MAX(q_position) AS worst_position
+      FROM query_day
+      GROUP BY page, date
+      HAVING SUM(q_impressions) >= ?
+    ),
+    with_shift AS (
+      SELECT *,
+        LAG(avg_position) OVER (PARTITION BY page ORDER BY date) AS prev_position,
+        COALESCE(
+          ABS(avg_position - LAG(avg_position) OVER (PARTITION BY page ORDER BY date)),
+          0.0
+        ) AS dod_shift
+      FROM daily
+    ),
+    scored AS (
+      SELECT *,
+        pos_stddev + dod_shift AS volatility
+      FROM with_shift
+    ),
+    top_pages AS (
+      SELECT page,
+        SUM(day_impressions) AS total_impressions,
+        AVG(volatility) AS avg_volatility,
+        MAX(volatility) AS peak_volatility,
+        COUNT(*) AS days_with_data
+      FROM scored
+      GROUP BY page
+      HAVING COUNT(*) >= ?
+      ORDER BY avg_volatility DESC
+      LIMIT ${Number(topN)}
+    )
+    SELECT
+      s.page,
+      strftime(s.date, '%Y-%m-%d') AS date,
+      s.query_count AS queryCount,
+      s.day_impressions AS dayImpressions,
+      s.avg_position AS avgPosition,
+      s.pos_stddev AS posStddev,
+      s.best_position AS bestPosition,
+      s.worst_position AS worstPosition,
+      s.dod_shift AS dodShift,
+      s.volatility AS volatility,
+      t.avg_volatility AS pageAvgVolatility,
+      t.peak_volatility AS pagePeakVolatility,
+      t.total_impressions AS pageTotalImpressions
+    FROM scored s
+    JOIN top_pages t USING (page)
+    ORDER BY t.avg_volatility DESC, s.date ASC
+  `,
+			params: [
+				startDate,
+				endDate,
+				minDayImpressions,
+				minDays
+			],
+			current: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const byPage = /* @__PURE__ */ new Map();
+		const allDates = /* @__PURE__ */ new Set();
+		for (const r of arr) {
+			const page = str$4(r.page);
+			const date = str$4(r.date);
+			allDates.add(date);
+			const entry = byPage.get(page) ?? {
+				page,
+				avgVolatility: num$1(r.pageAvgVolatility),
+				peakVolatility: num$1(r.pagePeakVolatility),
+				totalImpressions: num$1(r.pageTotalImpressions),
+				days: []
+			};
+			entry.days.push({
+				date,
+				queryCount: num$1(r.queryCount),
+				dayImpressions: num$1(r.dayImpressions),
+				avgPosition: num$1(r.avgPosition),
+				posStddev: num$1(r.posStddev),
+				bestPosition: num$1(r.bestPosition),
+				worstPosition: num$1(r.worstPosition),
+				dodShift: num$1(r.dodShift),
+				volatility: num$1(r.volatility)
+			});
+			byPage.set(page, entry);
+		}
+		const pages = [...byPage.values()].sort((a, b) => b.avgVolatility - a.avgVolatility);
+		const dates = [...allDates].sort();
+		const maxVolatility = pages.reduce((m, p) => Math.max(m, p.peakVolatility), 0);
+		return {
+			results: pages,
+			meta: {
+				total: pages.length,
+				dates,
+				maxVolatility
+			}
+		};
+	}
+});
+function str$3(v) {
+	return v == null ? "" : String(v);
+}
+function parseJsonList$3(v) {
+	if (Array.isArray(v)) return v;
+	if (typeof v === "string" && v.length > 0) {
+		const parsed = JSON.parse(v);
+		return Array.isArray(parsed) ? parsed : [];
+	}
+	return [];
+}
+const queryMigrationAnalyzer = defineAnalyzer$1({
+	id: "query-migration",
+	buildSql(params) {
+		const cur = periodOf$1(params);
+		let prevStart = params.prevStartDate;
+		let prevEnd = params.prevEndDate;
+		if (prevStart == null || prevEnd == null) {
+			const curStartMs = new Date(cur.startDate).getTime();
+			const span = new Date(cur.endDate).getTime() - curStartMs;
+			prevEnd = toIsoDate(new Date(curStartMs - MS_PER_DAY));
+			prevStart = toIsoDate(new Date(curStartMs - MS_PER_DAY - span));
+		}
+		const minImpressions = params.minImpressions ?? 20;
+		const limit = params.limit ?? 200;
+		const maxLevenshtein = 2;
+		return {
+			sql: `
+    WITH cur AS (
+      SELECT query, url AS page,
+        ${METRIC_EXPR.impressions} AS impressions,
+        ${METRIC_EXPR.clicks} AS clicks,
+        ${METRIC_EXPR.position} AS position
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ?
+        AND query IS NOT NULL AND query <> ''
+        AND url IS NOT NULL AND url <> ''
+      GROUP BY query, url
+      HAVING SUM(impressions) >= ?
+    ),
+    prev AS (
+      SELECT query, url AS page,
+        ${METRIC_EXPR.impressions} AS impressions,
+        ${METRIC_EXPR.clicks} AS clicks,
+        ${METRIC_EXPR.position} AS position
+      FROM read_parquet({{FILES_PREV}}, union_by_name = true)
+      WHERE date >= ? AND date <= ?
+        AND query IS NOT NULL AND query <> ''
+        AND url IS NOT NULL AND url <> ''
+      GROUP BY query, url
+      HAVING SUM(impressions) >= ?
+    ),
+    lost AS (
+      SELECT p.page AS source_page, p.query AS source_query, p.impressions AS source_impressions
+      FROM prev p
+      LEFT JOIN cur c ON p.page = c.page AND p.query = c.query
+      WHERE c.query IS NULL
+    ),
+    gained AS (
+      SELECT c.page AS target_page, c.query AS target_query, c.impressions AS target_impressions
+      FROM cur c
+      LEFT JOIN prev p ON p.page = c.page AND p.query = c.query
+      WHERE p.query IS NULL
+    ),
+    matched AS (
+      SELECT
+        l.source_page, l.source_query, l.source_impressions,
+        g.target_page, g.target_query, g.target_impressions,
+        CASE
+          WHEN l.source_query = g.target_query THEN 'exact'
+          ELSE 'fuzzy'
+        END AS match_type,
+        LEAST(l.source_impressions, g.target_impressions) AS absorbed_impressions
+      FROM lost l
+      JOIN gained g
+        ON l.source_page <> g.target_page
+        AND ABS(LENGTH(l.source_query) - LENGTH(g.target_query)) <= ${maxLevenshtein}
+        AND (
+          l.source_query = g.target_query
+          OR levenshtein(l.source_query, g.target_query) <= ${maxLevenshtein}
+        )
+    ),
+    edges AS (
+      SELECT
+        source_page, target_page,
+        SUM(absorbed_impressions) AS weight,
+        COUNT(*) AS query_count,
+        SUM(CASE WHEN match_type = 'exact' THEN 1 ELSE 0 END) AS exact_count,
+        to_json(list({
+          'sourceQuery': source_query,
+          'targetQuery': target_query,
+          'absorbed': absorbed_impressions,
+          'matchType': match_type
+        } ORDER BY absorbed_impressions DESC)) AS examplesJson
+      FROM matched
+      GROUP BY source_page, target_page
+    )
+    SELECT *
+    FROM edges
+    ORDER BY weight DESC
+    LIMIT ${Number(limit)}
+  `,
+			params: [
+				cur.startDate,
+				cur.endDate,
+				minImpressions,
+				prevStart,
+				prevEnd,
+				minImpressions
+			],
+			current: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(cur.startDate, cur.endDate)
+			},
+			previous: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(prevStart, prevEnd)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const cur = periodOf$1(params);
+		let prevStart = params.prevStartDate;
+		let prevEnd = params.prevEndDate;
+		if (prevStart == null || prevEnd == null) {
+			const curStartMs = new Date(cur.startDate).getTime();
+			const span = new Date(cur.endDate).getTime() - curStartMs;
+			prevEnd = toIsoDate(new Date(curStartMs - MS_PER_DAY));
+			prevStart = toIsoDate(new Date(curStartMs - MS_PER_DAY - span));
+		}
+		const edges = arr.map((r) => ({
+			sourcePage: str$3(r.source_page),
+			targetPage: str$3(r.target_page),
+			weight: num$1(r.weight),
+			queryCount: num$1(r.query_count),
+			exactCount: num$1(r.exact_count),
+			fuzzyCount: num$1(r.query_count) - num$1(r.exact_count),
+			examples: parseJsonList$3(r.examplesJson).slice(0, 8).map((e) => ({
+				sourceQuery: str$3(e.sourceQuery),
+				targetQuery: str$3(e.targetQuery),
+				absorbed: num$1(e.absorbed),
+				matchType: str$3(e.matchType)
+			}))
+		}));
+		const nodeAgg = /* @__PURE__ */ new Map();
+		for (const e of edges) {
+			const src = nodeAgg.get(e.sourcePage) ?? {
+				url: e.sourcePage,
+				outgoing: 0,
+				incoming: 0
+			};
+			src.outgoing += e.weight;
+			nodeAgg.set(e.sourcePage, src);
+			const tgt = nodeAgg.get(e.targetPage) ?? {
+				url: e.targetPage,
+				outgoing: 0,
+				incoming: 0
+			};
+			tgt.incoming += e.weight;
+			nodeAgg.set(e.targetPage, tgt);
+		}
+		const nodes = [...nodeAgg.values()];
+		const totalAbsorbed = edges.reduce((s, e) => s + e.weight, 0);
+		return {
+			results: edges,
+			meta: {
+				total: edges.length,
+				totalAbsorbed,
+				period: {
+					current: cur,
+					previous: {
+						startDate: prevStart,
+						endDate: prevEnd
+					}
+				},
+				nodes
+			}
+		};
+	}
+});
+function str$2(v) {
+	return v == null ? "" : String(v);
+}
+function bool(v) {
+	return v === true || v === 1 || v === "true";
 }
-async function collectRows(gen) {
-	const out = [];
-	for await (const batch of gen) out.push(...batch);
-	return out;
+function parseJsonList$2(v) {
+	if (Array.isArray(v)) return v;
+	if (typeof v === "string" && v.length > 0) {
+		const parsed = JSON.parse(v);
+		return Array.isArray(parsed) ? parsed : [];
+	}
+	return [];
 }
-const METRIC_NAMES = [
-	"clicks",
-	"impressions",
-	"ctr",
-	"position"
-];
-function isMetricDimension$2(dim) {
-	return METRIC_NAMES.includes(dim);
-}
-function applyBuilderStatePostProcessing(rows, state) {
-	const dimensionFilters = getDimensionFilters(state.filter, isMetricDimension$2);
-	const metricFilters = extractMetricFilters(state.filter);
-	const specialFilters = extractSpecialOperatorFilters(state.filter);
-	const ordered = [...rows.filter((row) => {
-		if (!dimensionFilters.every((filter) => matchesDimensionFilter(row, filter))) return false;
-		if (!metricFilters.every((filter) => matchesMetricFilter(row, filter))) return false;
-		if (specialFilters.some((filter) => filter.operator === "topLevel") && !matchesTopLevelPage(row)) return false;
-		return true;
-	})].sort((a, b) => {
-		const column = state.orderBy?.column ?? "clicks";
-		const dir = state.orderBy?.dir ?? "desc";
-		const left = column === "date" ? String(a.date ?? "") : metricValue(a, column);
-		const right = column === "date" ? String(b.date ?? "") : metricValue(b, column);
-		if (left === right) return 0;
-		if (dir === "asc") return left < right ? -1 : 1;
-		return left > right ? -1 : 1;
-	});
-	const offset = Math.max(0, Number(state.startRow ?? 0));
-	const limit = Math.max(0, Number((state.rowLimit ?? ordered.length) || 0));
-	return ordered.slice(offset, offset + limit);
+const stlDecomposeAnalyzer = defineAnalyzer$1({
+	id: "stl-decompose",
+	buildSql(params) {
+		const endDate = params.endDate ?? defaultEndDate();
+		const startDate = params.startDate ?? daysAgo(93);
+		const minImpressions = params.minImpressions ?? 100;
+		const minDays = 21;
+		const metric = params.metric === "clicks" ? "clicks" : "impressions";
+		const limit = params.limit ?? 100;
+		return {
+			sql: `
+    WITH daily AS (
+      SELECT
+        query,
+        url AS page,
+        date,
+        ${METRIC_EXPR.clicks} AS clicks,
+        ${METRIC_EXPR.impressions} AS impressions,
+        CAST(SUM(${metric}) AS DOUBLE) AS observed
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ?
+        AND query IS NOT NULL AND query <> ''
+        AND url IS NOT NULL AND url <> ''
+      GROUP BY query, url, date
+    ),
+    entity_stats AS (
+      SELECT query, page,
+        COUNT(*) AS days,
+        SUM(impressions) AS total_impressions
+      FROM daily
+      GROUP BY query, page
+      HAVING COUNT(*) >= ${Number(minDays)}
+        AND SUM(impressions) >= ?
+    ),
+    filtered AS (
+      SELECT d.*
+      FROM daily d
+      JOIN entity_stats e USING (query, page)
+    ),
+    trended AS (
+      SELECT *,
+        CASE
+          WHEN COUNT(*) OVER w = 7
+            THEN AVG(observed) OVER w
+          ELSE NULL
+        END AS trend
+      FROM filtered
+      WINDOW w AS (
+        PARTITION BY query, page
+        ORDER BY date
+        ROWS BETWEEN 3 PRECEDING AND 3 FOLLOWING
+      )
+    ),
+    detrended AS (
+      SELECT *,
+        observed - trend AS detrended,
+        dayofweek(date) AS dow
+      FROM trended
+    ),
+    seasonal_raw AS (
+      SELECT *,
+        AVG(detrended) OVER (PARTITION BY query, page, dow) AS seasonal_dow
+      FROM detrended
+    ),
+    seasonal_centered AS (
+      SELECT *,
+        seasonal_dow - AVG(seasonal_dow) OVER (PARTITION BY query, page) AS seasonal
+      FROM seasonal_raw
+    ),
+    residualed AS (
+      SELECT *,
+        CASE
+          WHEN trend IS NULL OR seasonal IS NULL THEN NULL
+          ELSE observed - trend - seasonal
+        END AS residual
+      FROM seasonal_centered
+    ),
+    scored AS (
+      SELECT *,
+        STDDEV_POP(residual) OVER (PARTITION BY query, page) AS resid_std,
+        CASE
+          WHEN residual IS NOT NULL
+            AND STDDEV_POP(residual) OVER (PARTITION BY query, page) > 0
+            AND ABS(residual) > 2.0 * STDDEV_POP(residual) OVER (PARTITION BY query, page)
+          THEN true ELSE false
+        END AS anomaly
+      FROM residualed
+    ),
+    per_entity AS (
+      SELECT query, page,
+        COUNT(*) AS days,
+        SUM(impressions) AS total_impressions,
+        VAR_POP(detrended) AS var_detrended,
+        VAR_POP(seasonal) AS var_seasonal,
+        VAR_POP(residual) AS var_residual,
+        COUNT(*) FILTER (WHERE anomaly) AS residual_anomalies,
+        REGR_SLOPE(observed, epoch(date) / 86400.0) AS trend_slope
+      FROM scored
+      GROUP BY query, page
+    ),
+    series AS (
+      SELECT query, page,
+        to_json(list({
+          'date': strftime(date, '%Y-%m-%d'),
+          'observed': observed,
+          'trend': trend,
+          'seasonal': seasonal,
+          'residual': residual,
+          'anomaly': anomaly
+        } ORDER BY date)) AS seriesJson
+      FROM scored
+      GROUP BY query, page
+    )
+    SELECT
+      e.query AS keyword,
+      e.page,
+      CAST(e.total_impressions AS DOUBLE) AS totalImpressions,
+      CAST(e.days AS DOUBLE) AS days,
+      CASE
+        WHEN e.var_detrended IS NULL OR e.var_detrended = 0 THEN 0.0
+        ELSE LEAST(e.var_seasonal / NULLIF(e.var_detrended, 0), 1.0)
+      END AS seasonalStrength,
+      CASE
+        WHEN e.var_detrended IS NULL OR e.var_detrended = 0 THEN 0.0
+        ELSE GREATEST(0.0, 1.0 - e.var_residual / NULLIF(e.var_detrended, 0))
+      END AS trendStrength,
+      CAST(e.residual_anomalies AS DOUBLE) AS residualAnomalies,
+      COALESCE(e.trend_slope, 0.0) AS trendSlope,
+      s.seriesJson
+    FROM per_entity e
+    LEFT JOIN series s USING (query, page)
+    ORDER BY seasonalStrength DESC, ABS(COALESCE(e.trend_slope, 0.0)) DESC
+    LIMIT ${Number(limit)}
+  `,
+			params: [
+				startDate,
+				endDate,
+				minImpressions
+			],
+			current: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const metric = params.metric === "clicks" ? "clicks" : "impressions";
+		const results = arr.map((r) => ({
+			keyword: str$2(r.keyword),
+			page: str$2(r.page),
+			totalImpressions: num$1(r.totalImpressions),
+			days: num$1(r.days),
+			seasonalStrength: num$1(r.seasonalStrength),
+			trendStrength: num$1(r.trendStrength),
+			residualAnomalies: num$1(r.residualAnomalies),
+			trendSlope: num$1(r.trendSlope),
+			series: parseJsonList$2(r.seriesJson).map((s) => ({
+				date: str$2(s.date),
+				observed: num$1(s.observed),
+				trend: s.trend == null ? null : num$1(s.trend),
+				seasonal: s.seasonal == null ? null : num$1(s.seasonal),
+				residual: s.residual == null ? null : num$1(s.residual),
+				anomaly: bool(s.anomaly)
+			}))
+		}));
+		return {
+			results,
+			meta: {
+				total: results.length,
+				metric,
+				avgSeasonalStrength: results.length > 0 ? results.reduce((a, r) => a + r.seasonalStrength, 0) / results.length : 0
+			}
+		};
+	}
+});
+function str$1(v) {
+	return v == null ? "" : String(v);
 }
-const GSC_API_CAPABILITIES = {
-	regex: true,
-	multiDataset: false,
-	comparisonJoin: false,
-	windowTotals: false
-};
-function isMetricDimension$1(dim) {
-	return [
-		"clicks",
-		"impressions",
-		"ctr",
-		"position"
-	].includes(dim);
-}
-function builderFromState(state) {
-	return { getState: () => state };
-}
-function createGscApiQuerySource(options) {
-	const { client, siteUrl } = options;
-	return {
-		name: "gsc-api",
-		capabilities: GSC_API_CAPABILITIES,
-		async queryRows(state) {
-			buildLogicalPlan(state, GSC_API_CAPABILITIES);
-			const filterDims = getFilterDimensions(state.filter, isMetricDimension$1);
-			assertDimensionsSupported([...state.dimensions, ...filterDims], "api", "gsc-api query source");
-			return applyBuilderStatePostProcessing(await collectRows(client.query(siteUrl, builderFromState(state))), state);
-		}
-	};
+function parseJsonList$1(v) {
+	if (Array.isArray(v)) return v;
+	if (typeof v === "string" && v.length > 0) {
+		const parsed = JSON.parse(v);
+		return Array.isArray(parsed) ? parsed : [];
+	}
+	return [];
+}
+const survivalAnalyzer = defineAnalyzer$1({
+	id: "survival",
+	buildSql(params) {
+		const endDate = params.endDate ?? defaultEndDate();
+		const startDate = params.startDate ?? daysAgo(183);
+		const minImpressions = params.minImpressions ?? 5;
+		return {
+			sql: `
+    WITH daily AS (
+      SELECT
+        query,
+        url,
+        date,
+        ${METRIC_EXPR.clicks} AS day_clicks,
+        ${METRIC_EXPR.impressions} AS day_impressions,
+        ${METRIC_EXPR.position} AS day_position
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ?
+        AND query IS NOT NULL AND query <> ''
+        AND url IS NOT NULL AND url <> ''
+      GROUP BY query, url, date
+      HAVING SUM(impressions) >= ?
+    ),
+    classified AS (
+      SELECT *,
+        (day_position <= 10) AS in_top10
+      FROM daily
+    ),
+    transitions AS (
+      SELECT *,
+        CASE
+          WHEN in_top10 AND (LAG(in_top10) OVER w IS NULL OR NOT LAG(in_top10) OVER w)
+            THEN 1 ELSE 0
+        END AS is_entry
+      FROM classified
+      WINDOW w AS (PARTITION BY query, url ORDER BY date)
+    ),
+    run_ids AS (
+      SELECT *,
+        SUM(is_entry) OVER (PARTITION BY query, url ORDER BY date) AS run_id
+      FROM transitions
+      WHERE in_top10
+    ),
+    window_bounds AS (
+      SELECT MIN(date) AS window_start, MAX(date) AS window_end FROM daily
+    ),
+    episodes_raw AS (
+      SELECT
+        query, url, run_id,
+        MIN(date) AS entry_date,
+        MAX(date) AS exit_date,
+        DATEDIFF('day', MIN(date), MAX(date)) + 1 AS tenure
+      FROM run_ids
+      GROUP BY query, url, run_id
+    ),
+    episodes AS (
+      SELECT
+        e.query, e.url, e.run_id, e.entry_date, e.exit_date, e.tenure,
+        (e.exit_date >= wb.window_end - INTERVAL 2 DAY) AS censored,
+        CASE
+          WHEN regexp_extract(e.url, '^(?:https?://[^/]+)?(/[^/?#]*)', 1) = '/' OR e.url = '/'
+            THEN 'home'
+          WHEN regexp_extract(e.url, '^(?:https?://[^/]+)?/([^/?#]+)', 1) = ''
+            THEN 'home'
+          ELSE regexp_extract(e.url, '^(?:https?://[^/]+)?/([^/?#]+)', 1)
+        END AS cohort
+      FROM episodes_raw e
+      CROSS JOIN window_bounds wb
+    ),
+    episodes_all AS (
+      SELECT query, url, tenure, censored, cohort FROM episodes
+      UNION ALL
+      SELECT query, url, tenure, censored, '__all__' AS cohort FROM episodes
+    ),
+    cohort_totals AS (
+      SELECT cohort, COUNT(*) AS n_total
+      FROM episodes_all
+      GROUP BY cohort
+    ),
+    events AS (
+      SELECT
+        cohort,
+        tenure,
+        COUNT(*) FILTER (WHERE NOT censored) AS d_t,
+        COUNT(*) AS n_ending_at_t
+      FROM episodes_all
+      GROUP BY cohort, tenure
+    ),
+    km AS (
+      SELECT
+        e.cohort,
+        e.tenure,
+        e.d_t,
+        e.n_ending_at_t,
+        SUM(e.n_ending_at_t) OVER (PARTITION BY e.cohort ORDER BY e.tenure DESC
+          ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS at_risk
+      FROM events e
+    ),
+    km_surv AS (
+      SELECT
+        cohort, tenure, d_t, at_risk,
+        EXP(SUM(LN(GREATEST(1.0 - CAST(d_t AS DOUBLE) / NULLIF(at_risk, 0), 1e-9)))
+          OVER (PARTITION BY cohort ORDER BY tenure
+            ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)) AS survival
+      FROM km
+    ),
+    curve_agg AS (
+      SELECT
+        cohort,
+        to_json(list({
+          'tenure': tenure,
+          'survival': survival,
+          'atRisk': at_risk,
+          'events': d_t
+        } ORDER BY tenure)) AS curveJson
+      FROM km_surv
+      GROUP BY cohort
+    ),
+    cohort_stats AS (
+      SELECT
+        ea.cohort,
+        COUNT(*) AS episode_count,
+        AVG(CASE WHEN ea.censored THEN 1.0 ELSE 0.0 END) AS censoring_rate
+      FROM episodes_all ea
+      GROUP BY ea.cohort
+    )
+    SELECT
+      cs.cohort,
+      cs.episode_count AS episodeCount,
+      cs.censoring_rate AS censoringRate,
+      ca.curveJson
+    FROM cohort_stats cs
+    LEFT JOIN curve_agg ca USING (cohort)
+    ORDER BY cs.cohort
+  `,
+			params: [
+				startDate,
+				endDate,
+				minImpressions
+			],
+			current: {
+				table: "page_keywords",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const endDate = params.endDate ?? defaultEndDate();
+		const startDate = params.startDate ?? daysAgo(183);
+		const windowDays = Math.round((new Date(endDate).getTime() - new Date(startDate).getTime()) / MS_PER_DAY) + 1;
+		const results = arr.map((r) => {
+			const curve = parseJsonList$1(r.curveJson).map((p) => ({
+				tenure: num$1(p.tenure),
+				survival: num$1(p.survival),
+				atRisk: num$1(p.atRisk),
+				events: num$1(p.events)
+			}));
+			let medianTenure = 0;
+			for (let i = 0; i < curve.length; i++) {
+				const cur = curve[i];
+				if (cur.survival <= .5) {
+					if (i === 0) medianTenure = cur.tenure;
+					else {
+						const prev = curve[i - 1];
+						const span = prev.survival - cur.survival;
+						const frac = span > 0 ? (prev.survival - .5) / span : 0;
+						medianTenure = prev.tenure + frac * (cur.tenure - prev.tenure);
+					}
+					break;
+				}
+			}
+			const last = curve[curve.length - 1];
+			if (medianTenure === 0 && last && last.survival > .5) medianTenure = last.tenure;
+			return {
+				cohort: str$1(r.cohort),
+				episodeCount: num$1(r.episodeCount),
+				censoringRate: num$1(r.censoringRate),
+				medianTenure,
+				curve
+			};
+		});
+		return {
+			results,
+			meta: {
+				totalEpisodes: results.find((r) => r.cohort === "__all__")?.episodeCount ?? 0,
+				cohortCount: results.filter((r) => r.cohort !== "__all__").length,
+				windowDays
+			}
+		};
+	}
+});
+function str(v) {
+	return v == null ? "" : String(v);
 }
-function isMetricDimension(dim) {
-	return [
-		"clicks",
-		"impressions",
-		"ctr",
-		"position"
-	].includes(dim);
+function parseJsonList(v) {
+	if (Array.isArray(v)) return v;
+	if (typeof v === "string" && v.length > 0) {
+		const parsed = JSON.parse(v);
+		return Array.isArray(parsed) ? parsed : [];
+	}
+	return [];
 }
-const ENGINE_SOURCE_CAPABILITIES = {
-	regex: true,
-	multiDataset: false,
-	comparisonJoin: false,
-	windowTotals: false,
-	fileSets: true,
-	localSource: true
-};
-function createEngineQuerySource(options) {
-	const { engine, ctx } = options;
+const trendsAnalyzer = defineAnalyzer$1({
+	id: "trends",
+	buildSql(params) {
+		const weeks = params.weeks ?? 28;
+		const endDate = params.endDate || defaultEndDate();
+		const startDate = params.startDate || toIsoDate(/* @__PURE__ */ new Date(Date.parse(endDate) - (weeks * 7 - 1) * MS_PER_DAY));
+		const minImpressions = params.minImpressions ?? 100;
+		const minWeeksWithData = params.minWeeksWithData ?? Math.max(2, Math.floor(weeks / 4));
+		const limit = params.limit ?? 500;
+		const dim = params.dimension === "keywords" ? "keywords" : "pages";
+		const table = dim === "keywords" ? "keywords" : "pages";
+		return {
+			sql: `
+    WITH bucketed AS (
+      SELECT
+        ${dim === "keywords" ? "query" : "url"} AS entity,
+        date_trunc('week', CAST(date AS DATE)) AS week,
+        ${METRIC_EXPR.clicks} AS clicks,
+        ${METRIC_EXPR.impressions} AS impressions,
+        SUM(sum_position) AS sum_position_sum
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ?
+      GROUP BY entity, week
+    ),
+    with_meta AS (
+      SELECT
+        entity, week, clicks, impressions, sum_position_sum,
+        ROW_NUMBER() OVER (PARTITION BY entity ORDER BY week) - 1 AS week_idx,
+        COUNT(*) OVER (PARTITION BY entity) AS n_weeks,
+        (ROW_NUMBER() OVER (PARTITION BY entity ORDER BY week) - 1)
+          < (COUNT(*) OVER (PARTITION BY entity) / 2) AS is_first_half
+      FROM bucketed
+    ),
+    agg AS (
+      SELECT
+        entity,
+        SUM(clicks) AS totalClicks,
+        SUM(impressions) AS totalImpressions,
+        any_value(n_weeks) AS weeksWithData,
+        COALESCE(regr_slope(clicks, CAST(week_idx AS DOUBLE)), 0.0) AS slope,
+        SUM(CASE WHEN is_first_half THEN clicks ELSE 0 END) AS firstHalfClicks,
+        SUM(CASE WHEN NOT is_first_half THEN clicks ELSE 0 END) AS secondHalfClicks,
+        SUM(sum_position_sum) / NULLIF(SUM(impressions), 0) + 1 AS avgPosition,
+        to_json(list({
+          'week': strftime(week, '%Y-%m-%d'),
+          'clicks': clicks,
+          'impressions': impressions
+        } ORDER BY week)) AS seriesJson
+      FROM with_meta
+      GROUP BY entity
+      HAVING SUM(impressions) >= ? AND any_value(n_weeks) >= ?
+    ),
+    classified AS (
+      SELECT
+        *,
+        CASE
+          WHEN firstHalfClicks = 0 AND secondHalfClicks > 0 THEN 10.0
+          WHEN firstHalfClicks = 0 THEN 1.0
+          ELSE secondHalfClicks / firstHalfClicks
+        END AS growthRatio
+      FROM agg
+    )
+    SELECT
+      entity,
+      totalClicks,
+      totalImpressions,
+      weeksWithData,
+      slope,
+      growthRatio,
+      avgPosition,
+      CASE
+        WHEN growthRatio >= 1.5 AND slope > 0 THEN 'accelerating'
+        WHEN growthRatio >= 1.1 AND slope >= 0 THEN 'growing'
+        WHEN growthRatio < 0.5 THEN 'cratering'
+        WHEN growthRatio < 0.9 AND slope < 0 THEN 'declining'
+        ELSE 'steady'
+      END AS trend,
+      seriesJson
+    FROM classified
+    ORDER BY
+      CASE
+        WHEN growthRatio >= 1.5 AND slope > 0 THEN 0
+        WHEN growthRatio < 0.5 THEN 1
+        WHEN growthRatio >= 1.1 AND slope >= 0 THEN 2
+        WHEN growthRatio < 0.9 AND slope < 0 THEN 3
+        ELSE 4
+      END,
+      ABS(growthRatio - 1) DESC,
+      totalClicks DESC
+    LIMIT ${Number(limit)}
+  `,
+			params: [
+				startDate,
+				endDate,
+				minImpressions,
+				minWeeksWithData
+			],
+			current: {
+				table,
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const weeks = params.weeks ?? 28;
+		const endDate = params.endDate || defaultEndDate();
+		const startDate = params.startDate || toIsoDate(/* @__PURE__ */ new Date(Date.parse(endDate) - (weeks * 7 - 1) * MS_PER_DAY));
+		const dim = params.dimension === "keywords" ? "keywords" : "pages";
+		const results = arr.map((r) => {
+			const series = parseJsonList(r.seriesJson).map((s) => ({
+				week: str(s.week),
+				clicks: num$1(s.clicks),
+				impressions: num$1(s.impressions)
+			}));
+			return {
+				[dim === "keywords" ? "query" : "page"]: str(r.entity),
+				totalClicks: num$1(r.totalClicks),
+				totalImpressions: num$1(r.totalImpressions),
+				weeksWithData: num$1(r.weeksWithData),
+				slope: num$1(r.slope),
+				growthRatio: num$1(r.growthRatio),
+				avgPosition: num$1(r.avgPosition),
+				trend: str(r.trend),
+				series
+			};
+		});
+		const counts = {
+			accelerating: 0,
+			growing: 0,
+			steady: 0,
+			declining: 0,
+			cratering: 0
+		};
+		for (const r of results) counts[r.trend] = (counts[r.trend] ?? 0) + 1;
+		return {
+			results,
+			meta: {
+				total: results.length,
+				dimension: dim,
+				weeks: Number(weeks),
+				startDate,
+				endDate,
+				counts
+			}
+		};
+	}
+});
+const SQL_ANALYZERS = [
+	bayesianCtrAnalyzer.sql,
+	bipartitePagerankAnalyzer.sql,
+	brandAnalyzer.sql,
+	cannibalizationAnalyzer.sql,
+	changePointAnalyzer.sql,
+	clusteringAnalyzer.sql,
+	concentrationAnalyzer.sql,
+	contentVelocityAnalyzer.sql,
+	ctrAnomalyAnalyzer.sql,
+	ctrCurveAnalyzer.sql,
+	darkTrafficAnalyzer.sql,
+	dataDetailAnalyzer.sql,
+	dataQueryAnalyzer.sql,
+	decayAnalyzer.sql,
+	deviceGapAnalyzer.sql,
+	intentAtlasAnalyzer.sql,
+	keywordBreadthAnalyzer.sql,
+	longTailAnalyzer.sql,
+	moversAnalyzer.sql,
+	opportunityAnalyzer.sql,
+	positionDistributionAnalyzer.sql,
+	positionVolatilityAnalyzer.sql,
+	queryMigrationAnalyzer.sql,
+	seasonalityAnalyzer.sql,
+	stlDecomposeAnalyzer.sql,
+	strikingDistanceAnalyzer.sql,
+	survivalAnalyzer.sql,
+	trendsAnalyzer.sql,
+	zeroClickAnalyzer.sql
+];
+const defaultAnalyzerRegistry = createAnalyzerRegistry$1({
+	rows: ROW_ANALYZERS,
+	sql: SQL_ANALYZERS
+});
+async function analyzeInBrowser(runner, opts, params) {
+	opts.signal?.throwIfAborted();
+	return runAnalyzerFromSource$1(createAttachedTableSource(runner, opts), params, defaultAnalyzerRegistry);
+}
+function createCompositeSource(opts) {
+	const { engine, live, site } = opts;
+	function rangeCovered(state) {
+		const { startDate, endDate } = extractDateRange(state.filter);
+		return !!(startDate && endDate && site.oldestDateSynced && site.newestDateSynced && startDate >= site.oldestDateSynced && endDate <= site.newestDateSynced);
+	}
 	return {
-		name: "engine",
-		capabilities: ENGINE_SOURCE_CAPABILITIES,
+		name: "composite-engine-live",
+		capabilities: engine.capabilities,
 		async queryRows(state) {
-			const filterDims = getFilterDimensions(state.filter, isMetricDimension);
-			assertDimensionsSupported([...state.dimensions, ...filterDims], "stored", "engine query source");
-			if (state.dimensions.includes("queryCanonical") || filterDims.includes("queryCanonical")) throw new Error("engine query source does not support queryCanonical; use browser/sqlite query sources for derived dimensions");
-			return (await engine.query(ctx, state)).rows;
+			if (!rangeCovered(state) && canProxyToGsc(state)) return live.queryRows(state);
+			return engine.queryRows(state);
 		},
-		async executeSql(sql, params, opts) {
-			const fileSets = opts?.fileSets;
-			if (!fileSets?.FILES) throw new Error("engine query source: executeSql requires opts.fileSets with a FILES entry");
-			const { rows } = await engine.runSQL({
-				ctx,
-				table: fileSets.FILES.table,
-				fileSets,
-				sql,
-				params: params ?? []
-			});
-			return rows;
-		}
+		executeSql: engine.executeSql
 	};
 }
-async function runAnalyzerWithEngine(deps, ctx, params, registry) {
-	return runAnalyzerFromSource(createEngineQuerySource({
-		engine: deps.engine,
-		ctx
-	}), params, registry);
-}
 const IN_MEMORY_DEFAULT_CAPABILITIES = {
 	regex: true,
 	multiDataset: true,
@@ -2712,10 +5204,10 @@ function analyzeStrikingDistance(keywords, options = {}) {
 	const { minPosition = 4, maxPosition = 20, minImpressions = 100, maxCtr = .05, sortBy = "potentialClicks", sortOrder = "desc" } = options;
 	const results = [];
 	for (const row of keywords) {
-		const position = num(row.position);
-		const impressions = num(row.impressions);
-		const ctr = num(row.ctr);
-		const clicks = num(row.clicks);
+		const position = num$1(row.position);
+		const impressions = num$1(row.impressions);
+		const ctr = num$1(row.ctr);
+		const clicks = num$1(row.clicks);
 		if (position < minPosition || position > maxPosition) continue;
 		if (impressions < minImpressions) continue;
 		if (ctr > maxCtr) continue;
@@ -2732,31 +5224,14 @@ function analyzeStrikingDistance(keywords, options = {}) {
 	}
 	return sortResults(results, sortBy, sortOrder);
 }
-function typedQuery(state) {
-	return { state };
-}
-function isTypedQuery(value) {
-	return "state" in value;
-}
-async function queryRows(source, query) {
-	const state = isTypedQuery(query) ? query.state : query;
-	return await source.queryRows(state);
-}
-async function queryComparisonRows(source, current, previous) {
-	const [currentRows, previousRows] = await Promise.all([queryRows(source, current), queryRows(source, previous)]);
-	return {
-		current: currentRows,
-		previous: previousRows
-	};
-}
 function keywordQuery(period, limit) {
-	return typedQuery(keywordsQueryState(period, limit));
+	return typedQuery$1(keywordsQueryState(period, limit));
 }
 function pageQuery(period, limit) {
-	return typedQuery(pagesQueryState(period, limit));
+	return typedQuery$1(pagesQueryState(period, limit));
 }
 function dateQuery(period, limit) {
-	return typedQuery(datesQueryState(period, limit));
+	return typedQuery$1(datesQueryState(period, limit));
 }
 function definePortableAnalyzer(definition) {
 	return definition;
@@ -2764,7 +5239,7 @@ function definePortableAnalyzer(definition) {
 async function runPortableAnalyzer(source, definition, input, options, limit = 25e3) {
 	const requiredQueries = definition.requiredQueries(input, limit);
 	const entries = Object.entries(requiredQueries);
-	const resolvedRows = await Promise.all(entries.map(async ([key, spec]) => [key, await queryRows(source, spec)]));
+	const resolvedRows = await Promise.all(entries.map(async ([key, spec]) => [key, await queryRows$1(source, spec)]));
 	return definition.run(Object.fromEntries(resolvedRows), options);
 }
 const PORTABLE_ANALYZERS = {
@@ -2826,9 +5301,9 @@ const PORTABLE_ANALYZERS = {
 async function queryAnalyticsFromSource(source, period, options = {}) {
 	const limit = options.limit ?? 25e3;
 	const [keywords, pages, dates] = await Promise.all([
-		queryRows(source, keywordQuery(period, limit)),
-		queryRows(source, pageQuery(period, limit)),
-		queryRows(source, dateQuery(period, limit))
+		queryRows$1(source, keywordQuery(period, limit)),
+		queryRows$1(source, pageQuery(period, limit)),
+		queryRows$1(source, dateQuery(period, limit))
 	]);
 	return {
 		keywords,
@@ -2870,4 +5345,4 @@ async function analyzeDecayFromSource(source, periods, options) {
 async function analyzeMoversFromSource(source, periods, options) {
 	return runPortableAnalyzer(source, PORTABLE_ANALYZERS.movers, periods, options);
 }
-export { AnalyzerCapabilityError, ROW_ANALYZERS, analyzeActionPriority, analyzeActionPriorityFromSource, analyzeBrandSegmentation, analyzeBrandSegmentationFromSource, analyzeCannibalization, analyzeClustering, analyzeClusteringFromSource, analyzeConcentration, analyzeDecay, analyzeDecayFromSource, analyzeFromSource, analyzeKeywordConcentration, analyzeKeywordConcentrationFromSource, analyzeMovers, analyzeMoversFromSource, analyzeOpportunityFromSource, analyzePageConcentration, analyzePageConcentrationFromSource, analyzeSeasonality, analyzeSeasonalityFromSource, analyzeStrikingDistance, analyzeStrikingDistanceFromSource, comparisonOf, createAnalyzerRegistry, createBrowserQuerySource, createEngineQuerySource, createGscApiQuerySource, createInMemoryQuerySource, createSorter, createSqliteQuerySource, isSqlQuerySource, mergePriorityActions, normalizePriorityActions, normalizeQuery, num, padTimeseries, periodOf, queryAnalyticsFromSource, queryComparisonFromSource, queryComparisonRows, queryRows, resolveWindow, runAnalyzerFromSource, runAnalyzerWithEngine, scorePriorityActions, windowToComparisonPeriod, windowToPeriod };
+export { AnalyzerCapabilityError, ENGINE_QUERY_CAPABILITIES, IN_MEMORY_DEFAULT_CAPABILITIES, ROW_ANALYZERS, SQL_ANALYZERS, analyzeActionPriority, analyzeActionPriorityFromSource, analyzeBrandSegmentation, analyzeBrandSegmentationFromSource, analyzeCannibalization, analyzeClustering, analyzeClusteringFromSource, analyzeConcentration, analyzeDecay, analyzeDecayFromSource, analyzeFromSource, analyzeInBrowser, analyzeKeywordConcentration, analyzeKeywordConcentrationFromSource, analyzeMovers, analyzeMoversFromSource, analyzeOpportunityFromSource, analyzePageConcentration, analyzePageConcentrationFromSource, analyzeSeasonality, analyzeSeasonalityFromSource, analyzeStrikingDistance, analyzeStrikingDistanceFromSource, comparisonOf, createAnalyzerRegistry, createCompositeSource, createEngineQuerySource, createInMemoryQuerySource, createSorter, defaultAnalyzerRegistry, defineAnalyzer, isSqlQuerySource, mergePriorityActions, normalizePriorityActions, normalizeQuery, num, padTimeseries, periodOf, queryAnalyticsFromSource, queryComparisonFromSource, queryComparisonRows, queryRows, resolveWindow, rewriteForTableSource, runAnalyzerFromSource, runAnalyzerWithEngine, scorePriorityActions, typedQuery, windowToComparisonPeriod, windowToPeriod };