@gscdump/analysis 1.4.0 → 1.4.1

package/dist/action-priority.d.mts

@@ -0,0 +1,34 @@
+import { AnalysisResult } from "@gscdump/engine/analysis-types";
+type ActionSource = 'cannibalization' | 'striking-distance' | 'ctr-anomaly' | 'change-point' | 'opportunity';
+type Effort = 'low' | 'medium' | 'high';
+interface PriorityAction {
+  id: string;
+  title: string;
+  keyword: string;
+  page: string;
+  sources: ActionSource[];
+  severity: number;
+  impressions: number;
+  impact: number;
+  why: string;
+  effort: Effort;
+  priorityScore: number;
+  data: Partial<Record<ActionSource, Record<string, unknown>>>;
+}
+type ActionPrioritySourceStatus = 'pending' | 'running' | 'done' | 'skipped' | 'error';
+interface ActionPrioritySourceState {
+  source: ActionSource;
+  status: ActionPrioritySourceStatus;
+  count: number;
+  error?: string;
+}
+interface ActionPriorityResult {
+  actions: PriorityAction[];
+  totalSignals: number;
+  sources: ActionPrioritySourceState[];
+}
+declare const DEFAULT_PRIORITY_SOURCES: ActionSource[];
+declare function normalizePriorityActions(source: ActionSource, result: AnalysisResult): PriorityAction[];
+declare function mergePriorityActions(all: PriorityAction[]): PriorityAction[];
+declare function scorePriorityActions(actions: PriorityAction[]): PriorityAction[];
+export { ActionPriorityResult, ActionPrioritySourceState, ActionPrioritySourceStatus, ActionSource, DEFAULT_PRIORITY_SOURCES, Effort, PriorityAction, mergePriorityActions, normalizePriorityActions, scorePriorityActions };

package/dist/action-priority.mjs

