@gscdump/analysis 1.4.0 → 1.4.1

package/dist/errors.d.mts

@@ -1,2 +1,52 @@
-import { AnalysisError, AnalysisErrorKind, analysisErrorToException, analysisErrors, formatAnalysisError, isAnalysisError } from "./_chunks/errors.mjs";
+type AnalysisErrorKind = 'missing-report-param' | 'missing-comparison-window' | 'missing-brand-terms' | 'unknown-report' | 'unknown-analyzer' | 'required-step-failed';
+type AnalysisError = {
+  kind: 'missing-report-param';
+  report: string;
+  param: string;
+  message: string;
+} | {
+  kind: 'missing-comparison-window';
+  report: string;
+  message: string;
+} | {
+  kind: 'missing-brand-terms';
+  message: string;
+} | {
+  kind: 'unknown-report';
+  report: string;
+  available: readonly string[];
+  message: string;
+} | {
+  kind: 'unknown-analyzer';
+  analyzer: string;
+  message: string;
+} | {
+  kind: 'required-step-failed';
+  report: string;
+  stepKey: string;
+  stepError: string;
+  message: string;
+  cause?: unknown;
+};
+declare const analysisErrors: {
+  readonly missingReportParam: (report: string, param: string, message: string) => AnalysisError;
+  readonly missingComparisonWindow: (report: string, message: string) => AnalysisError;
+  readonly missingBrandTerms: () => AnalysisError;
+  readonly unknownReport: (report: string, available: readonly string[]) => AnalysisError;
+  readonly unknownAnalyzer: (analyzer: string) => AnalysisError;
+  readonly requiredStepFailed: (report: string, stepKey: string, stepError: string, cause?: unknown) => AnalysisError;
+};
+declare function isAnalysisError(value: unknown): value is AnalysisError;
+/** The human-readable rendering of an `AnalysisError`, for logs and string sinks. */
+declare function formatAnalysisError(error: AnalysisError): string;
+/**
+ * Re-raises an `AnalysisError` value as a generic `Error`, stashing the union
+ * under `.analysisError` for stack-walking and preserving the original `cause`
+ * (so a `required-step-failed` keeps the underlying thrown value reachable).
+ * Used by the throwing wrappers over the `Result`-returning cores. The thrown
+ * `.message` is kept verbatim from the union, so existing message-regex
+ * assertions (`/--target/`, `/comparison window/`, `/required step "k"/`)
+ * continue to match.
+ */
+declare function analysisErrorToException(error: AnalysisError): Error;
 export { AnalysisError, AnalysisErrorKind, analysisErrorToException, analysisErrors, formatAnalysisError, isAnalysisError };

package/dist/index.d.mts

