@gscdump/analysis 1.4.0 → 1.4.2

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

@@ -0,0 +1,54 @@
+/**
+ * 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[];
+export { StrikingDistanceFilterOptions, StrikingDistanceInputRow, StrikingDistanceOptions, StrikingDistanceResult, analyzeStrikingDistance };

package/dist/analyzers/striking-distance.mjs

@@ -0,0 +1,82 @@
+import { queriesQueryState } from "../analyzer/adapt-rows.mjs";
+import { paginateSortedInMemory } from "../analyzer/paginate.mjs";
+import { defineAnalyzer } from "@gscdump/engine/analyzer";
+import { periodOf } from "@gscdump/engine/period";
+import { enumeratePartitions } from "@gscdump/engine/planner";
+import { num } from "@gscdump/engine/analysis-types";
+const DEFAULT_ROW_LIMIT = 25e3;
+function paginateStrikingDistance(results, options) {
+	return paginateSortedInMemory(results, {
+		limit: options.limit ?? 1e3,
+		offset: options.offset
+	}, (left, right) => right.potentialClicks - left.potentialClicks);
+}
+function filterStrikingDistance(rows, options = {}) {
+	const minPosition = options.minPosition ?? 4;
+	const maxPosition = options.maxPosition ?? 20;
+	const minImpressions = options.minImpressions ?? 100;
+	const maxCtr = options.maxCtr ?? .05;
+	const results = [];
+	for (const row of rows) {
+		const position = num(row.position);
+		const impressions = num(row.impressions);
+		const ctr = num(row.ctr);
+		const clicks = num(row.clicks);
+		if (position < minPosition || position > maxPosition) continue;
+		if (impressions < minImpressions) continue;
+		if (ctr > maxCtr) continue;
+		results.push({
+			keyword: String(row.query ?? ""),
+			page: row.page == null ? null : String(row.page),
+			clicks,
+			impressions,
+			ctr,
+			position,
+			potentialClicks: Math.round(impressions * .15)
+		});
+	}
+	return results;
+}
+function analyzeStrikingDistance(rows, options = {}) {
+	return paginateStrikingDistance(filterStrikingDistance(rows, options), options);
+}
+const strikingDistanceAnalyzer = defineAnalyzer({
+	id: "striking-distance",
+	reduce(rows, params) {
+		const results = filterStrikingDistance(Array.isArray(rows) ? rows : [], params);
+		const paged = paginateStrikingDistance(results, params);
+		return {
+			results: paged,
+			meta: {
+				total: results.length,
+				returned: paged.length
+			}
+		};
+	},
+	buildSql(params) {
+		const { startDate, endDate } = periodOf(params);
+		return {
+			sql: `
+    SELECT
+      query,
+      url AS page,
+      CAST(SUM(clicks) AS DOUBLE) AS clicks,
+      CAST(SUM(impressions) AS DOUBLE) AS impressions,
+      CAST(SUM(clicks) AS DOUBLE) / NULLIF(SUM(impressions), 0) AS ctr,
+      SUM(sum_position) / NULLIF(SUM(impressions), 0) + 1 AS position
+    FROM read_parquet({{FILES}}, union_by_name = true)
+    WHERE date >= ? AND date <= ?
+    GROUP BY query, url
+  `,
+			params: [startDate, endDate],
+			current: {
+				table: "page_queries",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	buildRows(params) {
+		return { queries: queriesQueryState(periodOf(params), params.limit ?? DEFAULT_ROW_LIMIT) };
+	}
+});
+export { analyzeStrikingDistance, filterStrikingDistance, strikingDistanceAnalyzer };

package/dist/analyzers/survival.mjs

@@ -0,0 +1,200 @@
+import { parseJsonRows, rowString } from "../analyzer/row-values.mjs";
+import { defineAnalyzer } from "@gscdump/engine/analyzer";
+import { defaultEndDate } from "@gscdump/engine/period";
+import { enumeratePartitions } from "@gscdump/engine/planner";
+import { METRIC_EXPR } from "@gscdump/engine/sql-fragments";
+import { num } from "@gscdump/engine/analysis-types";
+import { MS_PER_DAY, daysAgoUtc } from "gscdump/dates";
+const survivalAnalyzer = defineAnalyzer({
+	id: "survival",
+	buildSql(params) {
+		const endDate = params.endDate ?? defaultEndDate();
+		const startDate = params.startDate ?? daysAgoUtc(183);
+		const minImpressions = params.minImpressions ?? 5;
+		return {
+			sql: `
+    WITH daily AS (
+      SELECT
+        query,
+        url,
+        date,
+        ${METRIC_EXPR.clicks} AS day_clicks,
+        ${METRIC_EXPR.impressions} AS day_impressions,
+        ${METRIC_EXPR.position} AS day_position
+      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, date
+      HAVING SUM(impressions) >= ?
+    ),
+    classified AS (
+      SELECT *,
+        (day_position <= 10) AS in_top10
+      FROM daily
+    ),
+    transitions AS (
+      SELECT *,
+        CASE
+          WHEN in_top10 AND (LAG(in_top10) OVER w IS NULL OR NOT LAG(in_top10) OVER w)
+            THEN 1 ELSE 0
+        END AS is_entry
+      FROM classified
+      WINDOW w AS (PARTITION BY query, url ORDER BY date)
+    ),
+    run_ids AS (
+      SELECT *,
+        SUM(is_entry) OVER (PARTITION BY query, url ORDER BY date) AS run_id
+      FROM transitions
+      WHERE in_top10
+    ),
+    window_bounds AS (
+      SELECT MIN(date) AS window_start, MAX(date) AS window_end FROM daily
+    ),
+    episodes_raw AS (
+      SELECT
+        query, url, run_id,
+        MIN(date) AS entry_date,
+        MAX(date) AS exit_date,
+        DATEDIFF('day', MIN(date), MAX(date)) + 1 AS tenure
+      FROM run_ids
+      GROUP BY query, url, run_id
+    ),
+    episodes AS (
+      SELECT
+        e.query, e.url, e.run_id, e.entry_date, e.exit_date, e.tenure,
+        (e.exit_date >= wb.window_end - INTERVAL 2 DAY) AS censored,
+        CASE
+          WHEN regexp_extract(e.url, '^(?:https?://[^/]+)?(/[^/?#]*)', 1) = '/' OR e.url = '/'
+            THEN 'home'
+          WHEN regexp_extract(e.url, '^(?:https?://[^/]+)?/([^/?#]+)', 1) = ''
+            THEN 'home'
+          ELSE regexp_extract(e.url, '^(?:https?://[^/]+)?/([^/?#]+)', 1)
+        END AS cohort
+      FROM episodes_raw e
+      CROSS JOIN window_bounds wb
+    ),
+    episodes_all AS (
+      SELECT query, url, tenure, censored, cohort FROM episodes
+      UNION ALL
+      SELECT query, url, tenure, censored, '__all__' AS cohort FROM episodes
+    ),
+    cohort_totals AS (
+      SELECT cohort, COUNT(*) AS n_total
+      FROM episodes_all
+      GROUP BY cohort
+    ),
+    events AS (
+      SELECT
+        cohort,
+        tenure,
+        COUNT(*) FILTER (WHERE NOT censored) AS d_t,
+        COUNT(*) AS n_ending_at_t
+      FROM episodes_all
+      GROUP BY cohort, tenure
+    ),
+    km AS (
+      SELECT
+        e.cohort,
+        e.tenure,
+        e.d_t,
+        e.n_ending_at_t,
+        SUM(e.n_ending_at_t) OVER (PARTITION BY e.cohort ORDER BY e.tenure DESC
+          ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS at_risk
+      FROM events e
+    ),
+    km_surv AS (
+      SELECT
+        cohort, tenure, d_t, at_risk,
+        EXP(SUM(LN(GREATEST(1.0 - CAST(d_t AS DOUBLE) / NULLIF(at_risk, 0), 1e-9)))
+          OVER (PARTITION BY cohort ORDER BY tenure
+            ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)) AS survival
+      FROM km
+    ),
+    curve_agg AS (
+      SELECT
+        cohort,
+        to_json(list({
+          'tenure': tenure,
+          'survival': survival,
+          'atRisk': at_risk,
+          'events': d_t
+        } ORDER BY tenure)) AS curveJson
+      FROM km_surv
+      GROUP BY cohort
+    ),
+    cohort_stats AS (
+      SELECT
+        ea.cohort,
+        COUNT(*) AS episode_count,
+        AVG(CASE WHEN ea.censored THEN 1.0 ELSE 0.0 END) AS censoring_rate
+      FROM episodes_all ea
+      GROUP BY ea.cohort
+    )
+    SELECT
+      cs.cohort,
+      cs.episode_count AS episodeCount,
+      cs.censoring_rate AS censoringRate,
+      ca.curveJson
+    FROM cohort_stats cs
+    LEFT JOIN curve_agg ca USING (cohort)
+    ORDER BY cs.cohort
+  `,
+			params: [
+				startDate,
+				endDate,
+				minImpressions
+			],
+			current: {
+				table: "page_queries",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const endDate = params.endDate ?? defaultEndDate();
+		const startDate = params.startDate ?? daysAgoUtc(183);
+		const windowDays = Math.round((new Date(endDate).getTime() - new Date(startDate).getTime()) / MS_PER_DAY) + 1;
+		const results = arr.map((r) => {
+			const curve = parseJsonRows(r.curveJson).map((p) => ({
+				tenure: num(p.tenure),
+				survival: num(p.survival),
+				atRisk: num(p.atRisk),
+				events: num(p.events)
+			}));
+			let medianTenure = 0;
+			for (let i = 0; i < curve.length; i++) {
+				const cur = curve[i];
+				if (cur.survival <= .5) {
+					if (i === 0) medianTenure = cur.tenure;
+					else {
+						const prev = curve[i - 1];
+						const span = prev.survival - cur.survival;
+						const frac = span > 0 ? (prev.survival - .5) / span : 0;
+						medianTenure = prev.tenure + frac * (cur.tenure - prev.tenure);
+					}
+					break;
+				}
+			}
+			const last = curve[curve.length - 1];
+			if (medianTenure === 0 && last && last.survival > .5) medianTenure = last.tenure;
+			return {
+				cohort: rowString(r.cohort),
+				episodeCount: num(r.episodeCount),
+				censoringRate: num(r.censoringRate),
+				medianTenure,
+				curve
+			};
+		});
+		return {
+			results,
+			meta: {
+				totalEpisodes: results.find((r) => r.cohort === "__all__")?.episodeCount ?? 0,
+				cohortCount: results.filter((r) => r.cohort !== "__all__").length,
+				windowDays
+			}
+		};
+	}
+});
+export { survivalAnalyzer };

package/dist/analyzers/trends.mjs

@@ -0,0 +1,156 @@
+import { parseJsonRows, rowString } from "../analyzer/row-values.mjs";
+import { defineAnalyzer } from "@gscdump/engine/analyzer";
+import { defaultEndDate } from "@gscdump/engine/period";
+import { enumeratePartitions } from "@gscdump/engine/planner";
+import { METRIC_EXPR } from "@gscdump/engine/sql-fragments";
+import { num } from "@gscdump/engine/analysis-types";
+import { MS_PER_DAY, toIsoDate } from "gscdump/dates";
+const trendsAnalyzer = defineAnalyzer({
+	id: "trends",
+	buildSql(params) {
+		const weeks = params.weeks ?? 28;
+		const endDate = params.endDate || defaultEndDate();
+		const startDate = params.startDate || toIsoDate(/* @__PURE__ */ new Date(Date.parse(endDate) - (weeks * 7 - 1) * MS_PER_DAY));
+		const minImpressions = params.minImpressions ?? 100;
+		const minWeeksWithData = params.minWeeksWithData ?? Math.max(2, Math.floor(weeks / 4));
+		const limit = params.limit ?? 500;
+		const dim = params.dimension === "keywords" ? "keywords" : "pages";
+		const table = dim === "keywords" ? "queries" : "pages";
+		return {
+			sql: `
+    WITH bucketed AS (
+      SELECT
+        ${dim === "keywords" ? "query" : "url"} AS entity,
+        date_trunc('week', CAST(date AS DATE)) AS week,
+        ${METRIC_EXPR.clicks} AS clicks,
+        ${METRIC_EXPR.impressions} AS impressions,
+        SUM(sum_position) AS sum_position_sum
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ?
+      GROUP BY entity, week
+    ),
+    with_meta AS (
+      SELECT
+        entity, week, clicks, impressions, sum_position_sum,
+        ROW_NUMBER() OVER (PARTITION BY entity ORDER BY week) - 1 AS week_idx,
+        COUNT(*) OVER (PARTITION BY entity) AS n_weeks,
+        (ROW_NUMBER() OVER (PARTITION BY entity ORDER BY week) - 1)
+          < (COUNT(*) OVER (PARTITION BY entity) / 2) AS is_first_half
+      FROM bucketed
+    ),
+    agg AS (
+      SELECT
+        entity,
+        SUM(clicks) AS totalClicks,
+        SUM(impressions) AS totalImpressions,
+        any_value(n_weeks) AS weeksWithData,
+        COALESCE(regr_slope(clicks, CAST(week_idx AS DOUBLE)), 0.0) AS slope,
+        SUM(CASE WHEN is_first_half THEN clicks ELSE 0 END) AS firstHalfClicks,
+        SUM(CASE WHEN NOT is_first_half THEN clicks ELSE 0 END) AS secondHalfClicks,
+        SUM(sum_position_sum) / NULLIF(SUM(impressions), 0) + 1 AS avgPosition,
+        to_json(list({
+          'week': strftime(week, '%Y-%m-%d'),
+          'clicks': clicks,
+          'impressions': impressions
+        } ORDER BY week)) AS seriesJson
+      FROM with_meta
+      GROUP BY entity
+      HAVING SUM(impressions) >= ? AND any_value(n_weeks) >= ?
+    ),
+    classified AS (
+      SELECT
+        *,
+        CASE
+          WHEN firstHalfClicks = 0 AND secondHalfClicks > 0 THEN 10.0
+          WHEN firstHalfClicks = 0 THEN 1.0
+          ELSE secondHalfClicks / firstHalfClicks
+        END AS growthRatio
+      FROM agg
+    )
+    SELECT
+      entity,
+      totalClicks,
+      totalImpressions,
+      weeksWithData,
+      slope,
+      growthRatio,
+      avgPosition,
+      CASE
+        WHEN growthRatio >= 1.5 AND slope > 0 THEN 'accelerating'
+        WHEN growthRatio >= 1.1 AND slope >= 0 THEN 'growing'
+        WHEN growthRatio < 0.5 THEN 'cratering'
+        WHEN growthRatio < 0.9 AND slope < 0 THEN 'declining'
+        ELSE 'steady'
+      END AS trend,
+      seriesJson
+    FROM classified
+    ORDER BY
+      CASE
+        WHEN growthRatio >= 1.5 AND slope > 0 THEN 0
+        WHEN growthRatio < 0.5 THEN 1
+        WHEN growthRatio >= 1.1 AND slope >= 0 THEN 2
+        WHEN growthRatio < 0.9 AND slope < 0 THEN 3
+        ELSE 4
+      END,
+      ABS(growthRatio - 1) DESC,
+      totalClicks DESC
+    LIMIT ${Number(limit)}
+  `,
+			params: [
+				startDate,
+				endDate,
+				minImpressions,
+				minWeeksWithData
+			],
+			current: {
+				table,
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const weeks = params.weeks ?? 28;
+		const endDate = params.endDate || defaultEndDate();
+		const startDate = params.startDate || toIsoDate(/* @__PURE__ */ new Date(Date.parse(endDate) - (weeks * 7 - 1) * MS_PER_DAY));
+		const dim = params.dimension === "keywords" ? "keywords" : "pages";
+		const results = arr.map((r) => {
+			const series = parseJsonRows(r.seriesJson).map((s) => ({
+				week: rowString(s.week),
+				clicks: num(s.clicks),
+				impressions: num(s.impressions)
+			}));
+			return {
+				[dim === "keywords" ? "query" : "page"]: rowString(r.entity),
+				totalClicks: num(r.totalClicks),
+				totalImpressions: num(r.totalImpressions),
+				weeksWithData: num(r.weeksWithData),
+				slope: num(r.slope),
+				growthRatio: num(r.growthRatio),
+				avgPosition: num(r.avgPosition),
+				trend: rowString(r.trend),
+				series
+			};
+		});
+		const counts = {
+			accelerating: 0,
+			growing: 0,
+			steady: 0,
+			declining: 0,
+			cratering: 0
+		};
+		for (const r of results) counts[r.trend] = (counts[r.trend] ?? 0) + 1;
+		return {
+			results,
+			meta: {
+				total: results.length,
+				dimension: dim,
+				weeks: Number(weeks),
+				startDate,
+				endDate,
+				counts
+			}
+		};
+	}
+});
+export { trendsAnalyzer };

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