@@ -0,0 +1,201 @@
+import { clamp, clamp01 } from "./scoring.mjs";
+const DEFAULT_PRIORITY_SOURCES = [
+	"striking-distance",
+	"opportunity",
+	"cannibalization",
+	"ctr-anomaly",
+	"change-point"
+];
+const EFFORT_BY_SOURCE = {
+	"striking-distance": "low",
+	"opportunity": "low",
+	"cannibalization": "medium",
+	"ctr-anomaly": "high",
+	"change-point": "high"
+};
+const EFFORT_MULTIPLIER = {
+	low: 1.3,
+	medium: 1,
+	high: .7
+};
+const EFFORT_RANK = {
+	low: 0,
+	medium: 1,
+	high: 2
+};
+function idKey(keyword, page) {
+	return `${keyword.toLowerCase()}|${page.toLowerCase()}`;
+}
+function truncate(s, n) {
+	return s.length <= n ? s : `${s.slice(0, n - 1)}...`;
+}
+function buildAction(spec) {
+	return {
+		id: idKey(spec.keyword, spec.page),
+		title: spec.title,
+		keyword: spec.keyword,
+		page: spec.page,
+		sources: [spec.source],
+		severity: spec.severity,
+		impressions: spec.impressions,
+		impact: spec.impact,
+		effort: EFFORT_BY_SOURCE[spec.source],
+		why: spec.why,
+		priorityScore: 0,
+		data: { [spec.source]: spec.data }
+	};
+}
+function fromStrikingDistance(rows) {
+	const out = [];
+	for (const r of rows) {
+		if (r.page == null) continue;
+		const impact = Math.max(0, r.potentialClicks);
+		if (impact <= 0) continue;
+		const posScore = clamp01((20 - r.position) / 16);
+		const imprScore = Math.min(1, r.impressions / 5e3);
+		out.push(buildAction({
+			source: "striking-distance",
+			keyword: r.keyword,
+			page: r.page,
+			title: `Push "${truncate(r.keyword, 40)}" onto page 1`,
+			why: `Ranks #${r.position.toFixed(1)} with ${Math.round(r.impressions)} impressions; small gains unlock page-1 clicks.`,
+			severity: Math.round(100 * Math.sqrt(posScore * imprScore)),
+			impressions: r.impressions,
+			impact,
+			data: r
+		}));
+	}
+	return out;
+}
+function fromOpportunity(rows) {
+	const out = [];
+	for (const r of rows) {
+		if (r.page == null) continue;
+		const impact = Math.max(0, r.potentialClicks);
+		if (impact <= 0) continue;
+		out.push(buildAction({
+			source: "opportunity",
+			keyword: r.keyword,
+			page: r.page,
+			title: `Improve on-page for "${truncate(r.keyword, 40)}"`,
+			why: `Opportunity score ${Math.round(r.opportunityScore)}; CTR ${(r.ctr * 100).toFixed(1)}% vs expected at pos ${r.position.toFixed(1)}.`,
+			severity: Math.round(r.opportunityScore),
+			impressions: r.impressions,
+			impact,
+			data: r
+		}));
+	}
+	return out;
+}
+function fromCannibalization(events) {
+	const out = [];
+	for (const ev of events) {
+		if (ev.severity < 30) continue;
+		out.push(buildAction({
+			source: "cannibalization",
+			keyword: ev.keyword,
+			page: ev.leaderUrl,
+			title: `Consolidate cannibalization on "${truncate(ev.keyword, 36)}"`,
+			why: `${ev.competitorCount} URLs split ${Math.round(ev.totalImpressions)} impressions; leader loses ~${Math.round(ev.stolenClicks)} clicks to siblings.`,
+			severity: Math.round(ev.severity),
+			impressions: ev.totalImpressions,
+			impact: Math.max(0, ev.stolenClicks),
+			data: ev
+		}));
+	}
+	return out;
+}
+function fromCtrAnomaly(rows) {
+	const out = [];
+	let maxRaw = 0;
+	for (const r of rows) if (r.severity > maxRaw) maxRaw = r.severity;
+	for (const r of rows) {
+		const impact = Math.max(0, r.clicksLost);
+		if (impact <= 0) continue;
+		out.push(buildAction({
+			source: "ctr-anomaly",
+			keyword: r.keyword,
+			page: r.page,
+			title: `Lift CTR on "${truncate(r.keyword, 36)}"`,
+			why: `CTR collapsed ${r.breachDaysDown} days at flat position; ~${Math.round(r.clicksLost)} clicks lost vs baseline ${(r.baselineCtr * 100).toFixed(1)}%.`,
+			severity: maxRaw > 0 ? Math.round(r.severity / maxRaw * 100) : 0,
+			impressions: r.totalImpressions,
+			impact,
+			data: r
+		}));
+	}
+	return out;
+}
+function fromChangePoint(rows) {
+	const out = [];
+	for (const r of rows) {
+		if (r.direction !== "worsened") continue;
+		const days = Math.max(1, r.totalDays / 2);
+		const impact = Math.abs(r.leftMean - r.rightMean) * days;
+		if (impact <= 0) continue;
+		out.push(buildAction({
+			source: "change-point",
+			keyword: r.keyword,
+			page: r.page,
+			title: `Diagnose drop on "${truncate(r.keyword, 34)}"`,
+			why: `Significant regression around ${r.changeDate} (${r.leftMean.toFixed(1)} -> ${r.rightMean.toFixed(1)}, LLR ${r.llr.toFixed(0)}).`,
+			severity: clamp(Math.round(Math.log10(Math.max(10, r.llr)) / 3 * 100), 0, 100),
+			impressions: r.totalImpressions,
+			impact,
+			data: r
+		}));
+	}
+	return out;
+}
+function normalizePriorityActions(source, result) {
+	const rows = result.results;
+	if (source === "striking-distance") return fromStrikingDistance(rows);
+	if (source === "opportunity") return fromOpportunity(rows);
+	if (source === "cannibalization") return fromCannibalization(rows);
+	if (source === "ctr-anomaly") return fromCtrAnomaly(rows);
+	return fromChangePoint(rows);
+}
+function mergePriorityActions(all) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const a of all) {
+		const existing = byId.get(a.id);
+		if (existing == null) {
+			byId.set(a.id, {
+				...a,
+				sources: [...a.sources],
+				data: { ...a.data }
+			});
+			continue;
+		}
+		const mergedSources = [.../* @__PURE__ */ new Set([...existing.sources, ...a.sources])];
+		const preferNew = a.severity > existing.severity;
+		const mergedEffort = EFFORT_RANK[a.effort] < EFFORT_RANK[existing.effort] ? a.effort : existing.effort;
+		byId.set(a.id, {
+			id: existing.id,
+			title: preferNew ? a.title : existing.title,
+			keyword: existing.keyword,
+			page: existing.page,
+			sources: mergedSources,
+			severity: Math.max(existing.severity, a.severity),
+			impressions: Math.max(existing.impressions, a.impressions),
+			impact: existing.impact + a.impact,
+			why: preferNew ? a.why : existing.why,
+			effort: mergedEffort,
+			priorityScore: 0,
+			data: {
+				...existing.data,
+				...a.data
+			}
+		});
+	}
+	return [...byId.values()];
+}
+function scorePriorityActions(actions) {
+	for (const a of actions) {
+		const mult = EFFORT_MULTIPLIER[a.effort];
+		a.priorityScore = a.impact * (1 + a.severity / 100) * mult;
+	}
+	actions.sort((a, b) => b.priorityScore - a.priorityScore);
+	return actions;
+}
+export { DEFAULT_PRIORITY_SOURCES, mergePriorityActions, normalizePriorityActions, scorePriorityActions };