@@ -1,497 +1,33 @@
-import { ROW_ANALYZERS, SQL_ANALYZERS, defaultAnalyzerRegistry } from "./_chunks/default-registry.mjs";
-import { AnalysisError, AnalysisErrorKind, analysisErrorToException, analysisErrors, formatAnalysisError, isAnalysisError } from "./_chunks/errors.mjs";
-import { DryRunReportResult, FormatReportOptions, REPORTS, RunReportOptions, defaultReportRegistry, dryRunReport, formatReport, runReport, runReportResult } from "./_chunks/index.mjs";
-import { CompositeSourceOptions, IN_MEMORY_DEFAULT_CAPABILITIES, InMemoryQuerySourceOptions, createCompositeSource, createInMemoryQuerySource } from "./_chunks/index2.mjs";
-import { Analyzer, AnalyzerCapabilityError, AnalyzerRegistry, AnalyzerRegistry as AnalyzerRegistry$1, AnalyzerRegistryInit, AnalyzerVariants, DefineAnalyzerOptions, DefinedAnalyzer, Plan, ReduceContext, ReduceCtx, Reducer, RequiredCapability, RowQueriesPlan, SqlExtraQuery, SqlPlan, SqlPlanSpec, TypedRowQuery, createAnalyzerRegistry, defineAnalyzer, runAnalyzerFromSource } from "@gscdump/engine/analyzer";
+import { ROW_ANALYZERS } from "./analyzer/row-analyzers.mjs";
+import { SQL_ANALYZERS } from "./sql-analyzers.mjs";
+import { defaultAnalyzerRegistry } from "./default-registry.mjs";
+import { AnalysisError, AnalysisErrorKind, analysisErrorToException, analysisErrors, formatAnalysisError, isAnalysisError } from "./errors.mjs";
+import { ActionPriorityResult, ActionPrioritySourceState, ActionPrioritySourceStatus, ActionSource, DEFAULT_PRIORITY_SOURCES, Effort, PriorityAction, mergePriorityActions, normalizePriorityActions, scorePriorityActions } from "./action-priority.mjs";
+import { BaseMetrics, DateRow, PageRow, QueriesRow, QueryPageRow, SortOrder, createSorter } from "./types.mjs";
+import { BrandSegmentationOptions, BrandSegmentationResult, BrandSegmentationRow, BrandSummary, analyzeBrandSegmentation } from "./analyzers/brand.mjs";
+import { CannibalizationCompetitor, CannibalizationEvent, CannibalizationOptions, CannibalizationPage, CannibalizationResult, CannibalizationSortMetric, analyzeCannibalization } from "./analyzers/cannibalization.mjs";
+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 { 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";
+import { ZeroClickOptions, ZeroClickResult, analyzeZeroClick } from "./analyzers/zero-click.mjs";
+import { AnalyzerRunner, BrowserAnalyzeOptions, analyzeInBrowser } from "./browser.mjs";
+import { INTENT_CLASSIFIER_VERSION, IntentClassification, SEARCH_INTENT_CODE, SearchIntent, classifyQueryIntent, encodeIntent } from "./query/intent.mjs";
+import { NORMALIZER_VERSION, normalizeQuery } from "./query/normalize.mjs";
+import { FormatReportOptions, formatReport } from "./report/format.mjs";
+import { REPORTS, defaultReportRegistry } from "./report/registry.mjs";
+import { DryRunReportResult, RunReportOptions, dryRunReport, runReport, runReportResult } from "./report/runtime.mjs";
+import "./report/index.mjs";
+import { SitemapDelta, SitemapHealthDiff, SitemapHealthInput, SitemapHealthRow, SitemapHealthTotals, diffSitemapHealth } from "./sitemap-health.mjs";
+import { CompositeSourceOptions, createCompositeSource } from "./source/composite.mjs";
+import { IN_MEMORY_DEFAULT_CAPABILITIES, InMemoryQuerySourceOptions, createInMemoryQuerySource } from "./source/in-memory.mjs";
+import "./source/index.mjs";
+import { Analyzer, AnalyzerCapabilityError, AnalyzerRegistry, AnalyzerRegistryInit, AnalyzerVariants, DefineAnalyzerOptions, DefinedAnalyzer, Plan, ReduceContext, ReduceCtx, Reducer, RequiredCapability, RowQueriesPlan, SqlExtraQuery, SqlPlan, SqlPlanSpec, TypedRowQuery, createAnalyzerRegistry, defineAnalyzer, runAnalyzerFromSource } from "@gscdump/engine/analyzer";
 import { AnalysisPeriod, ComparisonMode, ComparisonPeriod, PadTimeseriesOptions, ResolveWindowOptions, ResolvedWindow, WindowPreset, comparisonOf, padTimeseries, periodOf, resolveWindow } from "@gscdump/engine/period";
-import { AnalysisParams, AnalysisParams as AnalysisParams$1, AnalysisResult, AnalysisResult as AnalysisResult$1, AnalysisTool, num } from "@gscdump/engine/analysis-types";
-import { AnalysisQuerySource, AnalysisSourceKind, AttachedTableRunner, AttachedTableRunner as AnalyzerRunner, AttachedTableSourceOptions, AttachedTableSourceOptions as BrowserAnalyzeOptions, ENGINE_QUERY_CAPABILITIES, EngineQuerySourceOptions, ExecuteSqlOptions, FileSet, QueryRow, SourceCapabilities, createEngineQuerySource, queryRows, runAnalyzerWithEngine } from "@gscdump/engine/source";
+import { AnalysisParams, AnalysisResult, AnalysisTool, num } from "@gscdump/engine/analysis-types";
+import { AnalysisQuerySource, AnalysisSourceKind, ENGINE_QUERY_CAPABILITIES, EngineQuerySourceOptions, ExecuteSqlOptions, FileSet, QueryRow, SourceCapabilities, createEngineQuerySource, queryRows, runAnalyzerWithEngine } from "@gscdump/engine/source";
 import { DefineReportOptions, DefinedReport, ReportAction, ReportContext, ReportFinding, ReportPlanStep, ReportResult, ReportSection } from "@gscdump/engine/report";
-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$1): PriorityAction[];
-declare function mergePriorityActions(all: PriorityAction[]): PriorityAction[];
-declare function scorePriorityActions(actions: PriorityAction[]): PriorityAction[];
-/**
- * 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[];
-interface BrandSegmentationOptions {
-  /** Brand terms to match against keywords (case-insensitive) */
-  brandTerms: string[];
-  /** Minimum impressions for a keyword to be included. Default: 10 */
-  minImpressions?: number;
-}
-interface BrandSegmentationRow {
-  query?: string;
-  keyword?: string;
-  variants?: readonly string[];
-  clicks?: number | null;
-  impressions?: number | null;
-}
-interface BrandSummary {
-  brandClicks: number;
-  nonBrandClicks: number;
-  brandShare: number;
-  brandImpressions: number;
-  nonBrandImpressions: number;
-}
-interface BrandSegmentationResult<T extends BrandSegmentationRow = QueriesRow> {
-  brand: T[];
-  nonBrand: T[];
-  summary: BrandSummary;
-}
-/**
- * Pure helper: segment keywords into brand and non-brand based on provided
- * brand terms. Re-exported from `@gscdump/analysis` for portable callers.
- */
-declare function analyzeBrandSegmentation(keywords: QueriesRow[], options: BrandSegmentationOptions): BrandSegmentationResult<QueriesRow>;
-declare function analyzeBrandSegmentation<T extends BrandSegmentationRow>(keywords: T[], options: BrandSegmentationOptions): BrandSegmentationResult<T>;
-type CannibalizationSortMetric = 'clicks' | 'impressions' | 'positionSpread' | 'pageCount';
-interface CannibalizationOptions {
-  /** Minimum impressions for a query to be considered. Default: 10 */
-  minImpressions?: number;
-  /** Maximum position spread to flag as cannibalization. Default: 10 */
-  maxPositionSpread?: number;
-  /** Minimum number of pages ranking for same query. Default: 2 */
-  minPages?: number;
-  /** Sort metric. Default: clicks */
-  sortBy?: CannibalizationSortMetric;
-  /** Sort order. Default: desc */
-  sortOrder?: SortOrder;
-}
-interface CannibalizationPage {
-  page: string;
-  clicks: number;
-  impressions: number;
-  ctr: number;
-  position: number;
-}
-interface CannibalizationResult {
-  query: string;
-  pages: CannibalizationPage[];
-  totalClicks: number;
-  totalImpressions: number;
-  positionSpread: number;
-}
-interface CannibalizationCompetitor {
-  url: string;
-  clicks: number;
-  impressions: number;
-  ctr: number;
-  position: number;
-  share: number;
-  rank: number;
-}
-interface CannibalizationEvent {
-  keyword: string;
-  totalImpressions: number;
-  totalClicks: number;
-  competitorCount: number;
-  leaderUrl: string;
-  leaderCtr: number;
-  leaderPosition: number;
-  hhi: number;
-  fragmentation: number;
-  stolenClicks: number;
-  severity: number;
-  competitors: CannibalizationCompetitor[];
-}
-/**
- * Pure helper: detects keyword cannibalization from row data — queries
- * ranking for multiple pages within a small position spread. Re-exported
- * from `@gscdump/analysis` for portable callers.
- */
-declare function analyzeCannibalization(rows: QueryPageRow[], options?: CannibalizationOptions): CannibalizationResult[];
-type ClusterType = 'prefix' | 'intent' | 'both';
-interface ClusteringOptions {
-  /** Minimum keywords for a cluster to be reported. Default: 2 */
-  minClusterSize?: number;
-  /** Minimum impressions for a keyword to be included. Default: 10 */
-  minImpressions?: number;
-  /** Clustering method. Default: 'both' */
-  clusterBy?: ClusterType;
-}
-interface KeywordCluster {
-  clusterName: string;
-  clusterType: 'prefix' | 'intent';
-  keywords: QueriesRow[];
-  totalClicks: number;
-  totalImpressions: number;
-  avgPosition: number;
-  keywordCount: number;
-}
-interface ClusteringResult {
-  clusters: KeywordCluster[];
-  unclustered: QueriesRow[];
-}
-/**
- * Pure helper: clusters keywords by intent prefix or common word prefix.
- * Re-exported from `@gscdump/analysis` for portable callers.
- */
-declare function analyzeClustering(keywords: QueriesRow[], options?: ClusteringOptions): ClusteringResult;
-type ConcentrationRiskLevel = 'low' | 'medium' | 'high';
-interface ConcentrationOptions {
-  /** Number of top items to report. Default: 10 */
-  topN?: number;
-}
-interface ConcentrationItem {
-  key: string;
-  clicks: number;
-  share: number;
-}
-interface ConcentrationInput {
-  key: string;
-  clicks: number;
-}
-interface ConcentrationResult {
-  /** Gini coefficient: 0 = equal distribution, 1 = fully concentrated */
-  giniCoefficient: number;
-  /** Herfindahl-Hirschman Index: 0-10000, >2500 = highly concentrated */
-  hhi: number;
-  /** Percentage of total clicks from top N items */
-  topNConcentration: number;
-  topNItems: ConcentrationItem[];
-  totalItems: number;
-  totalClicks: number;
-  /** Risk level derived from HHI: <1500 low, 1500-2500 medium, >2500 high */
-  riskLevel: ConcentrationRiskLevel;
-}
-/**
- * Pure helper: analyze traffic concentration across items (pages or keywords).
- * Re-exported from `@gscdump/analysis` for portable callers.
- */
-declare function analyzeConcentration(items: ConcentrationInput[], options?: ConcentrationOptions): ConcentrationResult;
-/**
- * Page concentration analysis.
- */
-declare function analyzePageConcentration(pages: PageRow[], options?: ConcentrationOptions): ConcentrationResult;
-/**
- * Keyword concentration analysis.
- */
-declare function analyzeKeywordConcentration(keywords: QueriesRow[], options?: ConcentrationOptions): ConcentrationResult;
-type DecaySortMetric = 'lostClicks' | 'declinePercent' | 'currentClicks';
-interface DecayOptions {
-  /** Minimum clicks in previous period to consider. Default: 50 */
-  minPreviousClicks?: number;
-  /** Minimum decline percentage (0-1). Default: 0.2 (20%) */
-  threshold?: number;
-  /** Metric to sort results by. Default: lostClicks */
-  sortBy?: DecaySortMetric;
-}
-interface DecayInput {
-  current: PageRow[];
-  previous: PageRow[];
-}
-interface DecaySeriesPoint {
-  week: string;
-  clicks: number;
-  impressions: number;
-}
-interface DecayResult {
-  page: string;
-  currentClicks: number;
-  previousClicks: number;
-  lostClicks: number;
-  declinePercent: number;
-  /** `null` when the page had no ranking data in the current period (not "position 0"). */
-  currentPosition: number | null;
-  previousPosition: number;
-  /** `null` unless both currentPosition and previousPosition exist. */
-  positionDrop: number | null;
-  series?: DecaySeriesPoint[];
-}
-/**
- * Pure helper: identify "decaying" content — pages that have lost
- * significant traffic between two periods.
- */
-declare function analyzeDecay(input: DecayInput, options?: DecayOptions): DecayResult[];
-type MoversSortMetric = 'clicks' | 'impressions' | 'clicksChange' | 'impressionsChange' | 'positionChange';
-interface MoversOptions {
-  /** Minimum change threshold to flag. Default: 0.2 (20%) */
-  changeThreshold?: number;
-  /** Minimum impressions in recent period. Default: 50 */
-  minImpressions?: number;
-  /** Metric to sort results by. Default: clicksChange */
-  sortBy?: MoversSortMetric;
-}
-interface MoversInput {
-  current: QueriesRow[];
-  previous: QueriesRow[];
-  /** If periods have different lengths, provide normalization factor (previous/current) */
-  normalizationFactor?: number;
-}
-interface MoverData {
-  keyword: string;
-  page: string | null;
-  recentClicks: number;
-  recentImpressions: number;
-  recentPosition: number;
-  baselineClicks: number;
-  baselineImpressions: number;
-  /** `null` when the keyword has no previous-period data (a genuinely new query), not "position 0". */
-  baselinePosition: number | null;
-  clicksChange: number;
-  clicksChangePercent: number;
-  impressionsChangePercent: number;
-  /** `null` unless both recentPosition and baselinePosition exist. */
-  positionChange: number | null;
-}
-interface MoversResult {
-  rising: MoverData[];
-  declining: MoverData[];
-  stable: MoverData[];
-}
-/**
- * Pure helper: identify "movers and shakers" — keywords with significant
- * recent changes between two periods.
- */
-declare function analyzeMovers(input: MoversInput, options?: MoversOptions): MoversResult;
-type OpportunitySortMetric = 'opportunityScore' | 'potentialClicks' | 'impressions' | 'position';
-interface OpportunityFactors {
-  positionScore: number;
-  impressionScore: number;
-  ctrGapScore: number;
-}
-interface OpportunityResult {
-  keyword: string;
-  page: string | null;
-  clicks: number;
-  impressions: number;
-  ctr: number;
-  position: number;
-  opportunityScore: number;
-  potentialClicks: number;
-  factors: OpportunityFactors;
-}
-interface OpportunityWeights {
-  position?: number;
-  impressions?: number;
-  ctrGap?: number;
-}
-interface OpportunityOptions {
-  minImpressions?: number;
-  weights?: OpportunityWeights;
-  sortBy?: OpportunitySortMetric;
-  limit?: number;
-}
-/** Pure opportunity scorer shared by hosted and package analyzer callers. */
-declare function analyzeOpportunity(keywords: QueriesRow[], options?: OpportunityOptions): OpportunityResult[];
-type SeasonalityMetric = 'clicks' | 'impressions';
-interface SeasonalityOptions {
-  /** Metric to analyze for seasonality. Default: clicks */
-  metric?: SeasonalityMetric;
-}
-interface MonthlyData {
-  month: string;
-  value: number;
-  vsAverage: number;
-  isPeak: boolean;
-  isTrough: boolean;
-}
-interface SeasonalityResult {
-  hasSeasonality: boolean;
-  /** Coefficient of variation: std dev / mean. Higher = more seasonal. */
-  strength: number;
-  peakMonths: string[];
-  troughMonths: string[];
-  monthlyBreakdown: MonthlyData[];
-  insufficientData: boolean;
-}
-/**
- * Pure helper: detects seasonality patterns by analyzing monthly traffic
- * variation. Re-exported from `@gscdump/analysis` for portable callers.
- */
-declare function analyzeSeasonality(dates: DateRow[], options?: SeasonalityOptions): SeasonalityResult;
-/**
- * Unified `striking-distance` analyzer. Spike for the `defineAnalyzer`
- * pattern: one file owns the SQL plan, the row plan, the typed `InputRow`
- * contract, and the shared reducer.
- *
- * SQL and row plans both emit rows matching `StrikingDistanceInputRow`.
- * Filtering (`minPosition`/`maxPosition`/`minImpressions`/`maxCtr`),
- * derivation (`potentialClicks`), and sorting all live in the reducer, so
- * drift between plans cannot silently change results. A SQL-side `LIMIT`
- * push-down can be added later as an optional optimization, but the
- * correctness contract stays with the reducer.
- */
-/**
- * Row shape both plans produce. Field names match GSC's native columns so
- * the row-source path needs no rename step; the SQL plan aliases `url → page`.
- */
-interface StrikingDistanceInputRow {
-  query: string;
-  page: string | null;
-  clicks: number;
-  impressions: number;
-  ctr: number;
-  position: number;
-}
-interface StrikingDistanceResult {
-  keyword: string;
-  page: string | null;
-  clicks: number;
-  impressions: number;
-  ctr: number;
-  position: number;
-  /** Estimated clicks at ~15% CTR (the average for positions 1–3). */
-  potentialClicks: number;
-}
-interface StrikingDistanceFilterOptions {
-  minPosition?: number;
-  maxPosition?: number;
-  minImpressions?: number;
-  maxCtr?: number;
-}
-interface StrikingDistanceOptions extends StrikingDistanceFilterOptions {
-  limit?: number;
-  offset?: number;
-}
-/** Pure striking-distance analysis for consumers that already own the rows. */
-declare function analyzeStrikingDistance(rows: readonly {
-  query: unknown;
-  page?: unknown;
-  clicks: unknown;
-  impressions: unknown;
-  ctr: unknown;
-  position: unknown;
-}[], options?: StrikingDistanceOptions): StrikingDistanceResult[];
-interface ZeroClickResult {
-  query: string;
-  page: string;
-  clicks: number;
-  impressions: number;
-  ctr: number;
-  position: number;
-}
-interface ZeroClickOptions {
-  minImpressions?: number;
-  maxCtr?: number;
-  maxPosition?: number;
-}
-/** Pure zero-click detector shared by hosted and package analyzer callers. */
-declare function analyzeZeroClick(rows: QueryPageRow[], options?: ZeroClickOptions): ZeroClickResult[];
-declare function analyzeInBrowser(runner: AttachedTableRunner, opts: AttachedTableSourceOptions, params: AnalysisParams$1, registry: AnalyzerRegistry$1): Promise<AnalysisResult$1>;
-declare const INTENT_CLASSIFIER_VERSION = 1;
-type SearchIntent = 'transactional' | 'commercial' | 'informational' | 'unknown';
-interface IntentClassification {
-  /** Primary intent, by priority transactional > commercial > informational. */
-  intent: SearchIntent;
-  /** Procedural sub-signal of informational ("how to …"). */
-  howTo: boolean;
-  /** Matched cue tokens/phrases, for explainability + debugging. */
-  signals: readonly string[];
-}
-declare const SEARCH_INTENT_CODE: Record<SearchIntent, number>;
-/** Pack a classification into one small int for cheap dimension storage. */
-declare function encodeIntent(c: Pick<IntentClassification, 'intent' | 'howTo'>): number;
-/**
- * Classify the search intent of a raw query from lexical cues. Deterministic;
- * version it (`INTENT_CLASSIFIER_VERSION`) and bump on any rule change so a
- * materialized `intent` can detect staleness, like the canonical normalizer.
- */
-declare function classifyQueryIntent(query: string): IntentClassification;
-/**
- * Algorithm version. Bump on ANY behaviour change (synonyms, depluralize,
- * folding) so downstream stores can record which version produced a
- * `query_canonical` and detect/repair staleness on a rule change instead of
- * silently mixing old and new keys. v1 = the original ASCII heuristic;
- * v2 adds Unicode folding, the empty-canonical guard, and `pluralize`-based
- * singularization.
- */
-declare const NORMALIZER_VERSION = 2;
-/**
- * Produce a canonical form of a search query for grouping near-duplicates.
- * Idempotent: `normalizeQuery(normalizeQuery(q)) === normalizeQuery(q)`.
- */
-declare function normalizeQuery(query: string): string;
-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 { type ActionPriorityResult, type ActionPrioritySourceState, type ActionPrioritySourceStatus, type ActionSource, type AnalysisError, type AnalysisErrorKind, 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 CompositeSourceOptions, type ConcentrationInput, type ConcentrationItem, type ConcentrationOptions, type ConcentrationResult, type ConcentrationRiskLevel, DEFAULT_PRIORITY_SOURCES, type DateRow, type DecayInput, type DecayOptions, type DecayResult, type DecaySeriesPoint, type DecaySortMetric, type DefineAnalyzerOptions, type DefineReportOptions, type DefinedAnalyzer, type DefinedReport, type DryRunReportResult, ENGINE_QUERY_CAPABILITIES, type Effort, type EngineQuerySourceOptions, type ExecuteSqlOptions, type FileSet, type FormatReportOptions, INTENT_CLASSIFIER_VERSION, IN_MEMORY_DEFAULT_CAPABILITIES, type InMemoryQuerySourceOptions, 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 PriorityAction, type QueriesRow, type QueryPageRow, type QueryRow, REPORTS, ROW_ANALYZERS, type ReduceContext, type ReduceCtx, type Reducer, type ReportAction, type ReportContext, type ReportFinding, type ReportPlanStep, type ReportResult, type ReportSection, type RequiredCapability, type ResolveWindowOptions, type ResolvedWindow, type RowQueriesPlan, type RunReportOptions, SEARCH_INTENT_CODE, SQL_ANALYZERS, type SearchIntent, type SeasonalityMetric, type SeasonalityOptions, type SeasonalityResult, 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, analysisErrorToException, analysisErrors, analyzeBrandSegmentation, analyzeCannibalization, analyzeClustering, analyzeConcentration, analyzeDecay, analyzeInBrowser, analyzeKeywordConcentration, analyzeMovers, analyzeOpportunity, analyzePageConcentration, analyzeSeasonality, analyzeStrikingDistance, analyzeZeroClick, classifyQueryIntent, comparisonOf, createAnalyzerRegistry, createCompositeSource, createEngineQuerySource, createInMemoryQuerySource, createSorter, defaultAnalyzerRegistry, defaultReportRegistry, defineAnalyzer, diffSitemapHealth, dryRunReport, encodeIntent, formatAnalysisError, formatReport, isAnalysisError, mergePriorityActions, normalizePriorityActions, normalizeQuery, num, padTimeseries, periodOf, queryRows, resolveWindow, runAnalyzerFromSource, runAnalyzerWithEngine, runReport, runReportResult, scorePriorityActions };