@@ -0,0 +1,17 @@
+import { QueryPageRow } from "../types.mjs";
+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[];
+export { ZeroClickOptions, ZeroClickResult, analyzeZeroClick };

package/dist/analyzers/zero-click.mjs

@@ -0,0 +1,122 @@
+import { paginateClause, paginateSortedInMemory } from "../analyzer/paginate.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";
+import { num } from "@gscdump/engine/analysis-types";
+import { between, date, gsc, page, query } from "gscdump/query";
+const DEFAULT_ROW_LIMIT = 25e3;
+function analyzeZeroClick(rows, options = {}) {
+	const minImpressions = options.minImpressions ?? 1e3;
+	const maxCtr = options.maxCtr ?? .03;
+	const maxPosition = options.maxPosition ?? 10;
+	const queryMap = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		if (row.impressions < minImpressions || row.position > maxPosition || row.ctr > maxCtr) continue;
+		const existing = queryMap.get(row.query);
+		if (!existing || row.position < existing.position) queryMap.set(row.query, { ...row });
+	}
+	return [...queryMap.values()].sort((left, right) => right.impressions - left.impressions);
+}
+const zeroClickAnalyzer = defineAnalyzer({
+	id: "zero-click",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf(params);
+		const minImpressions = params.minImpressions ?? 1e3;
+		const maxCtr = params.maxCtr ?? .03;
+		const maxPosition = params.maxPosition ?? 10;
+		const limit = params.limit ?? 1e3;
+		return {
+			sql: `
+      WITH agg AS (
+        SELECT
+          query,
+          url AS page,
+          ${METRIC_EXPR.clicks} AS clicks,
+          ${METRIC_EXPR.impressions} AS impressions,
+          ${METRIC_EXPR.ctr} AS ctr,
+          ${METRIC_EXPR.position} AS position
+        FROM read_parquet({{FILES}}, union_by_name = true)
+        WHERE date >= ? AND date <= ?
+        GROUP BY query, url
+        HAVING SUM(impressions) >= ?
+      )
+      SELECT
+        query, page, clicks, impressions, ctr, position,
+        CAST(GREATEST(0, ROUND(impressions * (
+          CASE
+            WHEN position <= 1 THEN 0.30
+            WHEN position <= 3 THEN 0.15
+            WHEN position <= 5 THEN 0.08
+            ELSE 0.04
+          END
+        )) - clicks) AS DOUBLE) AS missedClicks
+      FROM agg
+      WHERE position <= ? AND ctr < ?
+      ORDER BY impressions DESC
+      ${paginateClause({
+				limit,
+				offset: params.offset
+			})}
+    `,
+			params: [
+				startDate,
+				endDate,
+				minImpressions,
+				maxPosition,
+				maxCtr
+			],
+			current: {
+				table: "page_queries",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const minImpressions = params.minImpressions ?? 1e3;
+		const maxCtr = params.maxCtr ?? .03;
+		const maxPosition = params.maxPosition ?? 10;
+		return {
+			results: arr.map((r) => ({
+				query: r.query == null ? "" : String(r.query),
+				page: r.page == null ? "" : String(r.page),
+				clicks: num(r.clicks),
+				impressions: num(r.impressions),
+				ctr: num(r.ctr),
+				position: num(r.position),
+				missedClicks: num(r.missedClicks)
+			})),
+			meta: {
+				total: arr.length,
+				minImpressions,
+				maxCtr,
+				maxPosition
+			}
+		};
+	},
+	buildRows(params) {
+		const period = periodOf(params);
+		const limit = params.limit ?? DEFAULT_ROW_LIMIT;
+		return { rows: gsc.select(query, page).where(between(date, period.startDate, period.endDate)).limit(limit).getState() };
+	},
+	reduceRows(rows, params) {
+		const results = analyzeZeroClick(Array.isArray(rows) ? rows : [], {
+			minImpressions: params.minImpressions ?? 1e3,
+			maxCtr: params.maxCtr ?? .03,
+			maxPosition: params.maxPosition ?? 10
+		});
+		const paged = paginateSortedInMemory(results, {
+			limit: params.limit,
+			offset: params.offset
+		}, (left, right) => right.impressions - left.impressions);
+		return {
+			results: paged,
+			meta: {
+				total: results.length,
+				returned: paged.length
+			}
+		};
+	}
+});
+export { analyzeZeroClick, zeroClickAnalyzer };

package/dist/browser.d.mts

@@ -0,0 +1,5 @@
+import { AnalyzerRegistry } from "@gscdump/engine/analyzer";
+import { AnalysisParams, AnalysisResult } from "@gscdump/engine/analysis-types";
+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 };