package/dist/analyzer/adapt-rows.mjs

@@ -0,0 +1,12 @@
+import { between, date, gsc, page, query } from "gscdump/query";
+const DEFAULT_LIMIT = 25e3;
+function queriesQueryState(period, limit = DEFAULT_LIMIT) {
+	return gsc.select(query, page).where(between(date, period.startDate, period.endDate)).limit(limit).getState();
+}
+function pagesQueryState(period, limit = DEFAULT_LIMIT) {
+	return gsc.select(page).where(between(date, period.startDate, period.endDate)).limit(limit).getState();
+}
+function datesQueryState(period, limit = DEFAULT_LIMIT) {
+	return gsc.select(date).where(between(date, period.startDate, period.endDate)).limit(limit).getState();
+}
+export { datesQueryState, pagesQueryState, queriesQueryState };

package/dist/analyzer/all.mjs

@@ -0,0 +1,61 @@
+import { bayesianCtrAnalyzer } from "../analyzers/bayesian-ctr.mjs";
+import { bipartitePagerankAnalyzer } from "../analyzers/bipartite-pagerank.mjs";
+import { brandAnalyzer } from "../analyzers/brand.mjs";
+import { cannibalizationAnalyzer } from "../analyzers/cannibalization.mjs";
+import { changePointAnalyzer } from "../analyzers/change-point.mjs";
+import { clusteringAnalyzer } from "../analyzers/clustering.mjs";
+import { concentrationAnalyzer } from "../analyzers/concentration.mjs";
+import { contentVelocityAnalyzer } from "../analyzers/content-velocity.mjs";
+import { ctrAnomalyAnalyzer } from "../analyzers/ctr-anomaly.mjs";
+import { ctrCurveAnalyzer } from "../analyzers/ctr-curve.mjs";
+import { darkTrafficAnalyzer } from "../analyzers/dark-traffic.mjs";
+import { dataDetailAnalyzer } from "../analyzers/data-detail.mjs";
+import { dataQueryAnalyzer } from "../analyzers/data-query.mjs";
+import { decayAnalyzer } from "../analyzers/decay.mjs";
+import { deviceGapAnalyzer } from "../analyzers/device-gap.mjs";
+import { intentAtlasAnalyzer } from "../analyzers/intent-atlas.mjs";
+import { keywordBreadthAnalyzer } from "../analyzers/keyword-breadth.mjs";
+import { longTailAnalyzer } from "../analyzers/long-tail.mjs";
+import { moversAnalyzer } from "../analyzers/movers.mjs";
+import { opportunityAnalyzer } from "../analyzers/opportunity.mjs";
+import { positionDistributionAnalyzer } from "../analyzers/position-distribution.mjs";
+import { positionVolatilityAnalyzer } from "../analyzers/position-volatility.mjs";
+import { queryMigrationAnalyzer } from "../analyzers/query-migration.mjs";
+import { seasonalityAnalyzer } from "../analyzers/seasonality.mjs";
+import { stlDecomposeAnalyzer } from "../analyzers/stl-decompose.mjs";
+import { strikingDistanceAnalyzer } from "../analyzers/striking-distance.mjs";
+import { survivalAnalyzer } from "../analyzers/survival.mjs";
+import { trendsAnalyzer } from "../analyzers/trends.mjs";
+import { zeroClickAnalyzer } from "../analyzers/zero-click.mjs";
+const ALL_ANALYZERS = [
+	bayesianCtrAnalyzer,
+	bipartitePagerankAnalyzer,
+	brandAnalyzer,
+	cannibalizationAnalyzer,
+	changePointAnalyzer,
+	clusteringAnalyzer,
+	concentrationAnalyzer,
+	contentVelocityAnalyzer,
+	ctrAnomalyAnalyzer,
+	ctrCurveAnalyzer,
+	darkTrafficAnalyzer,
+	dataDetailAnalyzer,
+	dataQueryAnalyzer,
+	decayAnalyzer,
+	deviceGapAnalyzer,
+	intentAtlasAnalyzer,
+	keywordBreadthAnalyzer,
+	longTailAnalyzer,
+	moversAnalyzer,
+	opportunityAnalyzer,
+	positionDistributionAnalyzer,
+	positionVolatilityAnalyzer,
+	queryMigrationAnalyzer,
+	seasonalityAnalyzer,
+	stlDecomposeAnalyzer,
+	strikingDistanceAnalyzer,
+	survivalAnalyzer,
+	trendsAnalyzer,
+	zeroClickAnalyzer
+];
+export { ALL_ANALYZERS };

