@gscdump/analysis 1.4.0 → 1.4.2

package/dist/report/reports/triage.mjs

@@ -0,0 +1,155 @@
+import { requireReportParam } from "../require.mjs";
+import { reportRows, sectionArtifact, sectionCoverage, truncation } from "../sections.mjs";
+import { resolveTarget } from "../resolve-target.mjs";
+import { defineReport } from "@gscdump/engine/report";
+const DEFAULT_MAX = 10;
+const triageReport = defineReport({
+	id: "triage",
+	description: "Focused investigation: change-points, query migration, and position volatility scoped to one page or query.",
+	defaultPeriod: "last-90d",
+	defaultComparison: "none",
+	argsSpec: {
+		"target": {
+			type: "string",
+			description: "Target page URL or query string",
+			required: true
+		},
+		"target-kind": {
+			type: "string",
+			description: "page | query",
+			default: "page"
+		},
+		"max-findings": {
+			type: "number",
+			description: "Cap findings per section",
+			default: DEFAULT_MAX
+		}
+	},
+	plan: (params, window) => {
+		requireReportParam("triage", "target", params.target, "triage report requires --target <page-or-query>");
+		const dates = {
+			startDate: window.start,
+			endDate: window.end
+		};
+		return [
+			{
+				key: "change-point",
+				type: "change-point",
+				params: {
+					...dates,
+					limit: 200
+				}
+			},
+			{
+				key: "query-migration",
+				type: "query-migration",
+				params: {
+					...dates,
+					limit: 200
+				}
+			},
+			{
+				key: "position-volatility",
+				type: "position-volatility",
+				params: {
+					...dates,
+					limit: 200
+				}
+			}
+		];
+	},
+	reduce: (results, ctx) => {
+		const target = ctx.params.target;
+		const kind = ctx.params.targetKind ?? "page";
+		const max = ctx.params.maxFindings ?? DEFAULT_MAX;
+		const needle = (resolveTarget({
+			kind,
+			input: target
+		}).exact ?? target).toLowerCase();
+		const matches = (val) => val.toLowerCase().includes(needle);
+		return { sections: [
+			buildChangePointSection(results["change-point"], kind, matches, max),
+			buildMigrationSection(results["query-migration"], kind, matches, max, target),
+			buildVolatilitySection(results["position-volatility"], kind, matches, max)
+		] };
+	}
+});
+function buildChangePointSection(res, kind, matches, max) {
+	const rows = reportRows(res).filter((r) => matches(kind === "page" ? r.page : r.keyword)).sort((a, b) => b.llr - a.llr);
+	const kept = rows.slice(0, max);
+	const findings = kept.map((r) => ({
+		entity: {
+			kind: kind === "page" ? "page" : "query",
+			value: kind === "page" ? r.page : r.keyword
+		},
+		metrics: {
+			llr: r.llr,
+			delta: r.delta
+		},
+		why: `${r.direction} on ${r.changeDate}`
+	}));
+	return {
+		id: "change-point",
+		title: "Change-points",
+		severity: kept.length ? "medium" : "info",
+		summary: { magnitudeLabel: `${kept.length} change-point${kept.length === 1 ? "" : "s"}` },
+		findings,
+		truncated: truncation(rows.length, kept.length),
+		coverage: sectionCoverage(res),
+		actions: [],
+		artifact: sectionArtifact(res, "change-point")
+	};
+}
+function buildMigrationSection(res, kind, matches, max, _rawTarget) {
+	const rows = reportRows(res).filter((r) => kind === "page" ? matches(r.sourcePage) || matches(r.targetPage) : false).sort((a, b) => b.weight - a.weight);
+	const kept = rows.slice(0, max);
+	const findings = kept.map((r) => ({
+		entity: {
+			kind: "page",
+			value: r.targetPage
+		},
+		metrics: {
+			weight: r.weight,
+			queryCount: r.queryCount
+		},
+		why: `from ${r.sourcePage}`
+	}));
+	return {
+		id: "query-migration",
+		title: "Query migration",
+		severity: "info",
+		summary: { magnitudeLabel: kind === "page" ? `${kept.length} migration edges touching target` : "N/A for query target" },
+		findings,
+		truncated: truncation(rows.length, kept.length),
+		coverage: sectionCoverage(res),
+		actions: [],
+		artifact: sectionArtifact(res, "query-migration")
+	};
+}
+function buildVolatilitySection(res, kind, matches, max) {
+	const rows = kind === "page" ? reportRows(res).filter((r) => matches(r.page)) : [];
+	const kept = rows.sort((a, b) => b.peakVolatility - a.peakVolatility).slice(0, max);
+	const findings = kept.map((r) => ({
+		entity: {
+			kind: "page",
+			value: r.page
+		},
+		metrics: {
+			avgVolatility: r.avgVolatility,
+			peakVolatility: r.peakVolatility,
+			impressions: r.totalImpressions
+		}
+	}));
+	return {
+		id: "position-volatility",
+		title: "Position volatility",
+		severity: kept.length ? "low" : "info",
+		summary: { magnitudeLabel: kind === "page" ? `${kept.length} volatile day${kept.length === 1 ? "" : "s"}` : "N/A for query target" },
+		findings,
+		truncated: truncation(rows.length, kept.length),
+		coverage: sectionCoverage(res),
+		actions: [],
+		artifact: sectionArtifact(res, "position-volatility")
+	};
+}
+export { triageReport };