package/dist/index.mjs

@@ -1,53 +1,32 @@
-import { DEFAULT_PRIORITY_SOURCES, REPORTS, defaultReportRegistry, dryRunReport, formatReport, mergePriorityActions, normalizePriorityActions, runReport, runReportResult, scorePriorityActions } from "./_chunks/report.mjs";
-import { INTENT_CLASSIFIER_VERSION, NORMALIZER_VERSION, ROW_ANALYZERS, SEARCH_INTENT_CODE, SQL_ANALYZERS, analyzeBrandSegmentation, analyzeCannibalization, analyzeClustering, analyzeConcentration, analyzeDecay, analyzeKeywordConcentration, analyzeMovers, analyzeOpportunity, analyzePageConcentration, analyzeSeasonality, analyzeStrikingDistance, analyzeZeroClick, classifyQueryIntent, createSorter, defaultAnalyzerRegistry, encodeIntent, normalizeQuery } from "./_chunks/default-registry.mjs";
+import { DEFAULT_PRIORITY_SOURCES, mergePriorityActions, normalizePriorityActions, scorePriorityActions } from "./action-priority.mjs";
 import { analysisErrorToException, analysisErrors, formatAnalysisError, isAnalysisError } from "./errors.mjs";
-import { IN_MEMORY_DEFAULT_CAPABILITIES, createCompositeSource, createInMemoryQuerySource } from "./_chunks/source.mjs";
-import { AnalyzerCapabilityError, createAnalyzerRegistry, defineAnalyzer, runAnalyzerFromSource, runAnalyzerFromSource as runAnalyzerFromSource$1 } from "@gscdump/engine/analyzer";
+import { analyzeBrandSegmentation } from "./analyzers/brand.mjs";
+import { createSorter } from "./types.mjs";
+import { analyzeCannibalization } from "./analyzers/cannibalization.mjs";
+import { analyzeClustering } from "./analyzers/clustering.mjs";
+import { analyzeConcentration, analyzeKeywordConcentration, analyzePageConcentration } from "./analyzers/concentration.mjs";
+import { INTENT_CLASSIFIER_VERSION, SEARCH_INTENT_CODE, classifyQueryIntent, encodeIntent } from "./query/intent.mjs";
+import { NORMALIZER_VERSION, normalizeQuery } from "./query/normalize.mjs";
+import { analyzeDecay } from "./analyzers/decay.mjs";
+import { analyzeMovers } from "./analyzers/movers.mjs";
+import { analyzeOpportunity } from "./analyzers/opportunity.mjs";
+import { analyzeSeasonality } from "./analyzers/seasonality.mjs";
+import { analyzeStrikingDistance } from "./analyzers/striking-distance.mjs";
+import { analyzeZeroClick } from "./analyzers/zero-click.mjs";
+import { ROW_ANALYZERS } from "./analyzer/row-analyzers.mjs";
+import { analyzeInBrowser } from "./browser.mjs";
+import { SQL_ANALYZERS } from "./sql-analyzers.mjs";
+import { defaultAnalyzerRegistry } from "./default-registry.mjs";
+import { formatReport } from "./report/format.mjs";
+import { REPORTS, defaultReportRegistry } from "./report/registry.mjs";
+import { dryRunReport, runReport, runReportResult } from "./report/runtime.mjs";
+import "./report/index.mjs";
+import { diffSitemapHealth } from "./sitemap-health.mjs";
+import { createCompositeSource } from "./source/composite.mjs";
+import { IN_MEMORY_DEFAULT_CAPABILITIES, createInMemoryQuerySource } from "./source/in-memory.mjs";
+import "./source/index.mjs";
+import { AnalyzerCapabilityError, createAnalyzerRegistry, defineAnalyzer, runAnalyzerFromSource } from "@gscdump/engine/analyzer";
 import { comparisonOf, padTimeseries, periodOf, resolveWindow } from "@gscdump/engine/period";
 import { num } from "@gscdump/engine/analysis-types";