package/dist/analyzer/paginate.mjs

@@ -0,0 +1,85 @@
+const DEFAULT_LIMIT = 1e3;
+const MAX_LIMIT = 5e4;
+function clampLimit(limit, fallback = DEFAULT_LIMIT) {
+	const n = Number(limit ?? fallback);
+	if (!Number.isFinite(n) || n <= 0) return fallback;
+	return Math.min(n, MAX_LIMIT);
+}
+function clampOffset(offset) {
+	const n = Number(offset ?? 0);
+	if (!Number.isFinite(n) || n < 0) return 0;
+	return Math.floor(n);
+}
+function paginateClause(input) {
+	const l = clampLimit(input.limit);
+	const o = clampOffset(input.offset);
+	return o > 0 ? `LIMIT ${l} OFFSET ${o}` : `LIMIT ${l}`;
+}
+function paginateInMemory(rows, input) {
+	const l = clampLimit(input.limit, rows.length);
+	const o = clampOffset(input.offset);
+	return rows.slice(o, o + l);
+}
+function paginateSortedInMemory(rows, input, compare) {
+	const limit = clampLimit(input.limit, rows.length);
+	const offset = clampOffset(input.offset);
+	const selectedCount = Math.min(rows.length, offset + limit);
+	if (limit === 0 || offset >= rows.length || selectedCount === 0) return [];
+	const fullSort = () => [...rows].sort(compare).slice(offset, offset + limit);
+	if (selectedCount >= rows.length / 2) return fullSort();
+	let invalidComparison = false;
+	const compareStable = (left, right) => {
+		const order = compare(left.value, right.value);
+		if (Number.isNaN(order)) {
+			invalidComparison = true;
+			return left.index - right.index;
+		}
+		return order || left.index - right.index;
+	};
+	const isWorse = (left, right) => compareStable(left, right) > 0;
+	const heap = [];
+	const siftUp = (start) => {
+		let index = start;
+		while (index > 0) {
+			const parent = index - 1 >>> 1;
+			if (!isWorse(heap[index], heap[parent])) break;
+			const swap = heap[parent];
+			heap[parent] = heap[index];
+			heap[index] = swap;
+			index = parent;
+		}
+	};
+	const siftDown = () => {
+		let index = 0;
+		for (;;) {
+			const left = index * 2 + 1;
+			if (left >= heap.length) return;
+			const right = left + 1;
+			let worse = left;
+			if (right < heap.length && isWorse(heap[right], heap[left])) worse = right;
+			if (!isWorse(heap[worse], heap[index])) return;
+			const swap = heap[index];
+			heap[index] = heap[worse];
+			heap[worse] = swap;
+			index = worse;
+		}
+	};
+	for (let index = 0; index < rows.length; index++) {
+		const candidate = {
+			value: rows[index],
+			index
+		};
+		if (heap.length < selectedCount) {
+			heap.push(candidate);
+			siftUp(heap.length - 1);
+		} else if (compareStable(candidate, heap[0]) < 0) {
+			heap[0] = candidate;
+			siftDown();
+		}
+	}
+	if (invalidComparison) return fullSort();
+	heap.sort(compareStable);
+	if (invalidComparison) return fullSort();
+	return heap.slice(offset, offset + limit).map((entry) => entry.value);
+}
+export { clampLimit, clampOffset, paginateClause, paginateInMemory, paginateSortedInMemory };