package/dist/report/require.mjs

@@ -0,0 +1,15 @@
+import { analysisErrorToException, analysisErrors } from "../errors.mjs";
+import { err, ok, unwrapResult } from "gscdump/result";
+function requireReportParamResult(report, param, value, message) {
+	return value && value.trim() ? ok(value) : err(analysisErrors.missingReportParam(report, param, message));
+}
+function requireReportParam(report, param, value, message) {
+	return unwrapResult(requireReportParamResult(report, param, value, message), analysisErrorToException);
+}
+function requireComparisonWindowResult(report, window, message) {
+	return window.comparison ? ok(window.comparison) : err(analysisErrors.missingComparisonWindow(report, message));
+}
+function requireComparisonWindow(report, window, message) {
+	return unwrapResult(requireComparisonWindowResult(report, window, message), analysisErrorToException);
+}
+export { requireComparisonWindow, requireComparisonWindowResult, requireReportParam, requireReportParamResult };

package/dist/report/resolve-target.d.mts

@@ -0,0 +1,29 @@
+/**
+ * `resolveTarget()` — stub day-one resolver. Future versions can wire in
+ * fuzzy matching / embedding similarity / a manifest cache without
+ * changing the contract.
+ *
+ * Today: case-insensitive exact match, falling back to substring (LIKE %x%)
+ * over a caller-supplied candidate list.
+ */
+type ResolveTargetKind = 'page' | 'query';
+interface ResolveTargetInput {
+  kind: ResolveTargetKind;
+  input: string;
+  /**
+   * Pool to resolve against. Empty pool ⇒ caller trusts the input verbatim
+   * (resolver returns it as `exact`). Useful when the caller doesn't have
+   * a candidate list yet but knows the value is correct.
+   */
+  candidates?: readonly string[];
+}
+interface ResolveTargetResult {
+  /** Best exact match from `candidates` (case-insensitive), or trusted input when no candidates were supplied. */
+  exact: string | null;
+  /** All candidates that include the input as a substring (case-insensitive). Includes `exact` if matched. */
+  matches: string[];
+  /** True when no candidates matched at all. */
+  unresolved: boolean;
+}
+declare function resolveTarget(opts: ResolveTargetInput): ResolveTargetResult;
+export { ResolveTargetInput, ResolveTargetKind, ResolveTargetResult, resolveTarget };

package/dist/report/resolve-target.mjs

@@ -0,0 +1,32 @@
+function resolveTarget(opts) {
+	const needle = opts.input.trim();
+	if (!needle) return {
+		exact: null,
+		matches: [],
+		unresolved: true
+	};
+	const candidates = opts.candidates;
+	if (!candidates || candidates.length === 0) return {
+		exact: needle,
+		matches: [needle],
+		unresolved: false
+	};
+	const lower = needle.toLowerCase();
+	let exact = null;
+	const matches = [];
+	for (const c of candidates) {
+		const cl = c.toLowerCase();
+		if (cl === lower) {
+			exact = c;
+			if (!matches.includes(c)) matches.unshift(c);
+			continue;
+		}
+		if (cl.includes(lower)) matches.push(c);
+	}
+	return {
+		exact,
+		matches,
+		unresolved: matches.length === 0
+	};
+}
+export { resolveTarget };

package/dist/{_chunks/index.d.mts → report/runtime.d.mts}

