@gscdump/analysis 3.5.0 → 3.6.0

package/dist/analyzers/cannibalization.d.mts

@@ -1,6 +1,6 @@
 import { QueryPageRow, SortOrder } from "../types.mjs";
-type CannibalizationSortMetric = 'clicks' | 'impressions' | 'positionSpread' | 'pageCount';
-interface CannibalizationOptions {
+export type CannibalizationSortMetric = 'clicks' | 'impressions' | 'positionSpread' | 'pageCount';
+export interface CannibalizationOptions {
   /** Minimum impressions for a query to be considered. Default: 10 */
   minImpressions?: number;
   /** Maximum position spread to flag as cannibalization. Default: 10 */
@@ -12,21 +12,21 @@ interface CannibalizationOptions {
   /** Sort order. Default: desc */
   sortOrder?: SortOrder;
 }
-interface CannibalizationPage {
+export interface CannibalizationPage {
   page: string;
   clicks: number;
   impressions: number;
   ctr: number;
   position: number;
 }
-interface CannibalizationResult {
+export interface CannibalizationResult {
   query: string;
   pages: CannibalizationPage[];
   totalClicks: number;
   totalImpressions: number;
   positionSpread: number;
 }
-interface CannibalizationCompetitor {
+export interface CannibalizationCompetitor {
   url: string;
   clicks: number;
   impressions: number;
@@ -35,7 +35,7 @@ interface CannibalizationCompetitor {
   share: number;
   rank: number;
 }
-interface CannibalizationEvent {
+export interface CannibalizationEvent {
   keyword: string;
   totalImpressions: number;
   totalClicks: number;
@@ -54,5 +54,4 @@ interface CannibalizationEvent {
  * 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[];
-export { CannibalizationCompetitor, CannibalizationEvent, CannibalizationOptions, CannibalizationPage, CannibalizationResult, CannibalizationSortMetric, analyzeCannibalization };
+export declare function analyzeCannibalization(rows: QueryPageRow[], options?: CannibalizationOptions): CannibalizationResult[];

package/dist/analyzers/clustering.d.mts

@@ -1,6 +1,6 @@
 import { QueriesRow } from "../types.mjs";
-type ClusterType = 'prefix' | 'intent' | 'both';
-interface ClusteringOptions {
+export type ClusterType = 'prefix' | 'intent' | 'both';
+export interface ClusteringOptions {
   /** Minimum keywords for a cluster to be reported. Default: 2 */
   minClusterSize?: number;
   /** Minimum impressions for a keyword to be included. Default: 10 */
@@ -8,7 +8,7 @@ interface ClusteringOptions {
   /** Clustering method. Default: 'both' */
   clusterBy?: ClusterType;
 }
-interface KeywordCluster {
+export interface KeywordCluster {
   clusterName: string;
   clusterType: 'prefix' | 'intent';
   keywords: QueriesRow[];
@@ -17,7 +17,7 @@ interface KeywordCluster {
   avgPosition: number;
   keywordCount: number;
 }
-interface ClusteringResult {
+export interface ClusteringResult {
   clusters: KeywordCluster[];
   unclustered: QueriesRow[];
 }
@@ -25,5 +25,4 @@ interface ClusteringResult {
  * 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;
-export { ClusterType, ClusteringOptions, ClusteringResult, KeywordCluster, analyzeClustering };
+export declare function analyzeClustering(keywords: QueriesRow[], options?: ClusteringOptions): ClusteringResult;

package/dist/analyzers/concentration.d.mts

@@ -1,19 +1,19 @@
 import { PageRow, QueriesRow } from "../types.mjs";
-type ConcentrationRiskLevel = 'low' | 'medium' | 'high';
-interface ConcentrationOptions {
+export type ConcentrationRiskLevel = 'low' | 'medium' | 'high';
+export interface ConcentrationOptions {
   /** Number of top items to report. Default: 10 */
   topN?: number;
 }
-interface ConcentrationItem {
+export interface ConcentrationItem {
   key: string;
   clicks: number;
   share: number;
 }
-interface ConcentrationInput {
+export interface ConcentrationInput {
   key: string;
   clicks: number;
 }
-interface ConcentrationResult {
+export interface ConcentrationResult {
   /** Gini coefficient: 0 = equal distribution, 1 = fully concentrated */
   giniCoefficient: number;
   /** Herfindahl-Hirschman Index: 0-10000, >2500 = highly concentrated */
@@ -30,13 +30,12 @@ interface ConcentrationResult {
  * 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;
+export declare function analyzeConcentration(items: ConcentrationInput[], options?: ConcentrationOptions): ConcentrationResult;
 /**
  * Page concentration analysis.
  */
-declare function analyzePageConcentration(pages: PageRow[], options?: ConcentrationOptions): ConcentrationResult;
+export declare function analyzePageConcentration(pages: PageRow[], options?: ConcentrationOptions): ConcentrationResult;
 /**
  * Keyword concentration analysis.
  */
-declare function analyzeKeywordConcentration(keywords: QueriesRow[], options?: ConcentrationOptions): ConcentrationResult;
-export { ConcentrationInput, ConcentrationItem, ConcentrationOptions, ConcentrationResult, ConcentrationRiskLevel, analyzeConcentration, analyzeKeywordConcentration, analyzePageConcentration };
+export declare function analyzeKeywordConcentration(keywords: QueriesRow[], options?: ConcentrationOptions): ConcentrationResult;

package/dist/analyzers/decay.d.mts

@@ -1,6 +1,6 @@
 import { PageRow } from "../types.mjs";
-type DecaySortMetric = 'lostClicks' | 'declinePercent' | 'currentClicks';
-interface DecayOptions {
+export type DecaySortMetric = 'lostClicks' | 'declinePercent' | 'currentClicks';
+export interface DecayOptions {
   /** Minimum clicks in previous period to consider. Default: 50 */
   minPreviousClicks?: number;
   /** Minimum decline percentage (0-1). Default: 0.2 (20%) */
@@ -8,16 +8,16 @@ interface DecayOptions {
   /** Metric to sort results by. Default: lostClicks */
   sortBy?: DecaySortMetric;
 }
-interface DecayInput {
+export interface DecayInput {
   current: PageRow[];
   previous: PageRow[];
 }
-interface DecaySeriesPoint {
+export interface DecaySeriesPoint {
   week: string;
   clicks: number;
   impressions: number;
 }
-interface DecayResult {
+export interface DecayResult {
   page: string;
   currentClicks: number;
   previousClicks: number;
@@ -34,5 +34,4 @@ interface DecayResult {
  * Pure helper: identify "decaying" content — pages that have lost
  * significant traffic between two periods.
  */
-declare function analyzeDecay(input: DecayInput, options?: DecayOptions): DecayResult[];
-export { DecayInput, DecayOptions, DecayResult, DecaySeriesPoint, DecaySortMetric, analyzeDecay };
+export declare function analyzeDecay(input: DecayInput, options?: DecayOptions): DecayResult[];

package/dist/analyzers/movers.d.mts

@@ -1,6 +1,6 @@
 import { QueriesRow } from "../types.mjs";
-type MoversSortMetric = 'clicks' | 'impressions' | 'clicksChange' | 'impressionsChange' | 'positionChange';
-interface MoversOptions {
+export type MoversSortMetric = 'clicks' | 'impressions' | 'clicksChange' | 'impressionsChange' | 'positionChange';
+export interface MoversOptions {
   /** Minimum change threshold to flag. Default: 0.2 (20%) */
   changeThreshold?: number;
   /** Minimum impressions in recent period. Default: 50 */
@@ -8,13 +8,13 @@ interface MoversOptions {
   /** Metric to sort results by. Default: clicksChange */
   sortBy?: MoversSortMetric;
 }
-interface MoversInput {
+export interface MoversInput {
   current: QueriesRow[];
   previous: QueriesRow[];
   /** If periods have different lengths, provide normalization factor (previous/current) */
   normalizationFactor?: number;
 }
-interface MoverData {
+export interface MoverData {
   keyword: string;
   page: string | null;
   recentClicks: number;
@@ -30,7 +30,7 @@ interface MoverData {
   /** `null` unless both recentPosition and baselinePosition exist. */
   positionChange: number | null;
 }
-interface MoversResult {
+export interface MoversResult {
   rising: MoverData[];
   declining: MoverData[];
   stable: MoverData[];
@@ -39,5 +39,4 @@ interface MoversResult {
  * Pure helper: identify "movers and shakers" — keywords with significant
  * recent changes between two periods.
  */
-declare function analyzeMovers(input: MoversInput, options?: MoversOptions): MoversResult;
-export { MoverData, MoversInput, MoversOptions, MoversResult, MoversSortMetric, analyzeMovers };
+export declare function analyzeMovers(input: MoversInput, options?: MoversOptions): MoversResult;

package/dist/analyzers/opportunity.d.mts

@@ -1,11 +1,11 @@
 import { QueriesRow } from "../types.mjs";
-type OpportunitySortMetric = 'opportunityScore' | 'potentialClicks' | 'impressions' | 'position';
-interface OpportunityFactors {
+export type OpportunitySortMetric = 'opportunityScore' | 'potentialClicks' | 'impressions' | 'position';
+export interface OpportunityFactors {
   positionScore: number;
   impressionScore: number;
   ctrGapScore: number;
 }
-interface OpportunityResult {
+export interface OpportunityResult {
   keyword: string;
   page: string | null;
   clicks: number;
@@ -16,17 +16,16 @@ interface OpportunityResult {
   potentialClicks: number;
   factors: OpportunityFactors;
 }
-interface OpportunityWeights {
+export interface OpportunityWeights {
   position?: number;
   impressions?: number;
   ctrGap?: number;
 }
-interface OpportunityOptions {
+export 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[];
-export { OpportunityFactors, OpportunityOptions, OpportunityResult, OpportunitySortMetric, OpportunityWeights, analyzeOpportunity };
+export declare function analyzeOpportunity(keywords: QueriesRow[], options?: OpportunityOptions): OpportunityResult[];

package/dist/analyzers/seasonality.d.mts

@@ -1,17 +1,17 @@
 import { DateRow } from "../types.mjs";
-type SeasonalityMetric = 'clicks' | 'impressions';
-interface SeasonalityOptions {
+export type SeasonalityMetric = 'clicks' | 'impressions';
+export interface SeasonalityOptions {
   /** Metric to analyze for seasonality. Default: clicks */
   metric?: SeasonalityMetric;
 }
-interface MonthlyData {
+export interface MonthlyData {
   month: string;
   value: number;
   vsAverage: number;
   isPeak: boolean;
   isTrough: boolean;
 }
-interface SeasonalityResult {
+export interface SeasonalityResult {
   hasSeasonality: boolean;
   /** Coefficient of variation: std dev / mean. Higher = more seasonal. */
   strength: number;
@@ -24,5 +24,4 @@ interface SeasonalityResult {
  * 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;
-export { MonthlyData, SeasonalityMetric, SeasonalityOptions, SeasonalityResult, analyzeSeasonality };
+export declare function analyzeSeasonality(dates: DateRow[], options?: SeasonalityOptions): SeasonalityResult;

package/dist/analyzers/striking-distance.d.mts

@@ -14,7 +14,7 @@
  * 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 {
+export interface StrikingDistanceInputRow {
   query: string;
   page: string | null;
   clicks: number;
@@ -22,7 +22,7 @@ interface StrikingDistanceInputRow {
   ctr: number;
   position: number;
 }
-interface StrikingDistanceResult {
+export interface StrikingDistanceResult {
   keyword: string;
   page: string | null;
   clicks: number;
@@ -32,23 +32,22 @@ interface StrikingDistanceResult {
   /** Estimated clicks at ~15% CTR (the average for positions 1–3). */
   potentialClicks: number;
 }
-interface StrikingDistanceFilterOptions {
+export interface StrikingDistanceFilterOptions {
   minPosition?: number;
   maxPosition?: number;
   minImpressions?: number;
   maxCtr?: number;
 }
-interface StrikingDistanceOptions extends StrikingDistanceFilterOptions {
+export interface StrikingDistanceOptions extends StrikingDistanceFilterOptions {
   limit?: number;
   offset?: number;
 }
 /** Pure striking-distance analysis for consumers that already own the rows. */
-declare function analyzeStrikingDistance(rows: readonly {
+export declare function analyzeStrikingDistance(rows: readonly {
   query: unknown;
   page?: unknown;
   clicks: unknown;
   impressions: unknown;
   ctr: unknown;
   position: unknown;
-}[], options?: StrikingDistanceOptions): StrikingDistanceResult[];
-export { StrikingDistanceFilterOptions, StrikingDistanceInputRow, StrikingDistanceOptions, StrikingDistanceResult, analyzeStrikingDistance };
+}[], options?: StrikingDistanceOptions): StrikingDistanceResult[];

package/dist/analyzers/zero-click.d.mts

@@ -1,5 +1,5 @@
 import { QueryPageRow } from "../types.mjs";
-interface ZeroClickResult {
+export interface ZeroClickResult {
   query: string;
   page: string;
   clicks: number;
@@ -7,11 +7,10 @@ interface ZeroClickResult {
   ctr: number;
   position: number;
 }
-interface ZeroClickOptions {
+export 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[];
-export { ZeroClickOptions, ZeroClickResult, analyzeZeroClick };
+export declare function analyzeZeroClick(rows: QueryPageRow[], options?: ZeroClickOptions): ZeroClickResult[];

package/dist/browser.d.mts

@@ -1,5 +1,5 @@
 import { AnalysisParams, AnalysisResult } from "@gscdump/engine/analysis-types";
 import { AnalyzerRegistry } from "@gscdump/engine/analyzer";
 import { AttachedTableRunner, AttachedTableRunner as AnalyzerRunner, AttachedTableSourceOptions, AttachedTableSourceOptions as BrowserAnalyzeOptions } from "@gscdump/engine/source";
-declare function analyzeInBrowser(runner: AttachedTableRunner, opts: AttachedTableSourceOptions, params: AnalysisParams, registry: AnalyzerRegistry): Promise<AnalysisResult>;
-export { type AnalyzerRunner, type BrowserAnalyzeOptions, analyzeInBrowser };
+export declare function analyzeInBrowser(runner: AttachedTableRunner, opts: AttachedTableSourceOptions, params: AnalysisParams, registry: AnalyzerRegistry): Promise<AnalysisResult>;
+export type { AnalyzerRunner, BrowserAnalyzeOptions };

package/dist/default-registry.d.mts

@@ -1,4 +1,4 @@
 import { ROW_ANALYZERS } from "./analyzer/row-analyzers.mjs";
 import { SQL_ANALYZERS } from "./sql-analyzers.mjs";
-declare const defaultAnalyzerRegistry: import("@gscdump/engine/analyzer").AnalyzerRegistry;
-export { ROW_ANALYZERS, SQL_ANALYZERS, defaultAnalyzerRegistry };
+export declare const defaultAnalyzerRegistry: import("@gscdump/engine/analyzer").AnalyzerRegistry;
+export { ROW_ANALYZERS, SQL_ANALYZERS };

package/dist/errors.d.mts

@@ -1,5 +1,5 @@
-type AnalysisErrorKind = 'missing-report-param' | 'missing-comparison-window' | 'missing-brand-terms' | 'unknown-report' | 'unknown-analyzer' | 'required-step-failed';
-type AnalysisError = {
+export type AnalysisErrorKind = 'missing-report-param' | 'missing-comparison-window' | 'missing-brand-terms' | 'unknown-report' | 'unknown-analyzer' | 'required-step-failed';
+export type AnalysisError = {
   kind: 'missing-report-param';
   report: string;
   param: string;
@@ -28,7 +28,7 @@ type AnalysisError = {
   message: string;
   cause?: unknown;
 };
-declare const analysisErrors: {
+export declare const analysisErrors: {
   readonly missingReportParam: (report: string, param: string, message: string) => AnalysisError;
   readonly missingComparisonWindow: (report: string, message: string) => AnalysisError;
   readonly missingBrandTerms: () => AnalysisError;
@@ -36,9 +36,9 @@ declare const analysisErrors: {
   readonly unknownAnalyzer: (analyzer: string) => AnalysisError;
   readonly requiredStepFailed: (report: string, stepKey: string, stepError: string, cause?: unknown) => AnalysisError;
 };
-declare function isAnalysisError(value: unknown): value is AnalysisError;
+export 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;
+export 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`
@@ -48,5 +48,4 @@ declare function formatAnalysisError(error: AnalysisError): string;
  * assertions (`/--target/`, `/comparison window/`, `/required step "k"/`)
  * continue to match.
  */
-declare function analysisErrorToException(error: AnalysisError): Error;
-export { AnalysisError, AnalysisErrorKind, analysisErrorToException, analysisErrors, formatAnalysisError, isAnalysisError };
+export declare function analysisErrorToException(error: AnalysisError): Error;

package/dist/query/intent.d.mts

@@ -1,6 +1,6 @@
-declare const INTENT_CLASSIFIER_VERSION = 1;
-type SearchIntent = 'transactional' | 'commercial' | 'informational' | 'unknown';
-interface IntentClassification {
+export declare const INTENT_CLASSIFIER_VERSION = 1;
+export type SearchIntent = 'transactional' | 'commercial' | 'informational' | 'unknown';
+export interface IntentClassification {
   /** Primary intent, by priority transactional > commercial > informational. */
   intent: SearchIntent;
   /** Procedural sub-signal of informational ("how to …"). */
@@ -8,13 +8,12 @@ interface IntentClassification {
   /** Matched cue tokens/phrases, for explainability + debugging. */
   signals: readonly string[];
 }
-declare const SEARCH_INTENT_CODE: Record<SearchIntent, number>;
+export 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;
+export 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;
-export { INTENT_CLASSIFIER_VERSION, IntentClassification, SEARCH_INTENT_CODE, SearchIntent, classifyQueryIntent, encodeIntent };
+export declare function classifyQueryIntent(query: string): IntentClassification;

package/dist/query/normalize.d.mts

@@ -6,10 +6,9 @@
  * v2 adds Unicode folding, the empty-canonical guard, and `pluralize`-based
  * singularization.
  */
-declare const NORMALIZER_VERSION = 2;
+export 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;
-export { NORMALIZER_VERSION, normalizeQuery };
+export declare function normalizeQuery(query: string): string;

package/dist/report/format.d.mts

@@ -1,7 +1,6 @@
 import { ReportResult } from "@gscdump/engine/report";
-interface FormatReportOptions {
+export interface FormatReportOptions {
   /** Cap findings rendered per section. Defaults to all (already bounded by report). */
   maxFindingsPerSection?: number;
 }
-declare function formatReport(report: ReportResult, opts?: FormatReportOptions): string;
-export { FormatReportOptions, formatReport };
+export declare function formatReport(report: ReportResult, opts?: FormatReportOptions): string;

package/dist/report/registry.d.mts

@@ -1,4 +1,3 @@
 import { DefinedReport, ReportParams } from "@gscdump/engine/report";
-declare const REPORTS: readonly DefinedReport<ReportParams>[];
-declare const defaultReportRegistry: import("@gscdump/engine/report").ReportRegistry;
-export { REPORTS, defaultReportRegistry };
+export declare const REPORTS: readonly DefinedReport<ReportParams>[];
+export declare const defaultReportRegistry: import("@gscdump/engine/report").ReportRegistry;

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

@@ -6,8 +6,8 @@
  * Today: case-insensitive exact match, falling back to substring (LIKE %x%)
  * over a caller-supplied candidate list.
  */
-type ResolveTargetKind = 'page' | 'query';
-interface ResolveTargetInput {
+export type ResolveTargetKind = 'page' | 'query';
+export interface ResolveTargetInput {
   kind: ResolveTargetKind;
   input: string;
   /**
@@ -17,7 +17,7 @@ interface ResolveTargetInput {
    */
   candidates?: readonly string[];
 }
-interface ResolveTargetResult {
+export 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. */
@@ -25,5 +25,4 @@ interface ResolveTargetResult {
   /** True when no candidates matched at all. */
   unresolved: boolean;
 }
-declare function resolveTarget(opts: ResolveTargetInput): ResolveTargetResult;
-export { ResolveTargetInput, ResolveTargetKind, ResolveTargetResult, resolveTarget };
+export declare function resolveTarget(opts: ResolveTargetInput): ResolveTargetResult;

package/dist/report/runtime.d.mts

@@ -3,7 +3,7 @@ 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 RunReportOptions<P extends ReportParams = ReportParams> {
+export interface RunReportOptions<P extends ReportParams = ReportParams> {
   source: AnalysisQuerySource;
   analyzers: AnalyzerRegistry;
   ctx: ReportContext<P>;
@@ -26,7 +26,7 @@ interface RunReportOptions<P extends ReportParams = ReportParams> {
  * defects from this core's perspective and still propagate; those are modelled
  * at the report-definition boundary, not here.
  */
-declare function runReportResult<P extends ReportParams = ReportParams>(report: DefinedReport<P>, opts: RunReportOptions<P>): Promise<Result<ReportResult, AnalysisError>>;
+export declare function runReportResult<P extends ReportParams = ReportParams>(report: DefinedReport<P>, opts: RunReportOptions<P>): Promise<Result<ReportResult, AnalysisError>>;
 /**
  * Throwing wrapper over {@link runReportResult}, preserving the historical
  * call-site ergonomics (a required-step failure rejects). The thrown message is
@@ -34,8 +34,8 @@ declare function runReportResult<P extends ReportParams = ReportParams>(report:
  * assertions hold; the typed `AnalysisError` is reachable via `.analysisError`
  * and the original failure via `.cause`.
  */
-declare function runReport<P extends ReportParams = ReportParams>(report: DefinedReport<P>, opts: RunReportOptions<P>): Promise<ReportResult>;
-interface DryRunReportResult {
+export declare function runReport<P extends ReportParams = ReportParams>(report: DefinedReport<P>, opts: RunReportOptions<P>): Promise<ReportResult>;
+export interface DryRunReportResult {
   steps: {
     key: string;
     type: string;
@@ -52,5 +52,4 @@ interface DryRunReportResult {
  * cost models don't exist yet — so `estRowsScanned` is left undefined.
  * 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, RunReportOptions, dryRunReport, runReport, runReportResult };
+export declare function dryRunReport<P extends ReportParams = ReportParams>(report: DefinedReport<P>, ctx: ReportContext<P>): Promise<DryRunReportResult>;

package/dist/sitemap-health.d.mts

@@ -1,23 +1,23 @@
-interface SitemapHealthRow {
+export interface SitemapHealthRow {
   path: string;
   errors: number;
   warnings: number;
 }
-interface SitemapHealthInput extends SitemapHealthRow {
+export interface SitemapHealthInput extends SitemapHealthRow {
   isPending?: boolean;
   type?: string;
   contents?: Array<{
     submitted: number | string;
   }>;
 }
-interface SitemapDelta {
+export interface SitemapDelta {
   path: string;
   errorDelta: number;
   warningDelta: number;
   newErrors: number;
   newWarnings: number;
 }
-interface SitemapHealthTotals {
+export interface SitemapHealthTotals {
   totalSitemaps: number;
   totalUrls: number;
   totalErrors: number;
@@ -25,33 +25,32 @@ interface SitemapHealthTotals {
   pendingCount: number;
   indexSitemaps: number;
 }
-interface SitemapHealthDiff {
+export interface SitemapHealthDiff {
   changed: boolean;
   deltas: SitemapDelta[];
   totals: SitemapHealthTotals;
 }
-interface SitemapCollapsePolicy {
+export interface SitemapCollapsePolicy {
   ratio: number;
   minHighWater: number;
   minDrop: number;
   baselineOffset: 1 | 2;
 }
-declare const SITEMAP_SYNC_COLLAPSE_POLICY: SitemapCollapsePolicy;
-declare const SITEMAP_TRUST_COLLAPSE_POLICY: SitemapCollapsePolicy;
-type SitemapCollapseState = {
+export declare const SITEMAP_SYNC_COLLAPSE_POLICY: SitemapCollapsePolicy;
+export declare const SITEMAP_TRUST_COLLAPSE_POLICY: SitemapCollapsePolicy;
+export type SitemapCollapseState = {
   _tag: 'none';
 } | {
   _tag: 'awaiting_confirmation' | 'persisted' | 'recovered_blip';
   current: number;
   highWater: number;
 };
-interface CurrentSitemapScope {
+export interface CurrentSitemapScope {
   current: number;
   highWater: number;
   collapsed: boolean;
 }
-declare function classifySitemapCollapse(newestFirstCounts: ReadonlyArray<number | null | undefined>, policy: SitemapCollapsePolicy): SitemapCollapseState;
-declare function compareCurrentSitemapScope(newestFirstCounts: ReadonlyArray<number | null | undefined>, policy: SitemapCollapsePolicy): CurrentSitemapScope | null;
-declare function sitemapHistoryHasCollapse(newestFirstCounts: ReadonlyArray<number | null | undefined>, policy: SitemapCollapsePolicy): boolean;
-declare function diffSitemapHealth(prev: readonly SitemapHealthRow[], curr: readonly SitemapHealthInput[]): SitemapHealthDiff;
-export { CurrentSitemapScope, SITEMAP_SYNC_COLLAPSE_POLICY, SITEMAP_TRUST_COLLAPSE_POLICY, SitemapCollapsePolicy, SitemapCollapseState, SitemapDelta, SitemapHealthDiff, SitemapHealthInput, SitemapHealthRow, SitemapHealthTotals, classifySitemapCollapse, compareCurrentSitemapScope, diffSitemapHealth, sitemapHistoryHasCollapse };
+export declare function classifySitemapCollapse(newestFirstCounts: ReadonlyArray<number | null | undefined>, policy: SitemapCollapsePolicy): SitemapCollapseState;
+export declare function compareCurrentSitemapScope(newestFirstCounts: ReadonlyArray<number | null | undefined>, policy: SitemapCollapsePolicy): CurrentSitemapScope | null;
+export declare function sitemapHistoryHasCollapse(newestFirstCounts: ReadonlyArray<number | null | undefined>, policy: SitemapCollapsePolicy): boolean;
+export declare function diffSitemapHealth(prev: readonly SitemapHealthRow[], curr: readonly SitemapHealthInput[]): SitemapHealthDiff;

package/dist/source/composite.d.mts

@@ -1,6 +1,6 @@
 import { BuilderState } from "gscdump/query";
 import { AnalysisQuerySource } from "@gscdump/engine/source";
-interface SyncedRange {
+export interface SyncedRange {
   oldestDateSynced: string | null;
   newestDateSynced: string | null;
   /**
@@ -17,10 +17,9 @@ interface SyncedRange {
     end: string;
   }>;
 }
-interface CompositeSourceOptions {
+export interface CompositeSourceOptions {
   engine: AnalysisQuerySource;
   live: AnalysisQuerySource;
   site: SyncedRange;
 }
-declare function createCompositeSource(opts: CompositeSourceOptions): AnalysisQuerySource;
-export { CompositeSourceOptions, SyncedRange, createCompositeSource };
+export declare function createCompositeSource(opts: CompositeSourceOptions): AnalysisQuerySource;

package/dist/source/composite.mjs

@@ -23,7 +23,7 @@ function shouldRouteToLive(state, site) {
 	if (!startDate || !endDate) return false;
 	if (!site.oldestDateSynced || !site.newestDateSynced) return true;
 	if (startDate < site.oldestDateSynced || endDate > site.newestDateSynced) return true;
-	if (site.coveredSpans && site.coveredSpans.length > 0) return hasGapInCoveredSpans(startDate, endDate, site.coveredSpans);
+	if (site.coveredSpans) return hasGapInCoveredSpans(startDate, endDate, site.coveredSpans);
 	return false;
 }
 function createCompositeSource(opts) {

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

@@ -5,10 +5,9 @@ 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 {
+export declare const IN_MEMORY_DEFAULT_CAPABILITIES: PlannerCapabilities;
+export interface InMemoryQuerySourceOptions {
   queryRows: (state: BuilderState) => Promise<QueryRow[]> | QueryRow[];
   capabilities?: PlannerCapabilities;
 }
-declare function createInMemoryQuerySource(options: InMemoryQuerySourceOptions): AnalysisQuerySource;
-export { IN_MEMORY_DEFAULT_CAPABILITIES, InMemoryQuerySourceOptions, createInMemoryQuerySource };
+export declare function createInMemoryQuerySource(options: InMemoryQuerySourceOptions): AnalysisQuerySource;

package/dist/sql-analyzers.d.mts

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