package/dist/browser.mjs

@@ -0,0 +1,11 @@
+import { runAnalyzerFromSource } from "@gscdump/engine/analyzer";
+import { pgResolverAdapter } from "@gscdump/engine/resolver";
+import { createAttachedTableSource } from "@gscdump/engine/source";
+async function analyzeInBrowser(runner, opts, params, registry) {
+	opts.signal?.throwIfAborted();
+	return runAnalyzerFromSource(createAttachedTableSource(runner, {
+		adapter: pgResolverAdapter,
+		...opts
+	}), params, registry);
+}
+export { analyzeInBrowser };

package/dist/default-registry.d.mts

@@ -1,2 +1,4 @@
-import { ROW_ANALYZERS, SQL_ANALYZERS, defaultAnalyzerRegistry } from "./_chunks/default-registry.mjs";
+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 };

package/dist/default-registry.mjs

@@ -1,2 +1,6 @@
-import { ROW_ANALYZERS, SQL_ANALYZERS, defaultAnalyzerRegistry } from "./_chunks/default-registry.mjs";
+import { ALL_ANALYZERS } from "./analyzer/all.mjs";
+import { ROW_ANALYZERS } from "./analyzer/row-analyzers.mjs";
+import { SQL_ANALYZERS } from "./sql-analyzers.mjs";
+import { createAnalyzerRegistry } from "@gscdump/engine/analyzer";
+const defaultAnalyzerRegistry = createAnalyzerRegistry({ defined: ALL_ANALYZERS });
 export { ROW_ANALYZERS, SQL_ANALYZERS, defaultAnalyzerRegistry };