package/dist/analyzer/row-analyzers.d.mts

@@ -0,0 +1,3 @@
+import { Analyzer } from "@gscdump/engine/analyzer";
+declare const ROW_ANALYZERS: readonly Analyzer[];
+export { ROW_ANALYZERS };

package/dist/analyzer/row-analyzers.mjs

@@ -0,0 +1,3 @@
+import { ALL_ANALYZERS } from "./all.mjs";
+const ROW_ANALYZERS = ALL_ANALYZERS.flatMap((d) => d.rows ? [d.rows] : []);
+export { ROW_ANALYZERS };

package/dist/analyzer/row-values.mjs

@@ -0,0 +1,22 @@
+function rowNumber(value) {
+	if (typeof value === "number") return Number.isFinite(value) ? value : 0;
+	if (typeof value === "bigint") return Number(value);
+	if (value == null) return 0;
+	const n = Number(value);
+	return Number.isFinite(n) ? n : 0;
+}
+function rowString(value) {
+	return value == null ? "" : String(value);
+}
+function rowBoolean(value) {
+	return value === true || value === 1 || value === "true";
+}
+function parseJsonRows(value) {
+	if (Array.isArray(value)) return value;
+	if (typeof value === "string" && value.length > 0) {
+		const parsed = JSON.parse(value);
+		return Array.isArray(parsed) ? parsed : [];
+	}
+	return [];
+}
+export { parseJsonRows, rowBoolean, rowNumber, rowString };

package/dist/analyzers/bayesian-ctr.mjs