@@ -1,43 +1,8 @@
-import { AnalysisError } from "./errors.mjs";
+import { AnalysisError } from "../errors.mjs";
 import { AnalyzerRegistry } from "@gscdump/engine/analyzer";
 import { Result } from "gscdump/result";
 import { AnalysisQuerySource } from "@gscdump/engine/source";
 import { DefinedReport, ReportContext, ReportParams, ReportResult } from "@gscdump/engine/report";
-interface FormatReportOptions {
-  /** Cap findings rendered per section. Defaults to all (already bounded by report). */
-  maxFindingsPerSection?: number;
-}
-declare function formatReport(report: ReportResult, opts?: FormatReportOptions): string;
-declare const REPORTS: readonly DefinedReport<ReportParams>[];
-declare const defaultReportRegistry: import("@gscdump/engine/report").ReportRegistry;
-/**
- * `resolveTarget()` — stub day-one resolver. Future versions can wire in
- * fuzzy matching / embedding similarity / a manifest cache without
- * changing the contract.
- *
- * Today: case-insensitive exact match, falling back to substring (LIKE %x%)
- * over a caller-supplied candidate list.
- */
-type ResolveTargetKind = 'page' | 'query';
-interface ResolveTargetInput {
-  kind: ResolveTargetKind;
-  input: string;
-  /**
-   * Pool to resolve against. Empty pool ⇒ caller trusts the input verbatim
-   * (resolver returns it as `exact`). Useful when the caller doesn't have
-   * a candidate list yet but knows the value is correct.
-   */
-  candidates?: readonly string[];
-}
-interface ResolveTargetResult {
-  /** Best exact match from `candidates` (case-insensitive), or trusted input when no candidates were supplied. */
-  exact: string | null;
-  /** All candidates that include the input as a substring (case-insensitive). Includes `exact` if matched. */
-  matches: string[];
-  /** True when no candidates matched at all. */
-  unresolved: boolean;
-}
-declare function resolveTarget(opts: ResolveTargetInput): ResolveTargetResult;
 interface RunReportOptions<P extends ReportParams = ReportParams> {
   source: AnalysisQuerySource;
   analyzers: AnalyzerRegistry;
@@ -86,4 +51,4 @@ interface DryRunReportResult {
  * Useful right now only as an "is this report wired up correctly?" check.
  */
 declare function dryRunReport<P extends ReportParams = ReportParams>(report: DefinedReport<P>, ctx: ReportContext<P>): Promise<DryRunReportResult>;
-export { DryRunReportResult, FormatReportOptions, REPORTS, ResolveTargetInput, ResolveTargetKind, ResolveTargetResult, RunReportOptions, defaultReportRegistry, dryRunReport, formatReport, resolveTarget, runReport, runReportResult };
+export { DryRunReportResult, RunReportOptions, dryRunReport, runReport, runReportResult };

package/dist/report/runtime.mjs

@@ -0,0 +1,80 @@
+import { analysisErrorToException, analysisErrors } from "../errors.mjs";
+import { runAnalyzerFromSource } from "@gscdump/engine/analyzer";
+import { err, ok, unwrapResult } from "gscdump/result";
+import { computeInputHash } from "@gscdump/engine/report";
+async function executeStep(source, analyzers, step) {
+	return runAnalyzerFromSource(source, {
+		...step.params,
+		type: step.type
+	}, analyzers).then((result) => ({
+		state: {
+			key: step.key,
+			type: step.type,
+			status: "done"
+		},
+		result
+	})).catch((thrown) => {
+		const message = thrown?.message ?? String(thrown);
+		return {
+			state: {
+				key: step.key,
+				type: step.type,
+				status: "error",
+				error: message
+			},
+			cause: thrown
+		};
+	});
+}
+async function runReportResult(report, opts) {
+	const startedAt = Date.now();
+	const generatedAt = new Date(startedAt).toISOString();
+	const inputHash = await computeInputHash({
+		id: report.id,
+		site: opts.ctx.site,
+		window: opts.ctx.window,
+		params: opts.ctx.params,
+		registryVersion: opts.ctx.registryVersion
+	});
+	const steps = report.plan(opts.ctx.params, opts.ctx.window);
+	const outcomes = await Promise.all(steps.map((s) => executeStep(opts.source, opts.analyzers, s)));
+	const required = new Map(steps.filter((s) => s.required).map((s) => [s.key, s]));
+	const errored = outcomes.filter((o) => o.state.status === "error");
+	for (const o of errored) if (required.has(o.state.key)) return err(analysisErrors.requiredStepFailed(report.id, o.state.key, o.state.error ?? "unknown error", o.cause));
+	const resultsByKey = {};
+	for (const o of outcomes) if (o.result) resultsByKey[o.state.key] = o.result;
+	const sections = report.reduce(resultsByKey, opts.ctx).sections;
+	const degraded = errored.length > 0;
+	const stepStates = outcomes.map((o) => o.state);
+	return ok({
+		id: report.id,
+		site: opts.ctx.site,
+		inputHash,
+		generatedAt,
+		window: opts.ctx.window,
+		sections,
+		meta: {
+			durationMs: Date.now() - startedAt,
+			rowsScanned: 0,
+			degraded,
+			steps: stepStates
+		}
+	});
+}
+async function runReport(report, opts) {
+	return unwrapResult(await runReportResult(report, opts), analysisErrorToException);
+}
+async function dryRunReport(report, ctx) {
+	return {
+		steps: report.plan(ctx.params, ctx.window).map((s) => ({
+			key: s.key,
+			type: s.type
+		})),
+		windowResolved: {
+			start: ctx.window.start,
+			end: ctx.window.end,
+			days: ctx.window.days
+		}
+	};
+}
+export { dryRunReport, runReport, runReportResult };

package/dist/report/sections.mjs

@@ -0,0 +1,22 @@
+function reportRows(result) {
+	return result?.results ?? [];
+}
+function sectionCoverage(result) {
+	return result ? "full" : "partial";
+}
+function sectionArtifact(result, analyzer, params = {}) {
+	return result ? {
+		analyzer,
+		params: {
+			type: analyzer,
+			...params
+		}
+	} : void 0;
+}
+function truncation(total, kept) {
+	return total > kept ? {
+		kept,
+		total
+	} : void 0;
+}
+export { reportRows, sectionArtifact, sectionCoverage, truncation };

package/dist/sitemap-health.d.mts

@@ -0,0 +1,34 @@
+interface SitemapHealthRow {
+  path: string;
+  errors: number;
+  warnings: number;
+}
+interface SitemapHealthInput extends SitemapHealthRow {
+  isPending?: boolean;
+  type?: string;
+  contents?: Array<{
+    submitted: number | string;
+  }>;
+}
+interface SitemapDelta {
+  path: string;
+  errorDelta: number;
+  warningDelta: number;
+  newErrors: number;
+  newWarnings: number;
+}
+interface SitemapHealthTotals {
+  totalSitemaps: number;
+  totalUrls: number;
+  totalErrors: number;
+  totalWarnings: number;
+  pendingCount: number;
+  indexSitemaps: number;
+}
+interface SitemapHealthDiff {
+  changed: boolean;
+  deltas: SitemapDelta[];
+  totals: SitemapHealthTotals;
+}
+declare function diffSitemapHealth(prev: readonly SitemapHealthRow[], curr: readonly SitemapHealthInput[]): SitemapHealthDiff;
+export { SitemapDelta, SitemapHealthDiff, SitemapHealthInput, SitemapHealthRow, SitemapHealthTotals, diffSitemapHealth };

package/dist/sitemap-health.mjs

@@ -0,0 +1,37 @@
+function urlCountOf(sitemap) {
+	return sitemap.contents?.reduce((sum, c) => sum + (Number(c.submitted) || 0), 0) || 0;
+}
+function diffSitemapHealth(prev, curr) {
+	const previousByPath = new Map(prev.map((r) => [r.path, r]));
+	const deltas = [];
+	let changed = false;
+	for (const sitemap of curr) {
+		const prior = previousByPath.get(sitemap.path);
+		const errorDelta = prior ? sitemap.errors - (prior.errors || 0) : 0;
+		const warningDelta = prior ? sitemap.warnings - (prior.warnings || 0) : 0;
+		if (errorDelta !== 0 || warningDelta !== 0) {
+			changed = true;
+			deltas.push({
+				path: sitemap.path,
+				errorDelta,
+				warningDelta,
+				newErrors: sitemap.errors,
+				newWarnings: sitemap.warnings
+			});
+		}
+	}
+	const totals = {
+		totalSitemaps: curr.length,
+		totalUrls: curr.reduce((sum, s) => sum + urlCountOf(s), 0),
+		totalErrors: curr.reduce((sum, s) => sum + s.errors, 0),
+		totalWarnings: curr.reduce((sum, s) => sum + s.warnings, 0),
+		pendingCount: curr.filter((s) => s.isPending).length,
+		indexSitemaps: curr.filter((s) => s.type === "sitemapIndex").length
+	};
+	return {
+		changed,
+		deltas,
+		totals
+	};
+}
+export { diffSitemapHealth };

package/dist/{_chunks/index2.d.mts → source/composite.d.mts}

@@ -1,6 +1,5 @@
 import { BuilderState } from "gscdump/query";
-import { AnalysisQuerySource, QueryRow } from "@gscdump/engine/source";
-import { PlannerCapabilities } from "gscdump/query/plan";
+import { AnalysisQuerySource } from "@gscdump/engine/source";
 interface SyncedRange {
   oldestDateSynced: string | null;
   newestDateSynced: string | null;
@@ -24,14 +23,4 @@ interface CompositeSourceOptions {
   site: SyncedRange;
 }
 declare function createCompositeSource(opts: CompositeSourceOptions): AnalysisQuerySource;
-/**
- * Permissive defaults: in-memory sources are usually test doubles, so they
- * advertise every capability unless the test explicitly narrows them.
- */
-declare const IN_MEMORY_DEFAULT_CAPABILITIES: PlannerCapabilities;
-interface InMemoryQuerySourceOptions {
-  queryRows: (state: BuilderState) => Promise<QueryRow[]> | QueryRow[];
-  capabilities?: PlannerCapabilities;
-}
-declare function createInMemoryQuerySource(options: InMemoryQuerySourceOptions): AnalysisQuerySource;
-export { CompositeSourceOptions, IN_MEMORY_DEFAULT_CAPABILITIES, InMemoryQuerySourceOptions, SyncedRange, createCompositeSource, createInMemoryQuerySource };
+export { CompositeSourceOptions, SyncedRange, createCompositeSource };

package/dist/{_chunks/source.mjs → source/composite.mjs}

@@ -41,20 +41,4 @@ function createCompositeSource(opts) {
 		executeSql: engineExecuteSql ? (sql, params, execOpts) => engineExecuteSql(sql, params, execOpts) : void 0
 	};
 }
-const IN_MEMORY_DEFAULT_CAPABILITIES = {
-	regex: true,
-	multiDataset: true,
-	comparisonJoin: true,
-	windowTotals: true
-};
-function createInMemoryQuerySource(options) {
-	return {
-		name: "memory",
-		kind: "in-memory",
-		capabilities: options.capabilities ?? IN_MEMORY_DEFAULT_CAPABILITIES,
-		async queryRows(state) {
-			return await options.queryRows(state);
-		}
-	};
-}
-export { IN_MEMORY_DEFAULT_CAPABILITIES, createCompositeSource, createInMemoryQuerySource };
+export { createCompositeSource, hasGapInCoveredSpans, shouldRouteToLive };

package/dist/source/in-memory.d.mts

@@ -0,0 +1,14 @@
+import { BuilderState } from "gscdump/query";
+import { AnalysisQuerySource, QueryRow } from "@gscdump/engine/source";
+import { PlannerCapabilities } from "gscdump/query/plan";
+/**
+ * Permissive defaults: in-memory sources are usually test doubles, so they
+ * advertise every capability unless the test explicitly narrows them.
+ */
+declare const IN_MEMORY_DEFAULT_CAPABILITIES: PlannerCapabilities;
+interface InMemoryQuerySourceOptions {
+  queryRows: (state: BuilderState) => Promise<QueryRow[]> | QueryRow[];
+  capabilities?: PlannerCapabilities;
+}
+declare function createInMemoryQuerySource(options: InMemoryQuerySourceOptions): AnalysisQuerySource;
+export { IN_MEMORY_DEFAULT_CAPABILITIES, InMemoryQuerySourceOptions, createInMemoryQuerySource };

package/dist/source/in-memory.mjs

@@ -0,0 +1,17 @@
+const IN_MEMORY_DEFAULT_CAPABILITIES = {
+	regex: true,
+	multiDataset: true,
+	comparisonJoin: true,
+	windowTotals: true
+};
+function createInMemoryQuerySource(options) {
+	return {
+		name: "memory",
+		kind: "in-memory",
+		capabilities: options.capabilities ?? IN_MEMORY_DEFAULT_CAPABILITIES,
+		async queryRows(state) {
+			return await options.queryRows(state);
+		}
+	};
+}
+export { IN_MEMORY_DEFAULT_CAPABILITIES, createInMemoryQuerySource };

package/dist/source/index.d.mts

@@ -1,2 +1,3 @@
-import { CompositeSourceOptions, IN_MEMORY_DEFAULT_CAPABILITIES, InMemoryQuerySourceOptions, SyncedRange, createCompositeSource, createInMemoryQuerySource } from "../_chunks/index2.mjs";
+import { CompositeSourceOptions, SyncedRange, createCompositeSource } from "./composite.mjs";
+import { IN_MEMORY_DEFAULT_CAPABILITIES, InMemoryQuerySourceOptions, createInMemoryQuerySource } from "./in-memory.mjs";
 export { type CompositeSourceOptions, IN_MEMORY_DEFAULT_CAPABILITIES, type InMemoryQuerySourceOptions, type SyncedRange, createCompositeSource, createInMemoryQuerySource };

package/dist/source/index.mjs

@@ -1,2 +1,3 @@
-import { IN_MEMORY_DEFAULT_CAPABILITIES, createCompositeSource, createInMemoryQuerySource } from "../_chunks/source.mjs";
+import { createCompositeSource } from "./composite.mjs";
+import { IN_MEMORY_DEFAULT_CAPABILITIES, createInMemoryQuerySource } from "./in-memory.mjs";
 export { IN_MEMORY_DEFAULT_CAPABILITIES, createCompositeSource, createInMemoryQuerySource };

package/dist/sql-analyzers.d.mts

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

package/dist/sql-analyzers.mjs

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

package/dist/types.d.mts

@@ -0,0 +1,34 @@
+/**
+ * Domain row shapes + analysis utilities. Analyzer-call contracts
+ * (`AnalysisParams`, `AnalysisResult`, `AnalysisTool`, `num`) live in
+ * `@gscdump/engine/analysis-types`.
+ */
+type SortOrder = 'asc' | 'desc';
+/** Base search metrics */
+interface BaseMetrics {
+  clicks: number;
+  impressions: number;
+  ctr: number;
+  position: number;
+}
+/** Keyword row from query */
+interface QueriesRow extends BaseMetrics {
+  query: string;
+  page?: string;
+}
+/** Page row from query */
+interface PageRow extends BaseMetrics {
+  page: string;
+}
+/** Row with both query and page dimensions, both required */
+interface QueryPageRow extends BaseMetrics {
+  query: string;
+  page: string;
+}
+/** Date row from query */
+interface DateRow extends BaseMetrics {
+  date: string;
+}
+/** Create a generic sorter for any metric type */
+declare function createSorter<T, M extends string>(getValue: (item: T, metric: M) => number, defaultMetric: M, defaultOrder?: SortOrder): (items: T[], sortBy?: M, sortOrder?: SortOrder) => T[];
+export { BaseMetrics, DateRow, PageRow, QueriesRow, QueryPageRow, SortOrder, createSorter };

package/dist/types.mjs

@@ -0,0 +1,21 @@
+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);
+	};
+}
+export { buildPeriodMap, createMetricSorter, createSorter };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gscdump/analysis",
   "type": "module",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "description": "GSC analyzers — striking-distance, opportunity, movers, decay, brand, clustering, concentration, seasonality. Pure row-based + DuckDB-native.",
   "author": {
     "name": "Harlan Wilton",
@@ -57,9 +57,9 @@
   },
   "dependencies": {
     "pluralize": "^8.0.0",
-    "@gscdump/engine-gsc-api": "^1.4.0",
-    "@gscdump/engine": "^1.4.0",
-    "gscdump": "^1.4.0"
+    "@gscdump/engine": "^1.4.2",
+    "@gscdump/engine-gsc-api": "^1.4.2",
+    "gscdump": "^1.4.2"
   },
   "devDependencies": {
     "vitest": "^4.1.10"

package/dist/_chunks/default-registry.d.mts

@@ -1,5 +0,0 @@
-import { Analyzer } from "@gscdump/engine/analyzer";
-declare const ROW_ANALYZERS: readonly Analyzer[];
-declare const SQL_ANALYZERS: readonly Analyzer[];
-declare const defaultAnalyzerRegistry: import("@gscdump/engine/analyzer").AnalyzerRegistry;
-export { ROW_ANALYZERS, SQL_ANALYZERS, defaultAnalyzerRegistry };