@gscdump/analysis 3.8.0 → 4.0.1

package/dist/analyzers/movers.mjs

@@ -1,12 +1,26 @@
 import { queriesQueryState } from "../analyzer/adapt-rows.mjs";
+import { paginateClause, paginateInMemory, resolveSort } from "../analyzer/paginate.mjs";
 import { parseJsonRows, rowString } from "../analyzer/row-values.mjs";
-import { buildPeriodMap } from "../types.mjs";
 import { percentDifference } from "../scoring.mjs";
-import { num } from "@gscdump/engine/analysis-types";
+import { fetchBudgetOf, num } from "@gscdump/engine/analysis-types";
 import { defineAnalyzer } from "@gscdump/engine/analyzer";
 import { comparisonOf } from "@gscdump/engine/period";
 import { enumeratePartitions } from "@gscdump/engine/planner";
 import { METRIC_EXPR } from "@gscdump/engine/sql-fragments";
+const MOVERS_SORT_METRICS = [
+	"clicks",
+	"impressions",
+	"clicksDelta",
+	"clicksDeltaPercent",
+	"impressionsDelta",
+	"impressionsDeltaPercent",
+	"positionDelta"
+];
+const DEFAULT_SORT = {
+	sortBy: "clicksDelta",
+	sortDir: "desc"
+};
+const DEFAULT_MOVERS_LIMIT = 2e3;
 function withCanonicalFields(r) {
 	return {
 		...r,
@@ -19,90 +33,112 @@ function withCanonicalFields(r) {
 		prevPosition: r.baselinePosition
 	};
 }
-function selectMoversDirection(rising, declining, stable, params) {
-	if (params.direction) {
-		const selected = params.direction === "rising" ? rising : declining;
-		const total = selected.length;
-		const offset = params.offset ?? 0;
-		const limit = params.limit ?? total;
-		return {
-			results: selected.slice(offset, offset + limit),
-			meta: {
-				total,
-				rising: rising.length,
-				declining: declining.length,
-				stable: stable.length
-			}
-		};
+function sortValue(row, sortBy) {
+	switch (sortBy) {
+		case "clicks": return row.recentClicks;
+		case "impressions": return row.recentImpressions;
+		case "clicksDelta": return Math.abs(row.clicksChange);
+		case "clicksDeltaPercent": return Math.abs(row.clicksChangePercent);
+		case "impressionsDelta": return Math.abs(row.impressionsChange);
+		case "impressionsDeltaPercent": return Math.abs(row.impressionsChangePercent);
+		case "positionDelta": return Math.abs(row.positionChange ?? 0);
 	}
-	const combined = [...rising, ...declining];
+}
+function moversComparator(sortBy, sortDir) {
+	const mult = sortDir === "asc" ? 1 : -1;
+	return (a, b) => (sortValue(a, sortBy) - sortValue(b, sortBy)) * mult || a.keyword.localeCompare(b.keyword) || (a.page ?? "").localeCompare(b.page ?? "");
+}
+const SQL_SORT_EXPR = {
+	clicks: "recentClicks",
+	impressions: "recentImpressions",
+	clicksDelta: "ABS(clicksChange)",
+	clicksDeltaPercent: "ABS(clicksChangePercent)",
+	impressionsDelta: "ABS(impressionsChange)",
+	impressionsDeltaPercent: "ABS(impressionsChangePercent)",
+	positionDelta: "ABS(COALESCE(positionChange, 0))"
+};
+function selectMoversDirection(result, params, compare) {
+	const tag = (direction) => (r) => withCanonicalFields({
+		...r,
+		direction
+	});
+	const selected = params.direction === "rising" ? result.rising.map(tag("rising")) : params.direction === "declining" ? result.declining.map(tag("declining")) : [...result.rising.map(tag("rising")), ...result.declining.map(tag("declining"))].sort(compare);
+	const paged = paginateInMemory(selected, {
+		limit: params.limit ?? DEFAULT_MOVERS_LIMIT,
+		offset: params.offset
+	});
 	return {
-		results: combined,
+		results: paged,
 		meta: {
-			total: combined.length,
-			rising: rising.length,
-			declining: declining.length,
-			stable: stable.length
+			total: selected.length,
+			returned: paged.length,
+			rising: result.rising.length,
+			declining: result.declining.length,
+			stable: result.stable.length
 		}
 	};
 }
+function pairKey(query, page) {
+	return `${query}\u0000${page ?? ""}`;
+}
+function periodMap(rows, factor) {
+	const out = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const page = row.page ?? null;
+		out.set(pairKey(row.query, page), {
+			query: row.query,
+			page,
+			clicks: num(row.clicks) / factor,
+			impressions: num(row.impressions) / factor,
+			position: num(row.position)
+		});
+	}
+	return out;
+}
 function analyzeMovers(input, options = {}) {
-	const { changeThreshold = .2, minImpressions = 50, sortBy = "clicksChange" } = options;
-	const normFactor = input.normalizationFactor ?? 1;
-	const baselineMap = buildPeriodMap(input.previous, (r) => r.query, (r) => ({
-		clicks: num(r.clicks) / normFactor,
-		impressions: num(r.impressions) / normFactor,
-		position: num(r.position),
-		page: r.page ?? null
-	}));
-	const pageMap = /* @__PURE__ */ new Map();
-	for (const row of input.current) if (!pageMap.has(row.query) && row.page) pageMap.set(row.query, row.page);
-	for (const row of input.previous) if (!pageMap.has(row.query) && row.page) pageMap.set(row.query, row.page);
+	const { changeThreshold = .2, minImpressions = 50, sortBy = DEFAULT_SORT.sortBy, sortDir = DEFAULT_SORT.sortDir } = options;
+	const current = periodMap(input.current, 1);
+	const previous = periodMap(input.previous, input.normalizationFactor ?? 1);
 	const rising = [];
 	const declining = [];
 	const stable = [];
-	for (const row of input.current) {
-		const impressions = num(row.impressions);
-		const clicks = num(row.clicks);
-		const position = num(row.position);
-		if (impressions < minImpressions) continue;
-		const baseline = baselineMap.get(row.query);
-		const baselineClicksRaw = baseline?.clicks ?? 0;
-		const baselineImpressionsRaw = baseline?.impressions ?? 0;
-		const baselinePosition = baseline?.position ?? null;
+	for (const key of /* @__PURE__ */ new Set([...current.keys(), ...previous.keys()])) {
+		const cur = current.get(key);
+		const prev = previous.get(key);
+		const identity = cur ?? prev;
+		const clicks = cur?.clicks ?? 0;
+		const impressions = cur?.impressions ?? 0;
+		const baselineClicksRaw = prev?.clicks ?? 0;
+		const baselineImpressionsRaw = prev?.impressions ?? 0;
+		if (Math.max(impressions, baselineImpressionsRaw) < minImpressions) continue;
+		const recentPosition = cur?.position ?? null;
+		const baselinePosition = prev?.position ?? null;
+		const baselineClicks = Math.round(baselineClicksRaw);
+		const baselineImpressions = Math.round(baselineImpressionsRaw);
 		const clicksChangePercent = percentDifference(clicks, baselineClicksRaw);
-		const impressionsChangePercent = percentDifference(impressions, baselineImpressionsRaw);
 		const data = {
-			keyword: row.query,
-			page: pageMap.get(row.query) ?? null,
+			keyword: identity.query,
+			page: identity.page,
 			recentClicks: clicks,
 			recentImpressions: impressions,
-			recentPosition: position,
-			baselineClicks: Math.round(baselineClicksRaw),
-			baselineImpressions: Math.round(baselineImpressionsRaw),
+			recentPosition,
+			baselineClicks,
+			baselineImpressions,
 			baselinePosition,
-			clicksChange: clicks - Math.round(baselineClicksRaw),
+			clicksChange: clicks - baselineClicks,
 			clicksChangePercent,
-			impressionsChangePercent,
-			positionChange: baselinePosition != null ? position - baselinePosition : null
+			impressionsChange: impressions - baselineImpressions,
+			impressionsChangePercent: percentDifference(impressions, baselineImpressionsRaw),
+			positionChange: recentPosition != null && baselinePosition != null ? recentPosition - baselinePosition : null
 		};
 		const absChange = Math.abs(clicksChangePercent / 100);
 		if (clicksChangePercent > 0 && absChange >= changeThreshold) rising.push(data);
 		else if (clicksChangePercent < 0 && absChange >= changeThreshold) declining.push(data);
 		else stable.push(data);
 	}
-	const sortFn = (a, b) => {
-		switch (sortBy) {
-			case "clicks": return b.recentClicks - a.recentClicks;
-			case "impressions": return b.recentImpressions - a.recentImpressions;
-			case "clicksChange": return Math.abs(b.clicksChangePercent) - Math.abs(a.clicksChangePercent);
-			case "impressionsChange": return Math.abs(b.impressionsChangePercent) - Math.abs(a.impressionsChangePercent);
-			case "positionChange": return Math.abs(b.positionChange ?? 0) - Math.abs(a.positionChange ?? 0);
-			default: return Math.abs(b.clicksChangePercent) - Math.abs(a.clicksChangePercent);
-		}
-	};
-	rising.sort(sortFn);
-	declining.sort(sortFn);
+	const compare = moversComparator(sortBy, sortDir);
+	rising.sort(compare);
+	declining.sort(compare);
 	stable.sort((a, b) => b.recentClicks - a.recentClicks);
 	return {
 		rising,
@@ -110,13 +146,18 @@ function analyzeMovers(input, options = {}) {
 		stable
 	};
 }
+function resolveMoversSort(params) {
+	return resolveSort(params, MOVERS_SORT_METRICS, DEFAULT_SORT);
+}
 const moversAnalyzer = defineAnalyzer({
 	id: "movers",
 	buildSql(params) {
 		const { current: cur, previous: prev } = comparisonOf(params);
 		const minImpressions = params.minImpressions ?? 50;
 		const changeThreshold = params.changeThreshold ?? .2;
-		const limit = params.direction ? 5e3 : params.limit ?? 2e3;
+		const { sortBy, sortDir } = resolveMoversSort(params);
+		const orderBy = `${SQL_SORT_EXPR[sortBy]} ${sortDir === "asc" ? "ASC" : "DESC"}, keyword ASC, page ASC`;
+		const directions = params.direction === "rising" ? `('rising')` : params.direction === "declining" ? `('declining')` : `('rising', 'declining')`;
 		return {
 			sql: `
       WITH cur AS (
@@ -139,6 +180,67 @@ const moversAnalyzer = defineAnalyzer({
         WHERE date >= ? AND date <= ?
         GROUP BY query, url
       ),
+      joined AS (
+        SELECT
+          COALESCE(c.query, p.query) AS keyword,
+          COALESCE(c.url, p.url) AS page,
+          COALESCE(c.clicks, 0.0) AS recentClicks,
+          COALESCE(c.impressions, 0.0) AS recentImpressions,
+          c.position AS recentPosition,
+          COALESCE(p.clicks, 0.0) AS baselineClicks,
+          COALESCE(p.impressions, 0.0) AS baselineImpressions,
+          p.position AS baselinePosition
+        FROM cur c
+        FULL OUTER JOIN prev p ON c.query = p.query AND c.url = p.url
+        WHERE GREATEST(COALESCE(c.impressions, 0.0), COALESCE(p.impressions, 0.0)) >= ?
+      ),
+      derived AS (
+        SELECT
+          *,
+          (recentClicks - baselineClicks) AS clicksChange,
+          CASE
+            WHEN baselineClicks = 0 THEN CASE WHEN recentClicks > 0 THEN 100.0 ELSE 0.0 END
+            ELSE (recentClicks - baselineClicks) * 100.0 / baselineClicks
+          END AS clicksChangePercent,
+          (recentImpressions - baselineImpressions) AS impressionsChange,
+          CASE
+            WHEN baselineImpressions = 0 THEN CASE WHEN recentImpressions > 0 THEN 100.0 ELSE 0.0 END
+            ELSE (recentImpressions - baselineImpressions) * 100.0 / baselineImpressions
+          END AS impressionsChangePercent,
+          CASE
+            WHEN recentPosition IS NOT NULL AND baselinePosition IS NOT NULL THEN (recentPosition - baselinePosition)
+            ELSE NULL
+          END AS positionChange
+        FROM joined
+      ),
+      classified AS (
+        SELECT
+          *,
+          CASE
+            WHEN clicksChangePercent > 0 AND ABS(clicksChangePercent) / 100.0 >= ? THEN 'rising'
+            WHEN clicksChangePercent < 0 AND ABS(clicksChangePercent) / 100.0 >= ? THEN 'declining'
+            ELSE 'stable'
+          END AS direction
+        FROM derived
+      ),
+      counted AS (
+        SELECT
+          *,
+          CAST(SUM(CASE WHEN direction = 'rising' THEN 1 ELSE 0 END) OVER () AS DOUBLE) AS risingCount,
+          CAST(SUM(CASE WHEN direction = 'declining' THEN 1 ELSE 0 END) OVER () AS DOUBLE) AS decliningCount,
+          CAST(SUM(CASE WHEN direction = 'stable' THEN 1 ELSE 0 END) OVER () AS DOUBLE) AS stableCount
+        FROM classified
+      ),
+      selected AS (
+        SELECT *
+        FROM counted
+        WHERE direction IN ${directions}
+        ORDER BY ${orderBy}
+        ${paginateClause({
+				limit: params.limit ?? DEFAULT_MOVERS_LIMIT,
+				offset: params.offset
+			})}
+      ),
       weekly AS (
         SELECT query, url, date_trunc('week', CAST(date AS DATE)) AS week,
           ${METRIC_EXPR.clicks} AS clicks,
@@ -151,7 +253,8 @@ const moversAnalyzer = defineAnalyzer({
           SELECT query, url, date, clicks, impressions
           FROM read_parquet({{FILES_PREV}}, union_by_name = true)
           WHERE date >= ? AND date <= ?
-        )
+        ) u
+        SEMI JOIN selected ON u.query = selected.keyword AND u.url = selected.page
         GROUP BY query, url, week
       ),
       series_by_entity AS (
@@ -161,55 +264,24 @@ const moversAnalyzer = defineAnalyzer({
           'impressions': impressions
         } ORDER BY week)) AS seriesJson
         FROM weekly GROUP BY query, url
-      ),
-      joined AS (
-        SELECT
-          c.query AS keyword,
-          c.url AS page,
-          c.clicks AS recentClicks,
-          c.impressions AS recentImpressions,
-          c.position AS recentPosition,
-          COALESCE(p.clicks, 0.0) AS baselineClicks,
-          COALESCE(p.impressions, 0.0) AS baselineImpressions,
-          p.position AS baselinePosition,
-          (c.clicks - COALESCE(p.clicks, 0.0)) AS clicksChange,
-          CASE
-            WHEN COALESCE(p.clicks, 0.0) = 0 THEN CASE WHEN c.clicks > 0 THEN 100.0 ELSE 0.0 END
-            ELSE (c.clicks - p.clicks) * 100.0 / p.clicks
-          END AS clicksChangePercent,
-          CASE
-            WHEN COALESCE(p.impressions, 0.0) = 0 THEN CASE WHEN c.impressions > 0 THEN 100.0 ELSE 0.0 END
-            ELSE (c.impressions - p.impressions) * 100.0 / p.impressions
-          END AS impressionsChangePercent,
-          CASE WHEN p.position IS NOT NULL THEN (c.position - p.position) ELSE NULL END AS positionChange,
-          s.seriesJson
-        FROM cur c
-        LEFT JOIN prev p ON c.query = p.query AND c.url = p.url
-        LEFT JOIN series_by_entity s ON c.query = s.query AND c.url = s.url
-        WHERE c.impressions >= ?
       )
-      SELECT *,
-        CASE
-          WHEN clicksChangePercent > 0 AND ABS(clicksChangePercent) / 100.0 >= ? THEN 'rising'
-          WHEN clicksChangePercent < 0 AND ABS(clicksChangePercent) / 100.0 >= ? THEN 'declining'
-          ELSE 'stable'
-        END AS direction
-      FROM joined
-      ORDER BY ABS(clicksChangePercent) DESC
-      LIMIT ${Number(limit)}
+      SELECT selected.*, s.seriesJson
+      FROM selected
+      LEFT JOIN series_by_entity s ON selected.keyword = s.query AND selected.page = s.url
+      ORDER BY ${orderBy}
     `,
 			params: [
 				cur.startDate,
 				cur.endDate,
 				prev.startDate,
 				prev.endDate,
+				minImpressions,
+				changeThreshold,
+				changeThreshold,
 				cur.startDate,
 				cur.endDate,
 				prev.startDate,
-				prev.endDate,
-				minImpressions,
-				changeThreshold,
-				changeThreshold
+				prev.endDate
 			],
 			current: {
 				table: "page_queries",
@@ -222,41 +294,48 @@ const moversAnalyzer = defineAnalyzer({
 		};
 	},
 	reduceSql(rows, params) {
-		const normalized = (Array.isArray(rows) ? rows : []).map((r) => {
-			const recentClicks = num(r.recentClicks);
-			const recentImpressions = num(r.recentImpressions);
-			const recentPosition = num(r.recentPosition);
-			const baselineClicks = Math.round(num(r.baselineClicks));
-			const baselineImpressions = Math.round(num(r.baselineImpressions));
-			const baselinePosition = r.baselinePosition == null ? null : num(r.baselinePosition);
-			return {
-				keyword: rowString(r.keyword),
-				page: r.page == null ? null : rowString(r.page),
-				recentClicks,
-				recentImpressions,
-				recentPosition,
-				baselineClicks,
-				baselineImpressions,
-				baselinePosition,
-				clicksChange: num(r.clicksChange),
-				clicksChangePercent: num(r.clicksChangePercent),
-				impressionsChangePercent: num(r.impressionsChangePercent),
-				positionChange: r.positionChange == null ? null : num(r.positionChange),
-				direction: rowString(r.direction),
-				series: parseJsonRows(r.seriesJson).map((s) => ({
-					week: rowString(s.week),
-					clicks: num(s.clicks),
-					impressions: num(s.impressions)
-				}))
-			};
-		}).map(withCanonicalFields);
-		return selectMoversDirection(normalized.filter((r) => r.direction === "rising"), normalized.filter((r) => r.direction === "declining"), normalized.filter((r) => r.direction === "stable"), params);
+		const arr = Array.isArray(rows) ? rows : [];
+		const results = arr.map((r) => withCanonicalFields({
+			keyword: rowString(r.keyword),
+			page: r.page == null ? null : rowString(r.page),
+			recentClicks: num(r.recentClicks),
+			recentImpressions: num(r.recentImpressions),
+			recentPosition: r.recentPosition == null ? null : num(r.recentPosition),
+			baselineClicks: Math.round(num(r.baselineClicks)),
+			baselineImpressions: Math.round(num(r.baselineImpressions)),
+			baselinePosition: r.baselinePosition == null ? null : num(r.baselinePosition),
+			clicksChange: num(r.clicksChange),
+			clicksChangePercent: num(r.clicksChangePercent),
+			impressionsChange: num(r.impressionsChange),
+			impressionsChangePercent: num(r.impressionsChangePercent),
+			positionChange: r.positionChange == null ? null : num(r.positionChange),
+			direction: rowString(r.direction),
+			series: parseJsonRows(r.seriesJson).map((s) => ({
+				week: rowString(s.week),
+				clicks: num(s.clicks),
+				impressions: num(s.impressions)
+			}))
+		}));
+		const first = arr[0];
+		const rising = num(first?.risingCount);
+		const declining = num(first?.decliningCount);
+		const stable = num(first?.stableCount);
+		return {
+			results,
+			meta: {
+				total: params.direction === "rising" ? rising : params.direction === "declining" ? declining : rising + declining,
+				returned: results.length,
+				rising,
+				declining,
+				stable
+			}
+		};
 	},
 	buildRows(params) {
 		const { current, previous } = comparisonOf(params);
 		return {
-			current: queriesQueryState(current, params.limit),
-			previous: queriesQueryState(previous, params.limit)
+			current: queriesQueryState(current, fetchBudgetOf(params)),
+			previous: queriesQueryState(previous, fetchBudgetOf(params))
 		};
 	},
 	reduceRows(rows, params) {
@@ -264,20 +343,18 @@ const moversAnalyzer = defineAnalyzer({
 			current: [],
 			previous: []
 		};
-		const result = analyzeMovers({
-			current: map.current ?? [],
-			previous: map.previous ?? []
+		const current = map.current ?? [];
+		const previous = map.previous ?? [];
+		const { sortBy, sortDir } = resolveMoversSort(params);
+		return selectMoversDirection(analyzeMovers({
+			current,
+			previous
 		}, {
 			changeThreshold: params.changeThreshold,
-			minImpressions: params.minImpressions
-		});
-		return selectMoversDirection(result.rising.map((r) => withCanonicalFields({
-			...r,
-			direction: "rising"
-		})), result.declining.map((r) => withCanonicalFields({
-			...r,
-			direction: "declining"
-		})), [], params);
+			minImpressions: params.minImpressions,
+			sortBy,
+			sortDir
+		}), params, moversComparator(sortBy, sortDir));
 	}
 });
-export { analyzeMovers, moversAnalyzer };
+export { MOVERS_SORT_METRICS, analyzeMovers, moversAnalyzer };

package/dist/analyzers/opportunity.mjs

@@ -1,6 +1,6 @@
 import { queriesQueryState } from "../analyzer/adapt-rows.mjs";
-import { paginateClause, paginateSortedInMemory } from "../analyzer/paginate.mjs";
-import { num } from "@gscdump/engine/analysis-types";
+import { TOTAL_COUNT_SELECT, paginateClause, paginateSortedInMemory, totalCountOf } from "../analyzer/paginate.mjs";
+import { fetchBudgetOf, num } from "@gscdump/engine/analysis-types";
 import { defineAnalyzer } from "@gscdump/engine/analyzer";
 import { periodOf } from "@gscdump/engine/period";
 import { enumeratePartitions } from "@gscdump/engine/planner";
@@ -151,7 +151,8 @@ const opportunityAnalyzer = defineAnalyzer({
           ELSE 0.10
         END
       )) AS DOUBLE) AS potentialClicks,
-      positionScore, impressionScore, ctrGapScore
+      positionScore, impressionScore, ctrGapScore,
+      ${TOTAL_COUNT_SELECT}
     FROM gapped
     ORDER BY opportunityScore DESC
     ${paginateClause({
@@ -188,11 +189,14 @@ const opportunityAnalyzer = defineAnalyzer({
 					ctrGapScore: num(r.ctrGapScore)
 				}
 			})),
-			meta: { total: arr.length }
+			meta: {
+				total: totalCountOf(arr),
+				returned: arr.length
+			}
 		};
 	},
 	buildRows(params) {
-		return { queries: queriesQueryState(periodOf(params), params.limit) };
+		return { queries: queriesQueryState(periodOf(params), fetchBudgetOf(params)) };
 	},
 	reduceRows(rows, params) {
 		const results = analyzeOpportunity((Array.isArray(rows) ? rows : []) ?? [], { minImpressions: params.minImpressions });

package/dist/analyzers/seasonality.mjs

@@ -1,6 +1,6 @@
 import { datesQueryState } from "../analyzer/adapt-rows.mjs";
 import { rowBoolean, rowString } from "../analyzer/row-values.mjs";
-import { num } from "@gscdump/engine/analysis-types";
+import { fetchBudgetOf, num } from "@gscdump/engine/analysis-types";
 import { defineAnalyzer } from "@gscdump/engine/analyzer";
 import { periodOf } from "@gscdump/engine/period";
 import { enumeratePartitions } from "@gscdump/engine/planner";
@@ -123,13 +123,16 @@ const seasonalityAnalyzer = defineAnalyzer({
 		};
 	},
 	buildRows(params) {
-		return { dates: datesQueryState(periodOf(params), params.limit) };
+		return { dates: datesQueryState(periodOf(params), fetchBudgetOf(params)) };
 	},
 	reduceRows(rows, params) {
 		const result = analyzeSeasonality(Array.isArray(rows) ? rows : [], { metric: params.metric });
 		return {
 			results: result.monthlyBreakdown,
-			meta: { strength: result.strength }
+			meta: {
+				total: result.monthlyBreakdown.length,
+				strength: result.strength
+			}
 		};
 	}
 });

package/dist/analyzers/striking-distance.mjs

@@ -1,10 +1,9 @@
 import { queriesQueryState } from "../analyzer/adapt-rows.mjs";
 import { paginateSortedInMemory } from "../analyzer/paginate.mjs";
-import { num } from "@gscdump/engine/analysis-types";
+import { fetchBudgetOf, num } from "@gscdump/engine/analysis-types";
 import { defineAnalyzer } from "@gscdump/engine/analyzer";
 import { periodOf } from "@gscdump/engine/period";
 import { enumeratePartitions } from "@gscdump/engine/planner";
-const DEFAULT_ROW_LIMIT = 25e3;
 function paginateStrikingDistance(results, options) {
 	return paginateSortedInMemory(results, {
 		limit: options.limit ?? 1e3,
@@ -76,7 +75,7 @@ const strikingDistanceAnalyzer = defineAnalyzer({
 		};
 	},
 	buildRows(params) {
-		return { queries: queriesQueryState(periodOf(params), params.limit ?? DEFAULT_ROW_LIMIT) };
+		return { queries: queriesQueryState(periodOf(params), fetchBudgetOf(params)) };
 	}
 });
 export { analyzeStrikingDistance, filterStrikingDistance, strikingDistanceAnalyzer };

package/dist/analyzers/zero-click.mjs

@@ -1,11 +1,10 @@
-import { paginateClause, paginateSortedInMemory } from "../analyzer/paginate.mjs";
-import { num } from "@gscdump/engine/analysis-types";
+import { queriesQueryState } from "../analyzer/adapt-rows.mjs";
+import { TOTAL_COUNT_SELECT, paginateClause, paginateSortedInMemory, totalCountOf } from "../analyzer/paginate.mjs";
+import { fetchBudgetOf, num } from "@gscdump/engine/analysis-types";
 import { defineAnalyzer } from "@gscdump/engine/analyzer";
 import { periodOf } from "@gscdump/engine/period";
 import { enumeratePartitions } from "@gscdump/engine/planner";
 import { METRIC_EXPR } from "@gscdump/engine/sql-fragments";
-import { between, date, gsc, page, query } from "gscdump/query";
-const DEFAULT_ROW_LIMIT = 25e3;
 function analyzeZeroClick(rows, options = {}) {
 	const minImpressions = options.minImpressions ?? 1e3;
 	const maxCtr = options.maxCtr ?? .03;
@@ -50,7 +49,8 @@ const zeroClickAnalyzer = defineAnalyzer({
             WHEN position <= 5 THEN 0.08
             ELSE 0.04
           END
-        )) - clicks) AS DOUBLE) AS missedClicks
+        )) - clicks) AS DOUBLE) AS missedClicks,
+        ${TOTAL_COUNT_SELECT}
       FROM agg
       WHERE position <= ? AND ctr < ?
       ORDER BY impressions DESC
@@ -88,7 +88,8 @@ const zeroClickAnalyzer = defineAnalyzer({
 				missedClicks: num(r.missedClicks)
 			})),
 			meta: {
-				total: arr.length,
+				total: totalCountOf(arr),
+				returned: arr.length,
 				minImpressions,
 				maxCtr,
 				maxPosition
@@ -96,9 +97,7 @@ const zeroClickAnalyzer = defineAnalyzer({
 		};
 	},
 	buildRows(params) {
-		const period = periodOf(params);
-		const limit = params.limit ?? DEFAULT_ROW_LIMIT;
-		return { rows: gsc.select(query, page).where(between(date, period.startDate, period.endDate)).limit(limit).getState() };
+		return { rows: queriesQueryState(periodOf(params), fetchBudgetOf(params)) };
 	},
 	reduceRows(rows, params) {
 		const results = analyzeZeroClick(Array.isArray(rows) ? rows : [], {

package/dist/index.d.mts

@@ -4,7 +4,7 @@ import { CannibalizationCompetitor, CannibalizationEvent, CannibalizationOptions
 import { ClusterType, ClusteringOptions, ClusteringResult, KeywordCluster, analyzeClustering } from "./analyzers/clustering.mjs";
 import { ConcentrationInput, ConcentrationItem, ConcentrationOptions, ConcentrationResult, ConcentrationRiskLevel, analyzeConcentration, analyzeKeywordConcentration, analyzePageConcentration } from "./analyzers/concentration.mjs";
 import { DecayInput, DecayOptions, DecayResult, DecaySeriesPoint, DecaySortMetric, analyzeDecay } from "./analyzers/decay.mjs";
-import { MoverData, MoversInput, MoversOptions, MoversResult, MoversSortMetric, analyzeMovers } from "./analyzers/movers.mjs";
+import { MOVERS_SORT_METRICS, MoverData, MoversInput, MoversOptions, MoversResult, MoversSortMetric, analyzeMovers } from "./analyzers/movers.mjs";
 import { OpportunityFactors, OpportunityOptions, OpportunityResult, OpportunitySortMetric, OpportunityWeights, analyzeOpportunity } from "./analyzers/opportunity.mjs";
 import { MonthlyData, SeasonalityMetric, SeasonalityOptions, SeasonalityResult, analyzeSeasonality } from "./analyzers/seasonality.mjs";
 import { StrikingDistanceInputRow, StrikingDistanceOptions, StrikingDistanceResult, analyzeStrikingDistance } from "./analyzers/striking-distance.mjs";
@@ -18,4 +18,4 @@ import { Analyzer, AnalyzerCapabilityError, AnalyzerRegistry, AnalyzerRegistryIn
 import { AnalysisPeriod, ComparisonMode, ComparisonPeriod, PadTimeseriesOptions, ResolveWindowOptions, ResolvedWindow, WindowPreset, comparisonOf, padTimeseries, periodOf, resolveWindow } from "@gscdump/engine/period";
 import { AnalysisQuerySource, AnalysisSourceKind, ENGINE_QUERY_CAPABILITIES, EngineQuerySourceOptions, ExecuteSqlOptions, FileSet, QueryRow, SourceCapabilities, createEngineQuerySource, queryRows, runAnalyzerWithEngine } from "@gscdump/engine/source";
 import { DefineReportOptions, DefinedReport, ReportContext, ReportFinding, ReportPlanStep, ReportResult, ReportSection } from "@gscdump/engine/report";
-export { type AnalysisParams, type AnalysisPeriod, type AnalysisQuerySource, type AnalysisResult, type AnalysisSourceKind, type AnalysisTool, type Analyzer, AnalyzerCapabilityError, type AnalyzerRegistry, type AnalyzerRegistryInit, type AnalyzerRunner, type AnalyzerVariants, type BaseMetrics, type BrandSegmentationOptions, type BrandSegmentationResult, type BrandSegmentationRow, type BrandSummary, type BrowserAnalyzeOptions, type CannibalizationCompetitor, type CannibalizationEvent, type CannibalizationOptions, type CannibalizationPage, type CannibalizationResult, type CannibalizationSortMetric, type ClusterType, type ClusteringOptions, type ClusteringResult, type ComparisonMode, type ComparisonPeriod, type ConcentrationInput, type ConcentrationItem, type ConcentrationOptions, type ConcentrationResult, type ConcentrationRiskLevel, type CurrentSitemapScope, type DateRow, type DecayInput, type DecayOptions, type DecayResult, type DecaySeriesPoint, type DecaySortMetric, type DefineAnalyzerOptions, type DefineReportOptions, type DefinedAnalyzer, type DefinedReport, ENGINE_QUERY_CAPABILITIES, type EngineQuerySourceOptions, type ExecuteSqlOptions, type FileSet, INTENT_CLASSIFIER_VERSION, type IntentClassification, type KeywordCluster, type MonthlyData, type MoverData, type MoversInput, type MoversOptions, type MoversResult, type MoversSortMetric, NORMALIZER_VERSION, type OpportunityFactors, type OpportunityOptions, type OpportunityResult, type OpportunitySortMetric, type OpportunityWeights, type PadTimeseriesOptions, type PageRow, type Plan, type QueriesRow, type QueryPageRow, type QueryRow, type ReduceContext, type ReduceCtx, type Reducer, type ReportContext, type ReportFinding, type ReportPlanStep, type ReportResult, type ReportSection, type RequiredCapability, type ResolveWindowOptions, type ResolvedWindow, type RowQueriesPlan, SEARCH_INTENT_CODE, SITEMAP_SYNC_COLLAPSE_POLICY, SITEMAP_TRUST_COLLAPSE_POLICY, type SearchIntent, type SeasonalityMetric, type SeasonalityOptions, type SeasonalityResult, type SitemapCollapsePolicy, type SitemapCollapseState, type SitemapDelta, type SitemapHealthDiff, type SitemapHealthInput, type SitemapHealthRow, type SitemapHealthTotals, type SortOrder, type SourceCapabilities, type SqlExtraQuery, type SqlPlan, type SqlPlanSpec, type StrikingDistanceInputRow, type StrikingDistanceOptions, type StrikingDistanceResult, type TypedRowQuery, type WindowPreset, type ZeroClickOptions, type ZeroClickResult, analyzeBrandSegmentation, analyzeCannibalization, analyzeClustering, analyzeConcentration, analyzeDecay, analyzeInBrowser, analyzeKeywordConcentration, analyzeMovers, analyzeOpportunity, analyzePageConcentration, analyzeSeasonality, analyzeStrikingDistance, analyzeZeroClick, classifyQueryIntent, classifySitemapCollapse, compareCurrentSitemapScope, comparisonOf, createAnalyzerRegistry, createEngineQuerySource, createSorter, defineAnalyzer, diffSitemapHealth, encodeIntent, normalizeQuery, num, padTimeseries, periodOf, queryRows, resolveWindow, runAnalyzerFromSource, runAnalyzerWithEngine, sitemapHistoryHasCollapse };
+export { type AnalysisParams, type AnalysisPeriod, type AnalysisQuerySource, type AnalysisResult, type AnalysisSourceKind, type AnalysisTool, type Analyzer, AnalyzerCapabilityError, type AnalyzerRegistry, type AnalyzerRegistryInit, type AnalyzerRunner, type AnalyzerVariants, type BaseMetrics, type BrandSegmentationOptions, type BrandSegmentationResult, type BrandSegmentationRow, type BrandSummary, type BrowserAnalyzeOptions, type CannibalizationCompetitor, type CannibalizationEvent, type CannibalizationOptions, type CannibalizationPage, type CannibalizationResult, type CannibalizationSortMetric, type ClusterType, type ClusteringOptions, type ClusteringResult, type ComparisonMode, type ComparisonPeriod, type ConcentrationInput, type ConcentrationItem, type ConcentrationOptions, type ConcentrationResult, type ConcentrationRiskLevel, type CurrentSitemapScope, type DateRow, type DecayInput, type DecayOptions, type DecayResult, type DecaySeriesPoint, type DecaySortMetric, type DefineAnalyzerOptions, type DefineReportOptions, type DefinedAnalyzer, type DefinedReport, ENGINE_QUERY_CAPABILITIES, type EngineQuerySourceOptions, type ExecuteSqlOptions, type FileSet, INTENT_CLASSIFIER_VERSION, type IntentClassification, type KeywordCluster, MOVERS_SORT_METRICS, type MonthlyData, type MoverData, type MoversInput, type MoversOptions, type MoversResult, type MoversSortMetric, NORMALIZER_VERSION, type OpportunityFactors, type OpportunityOptions, type OpportunityResult, type OpportunitySortMetric, type OpportunityWeights, type PadTimeseriesOptions, type PageRow, type Plan, type QueriesRow, type QueryPageRow, type QueryRow, type ReduceContext, type ReduceCtx, type Reducer, type ReportContext, type ReportFinding, type ReportPlanStep, type ReportResult, type ReportSection, type RequiredCapability, type ResolveWindowOptions, type ResolvedWindow, type RowQueriesPlan, SEARCH_INTENT_CODE, SITEMAP_SYNC_COLLAPSE_POLICY, SITEMAP_TRUST_COLLAPSE_POLICY, type SearchIntent, type SeasonalityMetric, type SeasonalityOptions, type SeasonalityResult, type SitemapCollapsePolicy, type SitemapCollapseState, type SitemapDelta, type SitemapHealthDiff, type SitemapHealthInput, type SitemapHealthRow, type SitemapHealthTotals, type SortOrder, type SourceCapabilities, type SqlExtraQuery, type SqlPlan, type SqlPlanSpec, type StrikingDistanceInputRow, type StrikingDistanceOptions, type StrikingDistanceResult, type TypedRowQuery, type WindowPreset, type ZeroClickOptions, type ZeroClickResult, analyzeBrandSegmentation, analyzeCannibalization, analyzeClustering, analyzeConcentration, analyzeDecay, analyzeInBrowser, analyzeKeywordConcentration, analyzeMovers, analyzeOpportunity, analyzePageConcentration, analyzeSeasonality, analyzeStrikingDistance, analyzeZeroClick, classifyQueryIntent, classifySitemapCollapse, compareCurrentSitemapScope, comparisonOf, createAnalyzerRegistry, createEngineQuerySource, createSorter, defineAnalyzer, diffSitemapHealth, encodeIntent, normalizeQuery, num, padTimeseries, periodOf, queryRows, resolveWindow, runAnalyzerFromSource, runAnalyzerWithEngine, sitemapHistoryHasCollapse };

package/dist/index.mjs

@@ -4,7 +4,7 @@ import { analyzeCannibalization } from "./analyzers/cannibalization.mjs";
 import { analyzeClustering } from "./analyzers/clustering.mjs";
 import { analyzeConcentration, analyzeKeywordConcentration, analyzePageConcentration } from "./analyzers/concentration.mjs";
 import { analyzeDecay } from "./analyzers/decay.mjs";
-import { analyzeMovers } from "./analyzers/movers.mjs";
+import { MOVERS_SORT_METRICS, analyzeMovers } from "./analyzers/movers.mjs";
 import { analyzeOpportunity } from "./analyzers/opportunity.mjs";
 import { analyzeSeasonality } from "./analyzers/seasonality.mjs";
 import { analyzeStrikingDistance } from "./analyzers/striking-distance.mjs";
@@ -17,4 +17,4 @@ import { num } from "@gscdump/engine/analysis-types";
 import { AnalyzerCapabilityError, createAnalyzerRegistry, defineAnalyzer, runAnalyzerFromSource } from "@gscdump/engine/analyzer";
 import { comparisonOf, padTimeseries, periodOf, resolveWindow } from "@gscdump/engine/period";
 import { ENGINE_QUERY_CAPABILITIES, createEngineQuerySource, queryRows, runAnalyzerWithEngine } from "@gscdump/engine/source";
-export { AnalyzerCapabilityError, ENGINE_QUERY_CAPABILITIES, INTENT_CLASSIFIER_VERSION, NORMALIZER_VERSION, SEARCH_INTENT_CODE, SITEMAP_SYNC_COLLAPSE_POLICY, SITEMAP_TRUST_COLLAPSE_POLICY, analyzeBrandSegmentation, analyzeCannibalization, analyzeClustering, analyzeConcentration, analyzeDecay, analyzeInBrowser, analyzeKeywordConcentration, analyzeMovers, analyzeOpportunity, analyzePageConcentration, analyzeSeasonality, analyzeStrikingDistance, analyzeZeroClick, classifyQueryIntent, classifySitemapCollapse, compareCurrentSitemapScope, comparisonOf, createAnalyzerRegistry, createEngineQuerySource, createSorter, defineAnalyzer, diffSitemapHealth, encodeIntent, normalizeQuery, num, padTimeseries, periodOf, queryRows, resolveWindow, runAnalyzerFromSource, runAnalyzerWithEngine, sitemapHistoryHasCollapse };
+export { AnalyzerCapabilityError, ENGINE_QUERY_CAPABILITIES, INTENT_CLASSIFIER_VERSION, MOVERS_SORT_METRICS, NORMALIZER_VERSION, SEARCH_INTENT_CODE, SITEMAP_SYNC_COLLAPSE_POLICY, SITEMAP_TRUST_COLLAPSE_POLICY, analyzeBrandSegmentation, analyzeCannibalization, analyzeClustering, analyzeConcentration, analyzeDecay, analyzeInBrowser, analyzeKeywordConcentration, analyzeMovers, analyzeOpportunity, analyzePageConcentration, analyzeSeasonality, analyzeStrikingDistance, analyzeZeroClick, classifyQueryIntent, classifySitemapCollapse, compareCurrentSitemapScope, comparisonOf, createAnalyzerRegistry, createEngineQuerySource, createSorter, defineAnalyzer, diffSitemapHealth, encodeIntent, normalizeQuery, num, padTimeseries, periodOf, queryRows, resolveWindow, runAnalyzerFromSource, runAnalyzerWithEngine, sitemapHistoryHasCollapse };