@@ -0,0 +1,177 @@
+import { rowNumber, rowString } from "../analyzer/row-values.mjs";
+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";
+const bayesianCtrAnalyzer = defineAnalyzer({
+	id: "bayesian-ctr",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf(params);
+		const minImpressions = params.minImpressions ?? 50;
+		const limit = params.limit ?? 300;
+		const priorMinEntities = 5;
+		return {
+			sql: `
+    WITH entity AS (
+      SELECT
+        query,
+        url,
+        ${METRIC_EXPR.clicks} AS clicks,
+        ${METRIC_EXPR.impressions} AS impressions,
+        ${METRIC_EXPR.ctr} AS observed_ctr,
+        ${METRIC_EXPR.position} AS position,
+        CAST(ROUND(LEAST(${METRIC_EXPR.position}, 30)) AS INTEGER) AS bucket
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ?
+        AND query IS NOT NULL AND query <> ''
+        AND url IS NOT NULL AND url <> ''
+      GROUP BY query, url
+      HAVING SUM(impressions) >= ?
+        AND ${METRIC_EXPR.position} <= 30
+    ),
+    bucket_mu AS (
+      SELECT
+        bucket,
+        COUNT(*) AS n_entities,
+        SUM(observed_ctr * impressions) / NULLIF(SUM(impressions), 0) AS mu,
+        SUM(impressions) AS total_impressions
+      FROM entity
+      GROUP BY bucket
+    ),
+    bucket_var AS (
+      SELECT
+        e.bucket,
+        GREATEST(
+          SUM(e.impressions * POWER(e.observed_ctr - b.mu, 2))
+            / NULLIF(SUM(e.impressions), 0),
+          1e-9
+        ) AS v
+      FROM entity e
+      JOIN bucket_mu b USING (bucket)
+      GROUP BY e.bucket
+    ),
+    priors AS (
+      SELECT
+        m.bucket,
+        m.n_entities,
+        m.mu,
+        v.v,
+        CASE
+          WHEN m.n_entities >= ${Number(priorMinEntities)}
+            AND v.v > 0
+            AND m.mu > 0 AND m.mu < 1
+            AND (m.mu * (1.0 - m.mu) / v.v - 1.0) > 0
+          THEN GREATEST(0.5, m.mu * (m.mu * (1.0 - m.mu) / v.v - 1.0))
+          ELSE 2.0
+        END AS alpha,
+        CASE
+          WHEN m.n_entities >= ${Number(priorMinEntities)}
+            AND v.v > 0
+            AND m.mu > 0 AND m.mu < 1
+            AND (m.mu * (1.0 - m.mu) / v.v - 1.0) > 0
+          THEN GREATEST(0.5, (1.0 - m.mu) * (m.mu * (1.0 - m.mu) / v.v - 1.0))
+          ELSE 48.0
+        END AS beta
+      FROM bucket_mu m
+      JOIN bucket_var v USING (bucket)
+    ),
+    posterior AS (
+      SELECT
+        e.query,
+        e.url,
+        e.clicks,
+        e.impressions,
+        e.observed_ctr,
+        e.position,
+        e.bucket,
+        p.alpha AS prior_alpha,
+        p.beta AS prior_beta,
+        p.mu AS bucket_prior_mean,
+        p.alpha + e.clicks AS alpha_post,
+        p.beta + (e.impressions - e.clicks) AS beta_post
+      FROM entity e
+      JOIN priors p USING (bucket)
+    ),
+    scored AS (
+      SELECT *,
+        alpha_post / (alpha_post + beta_post) AS posterior_mean,
+        SQRT((alpha_post * beta_post)
+          / (POWER(alpha_post + beta_post, 2) * (alpha_post + beta_post + 1))) AS posterior_sd
+      FROM posterior
+    )
+    SELECT
+      query AS keyword,
+      url AS page,
+      clicks,
+      impressions,
+      observed_ctr AS observedCtr,
+      position,
+      bucket,
+      prior_alpha AS priorAlpha,
+      prior_beta AS priorBeta,
+      bucket_prior_mean AS bucketPriorMean,
+      posterior_mean AS posteriorMean,
+      posterior_sd AS posteriorSd,
+      GREATEST(0.0, posterior_mean - 1.96 * posterior_sd) AS ciLow,
+      LEAST(1.0, posterior_mean + 1.96 * posterior_sd) AS ciHigh,
+      posterior_mean - observed_ctr AS shrinkageDelta,
+      (posterior_mean - observed_ctr) * impressions AS expectedClicksDelta,
+      ABS(observed_ctr - posterior_mean) / NULLIF(posterior_sd, 0) AS significance,
+      CASE
+        WHEN observed_ctr > LEAST(1.0, posterior_mean + 1.96 * posterior_sd) THEN 'overperforming'
+        WHEN observed_ctr < GREATEST(0.0, posterior_mean - 1.96 * posterior_sd) THEN 'underperforming'
+        ELSE 'expected'
+      END AS classification
+    FROM scored
+    ORDER BY significance DESC NULLS LAST
+    LIMIT ${Number(limit)}
+  `,
+			params: [
+				startDate,
+				endDate,
+				minImpressions
+			],
+			current: {
+				table: "page_queries",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const minImpressions = params.minImpressions ?? 50;
+		const results = arr.map((r) => ({
+			keyword: rowString(r.keyword),
+			page: rowString(r.page),
+			clicks: rowNumber(r.clicks),
+			impressions: rowNumber(r.impressions),
+			observedCtr: rowNumber(r.observedCtr),
+			position: rowNumber(r.position),
+			bucket: rowNumber(r.bucket),
+			priorAlpha: rowNumber(r.priorAlpha),
+			priorBeta: rowNumber(r.priorBeta),
+			bucketPriorMean: rowNumber(r.bucketPriorMean),
+			posteriorMean: rowNumber(r.posteriorMean),
+			posteriorSd: rowNumber(r.posteriorSd),
+			ciLow: rowNumber(r.ciLow),
+			ciHigh: rowNumber(r.ciHigh),
+			shrinkageDelta: rowNumber(r.shrinkageDelta),
+			expectedClicksDelta: rowNumber(r.expectedClicksDelta),
+			significance: rowNumber(r.significance),
+			classification: rowString(r.classification)
+		}));
+		const under = results.filter((r) => r.classification === "underperforming").length;
+		const over = results.filter((r) => r.classification === "overperforming").length;
+		return {
+			results,
+			meta: {
+				total: results.length,
+				underperforming: under,
+				overperforming: over,
+				expected: results.length - under - over,
+				minImpressions
+			}
+		};
+	}
+});
+export { bayesianCtrAnalyzer };