-import { pgResolverAdapter } from "@gscdump/engine/resolver";
-import { ENGINE_QUERY_CAPABILITIES, createAttachedTableSource, createEngineQuerySource, queryRows, runAnalyzerWithEngine } from "@gscdump/engine/source";
-async function analyzeInBrowser(runner, opts, params, registry) {
-	opts.signal?.throwIfAborted();
-	return runAnalyzerFromSource$1(createAttachedTableSource(runner, {
-		adapter: pgResolverAdapter,
-		...opts
-	}), params, registry);
-}
-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
-	};
-}
+import { ENGINE_QUERY_CAPABILITIES, createEngineQuerySource, queryRows, runAnalyzerWithEngine } from "@gscdump/engine/source";
 export { AnalyzerCapabilityError, DEFAULT_PRIORITY_SOURCES, ENGINE_QUERY_CAPABILITIES, INTENT_CLASSIFIER_VERSION, IN_MEMORY_DEFAULT_CAPABILITIES, NORMALIZER_VERSION, REPORTS, ROW_ANALYZERS, SEARCH_INTENT_CODE, SQL_ANALYZERS, analysisErrorToException, analysisErrors, analyzeBrandSegmentation, analyzeCannibalization, analyzeClustering, analyzeConcentration, analyzeDecay, analyzeInBrowser, analyzeKeywordConcentration, analyzeMovers, analyzeOpportunity, analyzePageConcentration, analyzeSeasonality, analyzeStrikingDistance, analyzeZeroClick, classifyQueryIntent, comparisonOf, createAnalyzerRegistry, createCompositeSource, createEngineQuerySource, createInMemoryQuerySource, createSorter, defaultAnalyzerRegistry, defaultReportRegistry, defineAnalyzer, diffSitemapHealth, dryRunReport, encodeIntent, formatAnalysisError, formatReport, isAnalysisError, mergePriorityActions, normalizePriorityActions, normalizeQuery, num, padTimeseries, periodOf, queryRows, resolveWindow, runAnalyzerFromSource, runAnalyzerWithEngine, runReport, runReportResult, scorePriorityActions };