@gscdump/engine 0.23.1 → 0.23.2

package/dist/_chunks/index.d.mts

@@ -1,57 +1,111 @@
-import { AnalysisParams } from "./analysis-types.mjs";
-type WindowPreset = 'last-7d' | 'last-28d' | 'last-30d' | 'last-90d' | 'last-180d' | 'last-365d' | 'mtd' | 'ytd' | 'custom';
-type ComparisonMode = 'none' | 'prev-period' | 'yoy';
-interface ResolveWindowOptions {
-  preset: WindowPreset;
-  comparison?: ComparisonMode;
-  anchor?: string;
-  start?: string;
-  end?: string;
+import { Row, SearchType as SearchType$1, StorageEngine, TenantCtx } from "./storage.mjs";
+import { AnalysisParams, AnalysisResult } from "./analysis-types.mjs";
+import { ResolverAdapter } from "./types.mjs";
+import { AnalysisQuerySource, AnalysisSourceKind, AnalyzerRegistry, FileSet, QueryRow, SourceCapabilities } from "./registry.mjs";
+import { PlannerCapabilities } from "gscdump/query/plan";
+import { BuilderState } from "gscdump/query";
+interface AttachedTableRunner {
+  /**
+   * Run a query with positional (`?`) bound parameters. Return objects keyed
+   * by column name. BIGINT → number coercion is applied by the source factory
+   * (see `coerceRows`); runners only need to handle DATE → ISO string (or
+   * let the analyzer reducer normalize via `num(v)`/`str(v)`).
+   */
+  query: (sql: string, params?: unknown[], signal?: AbortSignal) => Promise<Row[]>;
 }
-interface ResolvedWindow {
-  start: string;
-  end: string;
-  days: number;
-  comparison?: {
-    start: string;
-    end: string;
-  };
+interface AttachedTableSourceOptions {
+  /** Schema name the exported DuckDB file was attached under — e.g. `gsc`. */
+  schema: string;
+  /**
+   * Abort in-flight queries when the caller no longer cares about the
+   * result. Every `runner.query` call receives the same signal.
+   */
+  signal?: AbortSignal;
+  /**
+   * List of table names actually attached to this connection. When provided,
+   * `executeSql` short-circuits with a specific "table not attached" error
+   * if the SQL plan references a table that isn't in this list — letting
+   * callers (e.g. the analytics layer) route to cloud fallback without
+   * paying the SQL execution cost. Omit to disable the check.
+   */
+  attachedTables?: readonly string[];
+  /**
+   * Dialect adapter surfaced on the source for analyzers that compose SQL
+   * from a `BuilderState` at plan-build time (e.g. `data-query`,
+   * `data-detail`). Attached-table sources execute pg-flavored DuckDB SQL,
+   * so callers should pass `pgResolverAdapter` here.
+   */
+  adapter?: ResolverAdapter<any>;
 }
-interface AnalysisPeriod {
-  startDate: string;
-  endDate: string;
+declare class AttachedTableMissingError extends Error {
+  readonly missing: readonly string[];
+  constructor(missing: readonly string[]);
 }
-interface ComparisonPeriod {
-  current: AnalysisPeriod;
-  previous: AnalysisPeriod;
+/**
+ * Swap `read_parquet({{KEY}}, union_by_name = true)` for `<schema>.<table>`.
+ * Tolerates whitespace variation. Preserves the rest of the SQL verbatim.
+ */
+declare function rewriteForTableSource(sql: string, schema: string, fileSets: Record<string, FileSet>): string;
+declare function createAttachedTableSource(runner: AttachedTableRunner, options: AttachedTableSourceOptions): AnalysisQuerySource;
+interface CreateSqlQuerySourceOptions<TKey extends string> {
+  /** Debug-only identifier surfaced on the source for error messages. */
+  name: string;
+  /** Telemetry tag stamped onto analyzer result meta. */
+  kind?: AnalysisSourceKind;
+  /** Dialect-specific adapter; compiles `BuilderState` → `{ sql, params }`. */
+  adapter: ResolverAdapter<TKey>;
+  /** Drives the underlying DB. Called for both typed queries and raw SQL. */
+  execute: (sql: string, params: unknown[]) => Promise<QueryRow[]>;
+  /** Tenant id for multi-tenant dialects; forwarded to `resolveToSQL`. */
+  siteId?: string | number;
+  /** Search-type scope for multi-tenant dialects; forwarded to `resolveToSQL`. */
+  searchType?: string;
+  /** Additional capability flags merged on top of `adapter.capabilities`. */
+  extraCapabilities?: Partial<SourceCapabilities>;
 }
-declare function defaultEndDate(): string;
-declare function defaultStartDate(): string;
-declare function periodOf(params: AnalysisParams): AnalysisPeriod;
-declare function comparisonOf(params: AnalysisParams): ComparisonPeriod;
-declare function resolveWindow(opts: ResolveWindowOptions): ResolvedWindow;
-/** Convert a ResolvedWindow into the AnalysisPeriod / ComparisonPeriod shape. */
-declare function windowToPeriod(w: ResolvedWindow): AnalysisPeriod;
-declare function windowToComparisonPeriod(w: ResolvedWindow): ComparisonPeriod | undefined;
-interface PadTimeseriesOptions<T> {
-  /** ISO date (YYYY-MM-DD), inclusive lower bound. */
-  startDate: string;
-  /** ISO date (YYYY-MM-DD), inclusive upper bound. */
-  endDate: string;
+declare function createSqlQuerySource<TKey extends string>(options: CreateSqlQuerySourceOptions<TKey>): AnalysisQuerySource;
+/**
+ * Capabilities the engine query path honors. Matches what the DuckDB compiler
+ * passes to `buildLogicalPlan`: regex pushes down; comparison joins and
+ * multi-dataset queries belong to the analyzer dispatcher, not the engine's
+ * builder-state query path.
+ */
+declare const ENGINE_QUERY_CAPABILITIES: PlannerCapabilities;
+interface EngineQuerySourceOptions {
+  engine: StorageEngine;
+  ctx: TenantCtx;
   /**
-   * Row to insert for missing dates. Defaults to `{ clicks: 0, impressions: 0, ctr: 0, position: 0 }`.
-   * The `date` field is set automatically.
+   * Restrict every manifest lookup the source performs to a single search-type
+   * slice. Threads into `engine.query` and `engine.runSQL` so the wrapped
+   * source returns rows from one cohort instead of unioning web + non-web
+   * parquet. Undefined preserves legacy cross-type behaviour for web-only
+   * tenants and admin paths.
    */
-  fill?: Omit<T, 'date'>;
-  /** Row-field that carries the ISO date. Defaults to `date`. */
-  dateKey?: string;
+  searchType?: SearchType$1;
 }
-type DateRowShape = Record<string, unknown> & {
-  date?: unknown;
-};
 /**
- * Pad rows so every calendar day in `[startDate, endDate]` appears at least
- * once. Existing dates keep all their rows (grouped timeseries safe).
+ * Wraps a storage engine as an `AnalysisQuerySource` with SQL execution.
+ * `queryRows` runs typed builder-state queries; `executeSql` delegates to
+ * `engine.runSQL` and requires `opts.fileSets` (with a `FILES` entry so the
+ * target table can be resolved for partition lookup).
  */
-declare function padTimeseries<T extends DateRowShape = DateRowShape>(rows: readonly T[], options: PadTimeseriesOptions<T>): T[];
-export { AnalysisPeriod, ComparisonMode, ComparisonPeriod, PadTimeseriesOptions, ResolveWindowOptions, ResolvedWindow, WindowPreset, comparisonOf, defaultEndDate, defaultStartDate, padTimeseries, periodOf, resolveWindow, windowToComparisonPeriod, windowToPeriod };
+declare function createEngineQuerySource(options: EngineQuerySourceOptions): AnalysisQuerySource;
+/**
+ * Convenience: wrap a storage engine + tenant ctx in a source and dispatch.
+ * Equivalent to wrapping `createEngineQuerySource`, with omitted searchType
+ * defaulted to web at this public helper boundary.
+ */
+declare function runAnalyzerWithEngine(deps: {
+  engine: StorageEngine;
+}, ctx: TenantCtx, params: AnalysisParams, registry: AnalyzerRegistry): Promise<AnalysisResult>;
+interface TypedQuery<TRow> {
+  state: BuilderState;
+  readonly __row?: TRow;
+}
+declare function typedQuery<TRow>(state: BuilderState): TypedQuery<TRow>;
+declare function queryRows<TRow = QueryRow>(source: AnalysisQuerySource, query: BuilderState | TypedQuery<TRow>): Promise<TRow[]>;
+declare function queryComparisonRows<TRow = QueryRow>(source: AnalysisQuerySource, current: BuilderState | TypedQuery<TRow>, previous: BuilderState | TypedQuery<TRow>): Promise<{
+  current: TRow[];
+  previous: TRow[];
+}>;
+export { AttachedTableMissingError, AttachedTableRunner, AttachedTableSourceOptions, CreateSqlQuerySourceOptions, ENGINE_QUERY_CAPABILITIES, EngineQuerySourceOptions, TypedQuery, createAttachedTableSource, createEngineQuerySource, createSqlQuerySource, queryComparisonRows, queryRows, rewriteForTableSource, runAnalyzerWithEngine, typedQuery };

package/dist/_chunks/index2.d.mts

@@ -0,0 +1,57 @@
+import { AnalysisParams } from "./analysis-types.mjs";
+type WindowPreset = 'last-7d' | 'last-28d' | 'last-30d' | 'last-90d' | 'last-180d' | 'last-365d' | 'mtd' | 'ytd' | 'custom';
+type ComparisonMode = 'none' | 'prev-period' | 'yoy';
+interface ResolveWindowOptions {
+  preset: WindowPreset;
+  comparison?: ComparisonMode;
+  anchor?: string;
+  start?: string;
+  end?: string;
+}
+interface ResolvedWindow {
+  start: string;
+  end: string;
+  days: number;
+  comparison?: {
+    start: string;
+    end: string;
+  };
+}
+interface AnalysisPeriod {
+  startDate: string;
+  endDate: string;
+}
+interface ComparisonPeriod {
+  current: AnalysisPeriod;
+  previous: AnalysisPeriod;
+}
+declare function defaultEndDate(): string;
+declare function defaultStartDate(): string;
+declare function periodOf(params: AnalysisParams): AnalysisPeriod;
+declare function comparisonOf(params: AnalysisParams): ComparisonPeriod;
+declare function resolveWindow(opts: ResolveWindowOptions): ResolvedWindow;
+/** Convert a ResolvedWindow into the AnalysisPeriod / ComparisonPeriod shape. */
+declare function windowToPeriod(w: ResolvedWindow): AnalysisPeriod;
+declare function windowToComparisonPeriod(w: ResolvedWindow): ComparisonPeriod | undefined;
+interface PadTimeseriesOptions<T> {
+  /** ISO date (YYYY-MM-DD), inclusive lower bound. */
+  startDate: string;
+  /** ISO date (YYYY-MM-DD), inclusive upper bound. */
+  endDate: string;
+  /**
+   * Row to insert for missing dates. Defaults to `{ clicks: 0, impressions: 0, ctr: 0, position: 0 }`.
+   * The `date` field is set automatically.
+   */
+  fill?: Omit<T, 'date'>;
+  /** Row-field that carries the ISO date. Defaults to `date`. */
+  dateKey?: string;
+}
+type DateRowShape = Record<string, unknown> & {
+  date?: unknown;
+};
+/**
+ * Pad rows so every calendar day in `[startDate, endDate]` appears at least
+ * once. Existing dates keep all their rows (grouped timeseries safe).
+ */
+declare function padTimeseries<T extends DateRowShape = DateRowShape>(rows: readonly T[], options: PadTimeseriesOptions<T>): T[];
+export { AnalysisPeriod, ComparisonMode, ComparisonPeriod, PadTimeseriesOptions, ResolveWindowOptions, ResolvedWindow, WindowPreset, comparisonOf, defaultEndDate, defaultStartDate, padTimeseries, periodOf, resolveWindow, windowToComparisonPeriod, windowToPeriod };

package/dist/_chunks/pg-adapter.d.mts

@@ -0,0 +1,28 @@
+import { ResolverAdapter } from "./types.mjs";
+import { TableName } from "@gscdump/contracts";
+type PgTableKey = TableName;
+declare const pgResolverAdapter: ResolverAdapter<PgTableKey>;
+/**
+ * Parquet-aware variant of {@link pgResolverAdapter}. Identical SQL output
+ * except FROM clauses emit `read_parquet({{FILES}}, union_by_name = true) AS
+ * "${tk}"`. The runSQL pipeline substitutes `{{FILES}}` with R2 object keys
+ * resolved from the manifest. The `AS "${tk}"` alias is mandatory — drizzle
+ * compiles `colRef` to table-qualified `"pages"."url"`, which would not
+ * resolve against an unaliased FROM.
+ *
+ * Single-use: build a fresh adapter per query. Cheap (no I/O) and avoids
+ * accidental adapter caching that would lock in a stale `{{FILES}}` set.
+ */
+declare function createParquetResolverAdapter(): ResolverAdapter<PgTableKey>;
+/**
+ * Multi-tenant pg-flavored adapter for the Iceberg / R2 SQL read path.
+ * Identical SQL output to `pgResolverAdapter` except WHERE clauses inject
+ * `site_id = ?` AND `search_type = ?` automatically when those scopes are
+ * passed to `resolveToSQL`. Required for the Iceberg fact tables which are
+ * shared across tenants — querying without these predicates would leak
+ * cross-tenant data. Single-use: the adapter has no `tableRef` override,
+ * so callers must rewrite bare table names to their qualified form (e.g.
+ * `${namespace}.pages`) before sending to R2 SQL.
+ */
+declare function createIcebergResolverAdapter(): ResolverAdapter<PgTableKey>;
+export { PgTableKey, createIcebergResolverAdapter, createParquetResolverAdapter, pgResolverAdapter };

package/dist/_chunks/resolver.mjs

@@ -2,7 +2,7 @@ import { SCHEMAS, drizzleSchema } from "./schema.mjs";
 import { enumeratePartitions } from "./parquet-plan.mjs";
 import { escapeLike } from "../sql-fragments.mjs";
 import "../planner.mjs";
-import { PgDialect } from "drizzle-orm/pg-core";
+import { PgDialect, pgTable, varchar } from "drizzle-orm/pg-core";
 import { UnresolvableDatasetError, buildLogicalComparisonPlan, buildLogicalPlan, inferDataset as inferLogicalDataset, isDatasetResolvable } from "gscdump/query/plan";
 import { normalizeUrl } from "gscdump/normalize";
 import { sql } from "drizzle-orm";
@@ -180,7 +180,7 @@ function buildDimensionColumnMap(datasetToTableKey) {
 	return Object.fromEntries(entries);
 }
 function createSqlFragments(config) {
-	const { schema, datasetToTableKey, metricCast, regexPredicate, tableLabel, includeSiteId, urlToPathExpr: urlToPathExprOverride, tableRef: tableRefOverride } = config;
+	const { schema, datasetToTableKey, metricCast, regexPredicate, tableLabel, includeSiteId, includeSearchType, urlToPathExpr: urlToPathExprOverride, tableRef: tableRefOverride } = config;
 	const DIM_COLUMN_MAP = buildDimensionColumnMap(datasetToTableKey);
 	function isMetricDimension(dim) {
 		return METRIC_NAMES.includes(dim);
@@ -211,6 +211,9 @@ function createSqlFragments(config) {
 	function siteIdColRef(tableKey) {
 		return colRef(tableKey, "site_id");
 	}
+	function searchTypeColRef(tableKey) {
+		return colRef(tableKey, "search_type");
+	}
 	function dimExprSql(dim, tableKey) {
 		const colName = dimColumn(dim, tableKey);
 		if (dim === "page") return sql.raw(urlToPathExpr(colName));
@@ -335,6 +338,7 @@ function createSqlFragments(config) {
 		tableRef,
 		dateColRef,
 		siteIdColRef: includeSiteId ? siteIdColRef : void 0,
+		searchTypeColRef: includeSearchType ? searchTypeColRef : void 0,
 		dimExprSql,
 		metricSql,
 		havingPredicates,
@@ -357,6 +361,7 @@ function createResolverAdapter(config) {
 		dateColRef: runtime.dateColRef,
 		urlToPathExpr: runtime.urlToPathExpr,
 		siteIdColRef: runtime.siteIdColRef,
+		searchTypeColRef: runtime.searchTypeColRef,
 		dimExprSql: runtime.dimExprSql,
 		metricSql: runtime.metricSql,
 		dimensionPredicates: runtime.dimensionPredicates,
@@ -366,6 +371,83 @@ function createResolverAdapter(config) {
 		compile: config.compile
 	};
 }
+const pgDialect = new PgDialect();
+function withTenantCols(tableName, baseTable) {
+	const t = pgTable(tableName, {
+		site_id: varchar("site_id").notNull(),
+		search_type: varchar("search_type").notNull()
+	});
+	return {
+		...baseTable,
+		site_id: t.site_id,
+		search_type: t.search_type
+	};
+}
+const icebergSchema = {
+	pages: withTenantCols("pages", drizzleSchema.pages),
+	queries: withTenantCols("queries", drizzleSchema.queries),
+	countries: withTenantCols("countries", drizzleSchema.countries),
+	page_queries: withTenantCols("page_queries", drizzleSchema.page_queries),
+	dates: withTenantCols("dates", drizzleSchema.dates),
+	search_appearance: withTenantCols("search_appearance", drizzleSchema.search_appearance),
+	search_appearance_pages: withTenantCols("search_appearance_pages", drizzleSchema.search_appearance_pages),
+	search_appearance_queries: withTenantCols("search_appearance_queries", drizzleSchema.search_appearance_queries),
+	search_appearance_page_queries: withTenantCols("search_appearance_page_queries", drizzleSchema.search_appearance_page_queries),
+	hourly_pages: withTenantCols("hourly_pages", drizzleSchema.hourly_pages)
+};
+function compilePg(query) {
+	const compiled = pgDialect.sqlToQuery(query);
+	return {
+		sql: compiled.sql,
+		params: compiled.params
+	};
+}
+const PG_BASE_CONFIG = {
+	schema: drizzleSchema,
+	datasetToTableKey: {
+		pages: "pages",
+		queries: "queries",
+		page_queries: "page_queries",
+		countries: "countries",
+		dates: "dates",
+		search_appearance: "search_appearance",
+		search_appearance_pages: "search_appearance_pages",
+		search_appearance_queries: "search_appearance_queries",
+		search_appearance_page_queries: "search_appearance_page_queries",
+		hourly_pages: "hourly_pages"
+	},
+	metricCast: "DOUBLE",
+	regexPredicate: (expr, pattern, negate) => negate ? sql`NOT regexp_matches(${expr}, ${pattern})` : sql`regexp_matches(${expr}, ${pattern})`,
+	urlToPathExpr: (col) => `CASE WHEN ${col} LIKE 'http%' THEN COALESCE(NULLIF(regexp_replace(${col}, '^https?://[^/]+', ''), ''), '/') ELSE ${col} END`,
+	includeSiteId: false,
+	compile: compilePg,
+	capabilities: {
+		regex: true,
+		comparisonJoin: true,
+		windowTotals: true
+	}
+};
+const pgResolverAdapter = createResolverAdapter({
+	...PG_BASE_CONFIG,
+	tableLabel: "pg-resolver-adapter"
+});
+function createParquetResolverAdapter() {
+	return createResolverAdapter({
+		...PG_BASE_CONFIG,
+		tableLabel: "parquet-resolver-adapter",
+		tableRef: (tk) => sql.raw(`read_parquet({{FILES}}, union_by_name = true) AS "${tk}"`)
+	});
+}
+function createIcebergResolverAdapter() {
+	return createResolverAdapter({
+		...PG_BASE_CONFIG,
+		schema: icebergSchema,
+		includeSiteId: true,
+		includeSearchType: true,
+		tableLabel: "iceberg-resolver-adapter",
+		tableRef: (tk) => sql.raw(`"${tk}"`)
+	});
+}
 const COMPARISON_FILTER_SQL = {
 	new: sql`AND (p.impressions IS NULL OR p.impressions = 0)`,
 	lost: sql`AND p.impressions > 0 AND c.impressions = 0`,
@@ -440,7 +522,7 @@ function compileFilterTree(node, adapter, tableKey) {
 	return sql`(${sql.join(childSqls, sep)})`;
 }
 function buildScope(state, options) {
-	const { adapter, siteId } = options;
+	const { adapter, siteId, searchType } = options;
 	const plan = buildLogicalPlan(state, adapter.capabilities);
 	const tableKey = adapter.tableKeyForDataset(plan.dataset);
 	const dimFilters = toInternalDimensionFilters(plan.dimensionFilters);
@@ -451,6 +533,7 @@ function buildScope(state, options) {
 	const metrics = plan.metrics;
 	const wherePredicates = [];
 	if (adapter.siteIdColRef && siteId != null) wherePredicates.push(sql`${adapter.siteIdColRef(tableKey)} = ${siteId}`);
+	if (adapter.searchTypeColRef && searchType != null) wherePredicates.push(sql`${adapter.searchTypeColRef(tableKey)} = ${searchType}`);
 	wherePredicates.push(sql`${adapter.dateColRef(tableKey)} >= ${plan.dateRange.startDate}`);
 	wherePredicates.push(sql`${adapter.dateColRef(tableKey)} <= ${plan.dateRange.endDate}`);
 	wherePredicates.push(...adapter.prefilterPredicates(prefilters, tableKey));
@@ -572,7 +655,7 @@ function buildTotalsSql(state, options) {
 	return compileCollapsed(adapter, wherePredicates.length > 0 ? sql`SELECT ${joinComma(selectExprs)} FROM ${table} WHERE ${joinAnd(wherePredicates)}` : sql`SELECT ${joinComma(selectExprs)} FROM ${table}`);
 }
 function resolveComparisonSQL(current, previous, options, comparisonFilter) {
-	const { adapter, siteId } = options;
+	const { adapter, siteId, searchType } = options;
 	const comparisonPlan = buildComparisonPlan(current, previous, adapter.capabilities);
 	const currentScope = buildScope(current, options);
 	const previousScope = buildScope(previous, options);
@@ -590,6 +673,7 @@ function resolveComparisonSQL(current, previous, options, comparisonFilter) {
 	const groupByExprs = groupByDims.map((d) => adapter.dimExprSql(d, tableKey));
 	const prevWhere = [];
 	if (adapter.siteIdColRef && siteId != null) prevWhere.push(sql`${adapter.siteIdColRef(tableKey)} = ${siteId}`);
+	if (adapter.searchTypeColRef && searchType != null) prevWhere.push(sql`${adapter.searchTypeColRef(tableKey)} = ${searchType}`);
 	if (previousScope.startDate) prevWhere.push(sql`${adapter.dateColRef(tableKey)} >= ${previousScope.startDate}`);
 	if (previousScope.endDate) prevWhere.push(sql`${adapter.dateColRef(tableKey)} <= ${previousScope.endDate}`);
 	const prevDimSql = comparisonPlan.current.dimensionFilterTree ? compileFilterTree(comparisonPlan.current.dimensionFilterTree, adapter, tableKey) : void 0;
@@ -627,7 +711,7 @@ function resolveComparisonSQL(current, previous, options, comparisonFilter) {
 	};
 }
 function buildExtrasQueries(state, options) {
-	const { adapter, siteId } = options;
+	const { adapter, siteId, searchType } = options;
 	const plan = buildLogicalPlan(state, adapter.capabilities);
 	const dims = plan.groupByDimensions;
 	const extras = [];
@@ -637,6 +721,7 @@ function buildExtrasQueries(state, options) {
 	const table = adapter.tableRef(queriesKey);
 	const whereParts = [];
 	if (adapter.siteIdColRef && siteId != null) whereParts.push(sql`${adapter.siteIdColRef(queriesKey)} = ${siteId}`);
+	if (adapter.searchTypeColRef && searchType != null) whereParts.push(sql`${adapter.searchTypeColRef(queriesKey)} = ${searchType}`);
 	whereParts.push(sql`${adapter.dateColRef(queriesKey)} >= ${plan.dateRange.startDate}`);
 	whereParts.push(sql`${adapter.dateColRef(queriesKey)} <= ${plan.dateRange.endDate}`);
 	const whereExpr = whereParts.length > 0 ? sql`WHERE ${joinAnd(whereParts)}` : sql``;
@@ -771,50 +856,6 @@ function matchesMetricFilter(row, filter) {
 function matchesTopLevelPage(row) {
 	return (normalizeUrl(dimensionValue(row, "page")).match(/\//g)?.length ?? 0) <= 1;
 }
-const pgDialect = new PgDialect();
-function compilePg(query) {
-	const compiled = pgDialect.sqlToQuery(query);
-	return {
-		sql: compiled.sql,
-		params: compiled.params
-	};
-}
-const PG_BASE_CONFIG = {
-	schema: drizzleSchema,
-	datasetToTableKey: {
-		pages: "pages",
-		queries: "queries",
-		page_queries: "page_queries",
-		countries: "countries",
-		dates: "dates",
-		search_appearance: "search_appearance",
-		search_appearance_pages: "search_appearance_pages",
-		search_appearance_queries: "search_appearance_queries",
-		search_appearance_page_queries: "search_appearance_page_queries",
-		hourly_pages: "hourly_pages"
-	},
-	metricCast: "DOUBLE",
-	regexPredicate: (expr, pattern, negate) => negate ? sql`NOT regexp_matches(${expr}, ${pattern})` : sql`regexp_matches(${expr}, ${pattern})`,
-	urlToPathExpr: (col) => `CASE WHEN ${col} LIKE 'http%' THEN COALESCE(NULLIF(regexp_replace(${col}, '^https?://[^/]+', ''), ''), '/') ELSE ${col} END`,
-	includeSiteId: false,
-	compile: compilePg,
-	capabilities: {
-		regex: true,
-		comparisonJoin: true,
-		windowTotals: true
-	}
-};
-const pgResolverAdapter = createResolverAdapter({
-	...PG_BASE_CONFIG,
-	tableLabel: "pg-resolver-adapter"
-});
-function createParquetResolverAdapter() {
-	return createResolverAdapter({
-		...PG_BASE_CONFIG,
-		tableLabel: "parquet-resolver-adapter",
-		tableRef: (tk) => sql.raw(`read_parquet({{FILES}}, union_by_name = true) AS "${tk}"`)
-	});
-}
 function runArgs(ctx, partitions) {
 	return {
 		ctx: {
@@ -912,4 +953,4 @@ function assertSchemaInSync(options) {
 		if (missing.length > 0 || extra.length > 0) throw new Error(`${label} drizzle schema for '${key}' drifted from SCHEMAS. Missing: [${missing.join(", ")}]. Extra: [${extra.join(", ")}].`);
 	}
 }
-export { DIMENSION_SURFACES, LOGICAL_DATASETS, UnresolvableDatasetError, assertDimensionsSupported, assertSchemaInSync, buildExtrasQueries, buildTotalsSql, createParquetResolverAdapter, createResolverAdapter, createSqlFragments, dimensionColumn, dimensionValue, getDimensionFilters, getFilterDimensions, getInternalFilters, inferLogicalDataset, isDatasetResolvable, matchesDimensionFilter, matchesMetricFilter, matchesTopLevelPage, mergeExtras, metricValue, pgResolverAdapter, resolveComparisonSQL, resolveToSQL, resolveToSQLOptimized, runComparisonQuery, runOptimizedQuery, supportsDimensionOnSurface };
+export { DIMENSION_SURFACES, LOGICAL_DATASETS, UnresolvableDatasetError, assertDimensionsSupported, assertSchemaInSync, buildExtrasQueries, buildTotalsSql, createIcebergResolverAdapter, createParquetResolverAdapter, createResolverAdapter, createSqlFragments, dimensionColumn, dimensionValue, getDimensionFilters, getFilterDimensions, getInternalFilters, inferLogicalDataset, isDatasetResolvable, matchesDimensionFilter, matchesMetricFilter, matchesTopLevelPage, mergeExtras, metricValue, pgResolverAdapter, resolveComparisonSQL, resolveToSQL, resolveToSQLOptimized, runComparisonQuery, runOptimizedQuery, supportsDimensionOnSurface };

package/dist/_chunks/source.mjs

@@ -0,0 +1,165 @@
+import "./storage.mjs";
+import { assertDimensionsSupported, getFilterDimensions, pgResolverAdapter, resolveToSQL } from "./resolver.mjs";
+import { runAnalyzerFromSource } from "./dispatch.mjs";
+function coerceRow(row) {
+	let mutated = null;
+	for (const [k, v] of Object.entries(row)) if (typeof v === "bigint") {
+		if (!mutated) mutated = { ...row };
+		mutated[k] = Number(v);
+	}
+	return mutated ?? row;
+}
+function coerceRows(rows) {
+	const out = Array.from({ length: rows.length });
+	for (let i = 0; i < rows.length; i++) out[i] = coerceRow(rows[i]);
+	return out;
+}
+var AttachedTableMissingError = class extends Error {
+	missing;
+	constructor(missing) {
+		super(`attached-table source: required table(s) not attached: ${missing.join(", ")}`);
+		this.missing = missing;
+		this.name = "AttachedTableMissingError";
+	}
+};
+const ATTACHED_TABLE_CAPABILITIES = {
+	fileSets: true,
+	attachedTables: true,
+	regex: true
+};
+const ATTACHED_TABLE_CAPABILITIES_WITH_ADAPTER = {
+	...ATTACHED_TABLE_CAPABILITIES,
+	adapter: true
+};
+function rewriteForTableSource(sql, schema, fileSets) {
+	let out = sql;
+	for (const [key, fs] of Object.entries(fileSets)) {
+		const pattern = new RegExp(`read_parquet\\(\\s*\\{\\{${key}\\}\\}\\s*,\\s*union_by_name\\s*=\\s*true\\s*\\)`, "g");
+		out = out.replace(pattern, `${schema}.${fs.table}`);
+	}
+	return out;
+}
+function createAttachedTableSource(runner, options) {
+	const { schema, signal, attachedTables, adapter } = options;
+	const attachedSet = attachedTables ? new Set(attachedTables) : null;
+	return {
+		name: "attached-table",
+		kind: "browser",
+		capabilities: adapter ? ATTACHED_TABLE_CAPABILITIES_WITH_ADAPTER : ATTACHED_TABLE_CAPABILITIES,
+		adapter,
+		async queryRows() {
+			throw new Error("attached-table source: queryRows is not supported; use SQL analyzers");
+		},
+		async executeSql(sql, params, opts) {
+			signal?.throwIfAborted();
+			const fileSets = opts?.fileSets ?? {};
+			if (attachedSet) {
+				const missing = [];
+				for (const fs of Object.values(fileSets)) if (!attachedSet.has(fs.table)) missing.push(fs.table);
+				if (missing.length > 0) throw new AttachedTableMissingError(missing);
+			}
+			const rewritten = rewriteForTableSource(sql, schema, fileSets);
+			return coerceRows(await runner.query(rewritten, params ?? [], signal));
+		}
+	};
+}
+function createSqlQuerySource(options) {
+	const { name, kind, adapter, execute, siteId, searchType, extraCapabilities } = options;
+	return {
+		name,
+		kind,
+		capabilities: {
+			...adapter.capabilities,
+			...extraCapabilities,
+			adapter: true
+		},
+		adapter,
+		siteId,
+		async queryRows(state) {
+			const resolved = resolveToSQL(state, {
+				adapter,
+				siteId,
+				searchType
+			});
+			return coerceRows(await execute(resolved.sql, resolved.params));
+		},
+		async executeSql(sql, params) {
+			return coerceRows(await execute(sql, params ?? []));
+		}
+	};
+}
+function isMetricDimension(dim) {
+	return [
+		"clicks",
+		"impressions",
+		"ctr",
+		"position"
+	].includes(dim);
+}
+const ENGINE_QUERY_CAPABILITIES = {
+	regex: true,
+	multiDataset: false,
+	comparisonJoin: false,
+	windowTotals: false
+};
+const ENGINE_SOURCE_CAPABILITIES = {
+	...ENGINE_QUERY_CAPABILITIES,
+	fileSets: true,
+	adapter: true
+};
+function createEngineQuerySource(options) {
+	const { engine, ctx, searchType } = options;
+	return {
+		name: "engine",
+		kind: "local",
+		capabilities: ENGINE_SOURCE_CAPABILITIES,
+		adapter: pgResolverAdapter,
+		async queryRows(state) {
+			const filterDims = getFilterDimensions(state.filter, isMetricDimension);
+			assertDimensionsSupported([...state.dimensions, ...filterDims], "stored", "engine query source");
+			if (state.dimensions.includes("queryCanonical") || filterDims.includes("queryCanonical")) throw new Error("engine query source does not support queryCanonical; use browser/sqlite query sources for derived dimensions");
+			return coerceRows((await engine.query({
+				...ctx,
+				...searchType !== void 0 ? { searchType } : {}
+			}, state)).rows);
+		},
+		async executeSql(sql, params, opts) {
+			const fileSets = opts?.fileSets;
+			if (!fileSets?.FILES) throw new Error("engine query source: executeSql requires opts.fileSets with a FILES entry");
+			const { rows } = await engine.runSQL({
+				ctx,
+				table: fileSets.FILES.table,
+				fileSets,
+				sql,
+				params: params ?? [],
+				...searchType !== void 0 ? { searchType } : {}
+			});
+			return coerceRows(rows);
+		}
+	};
+}
+async function runAnalyzerWithEngine(deps, ctx, params, registry) {
+	return runAnalyzerFromSource(createEngineQuerySource({
+		engine: deps.engine,
+		ctx,
+		searchType: params.searchType ?? "web"
+	}), params, registry);
+}
+function typedQuery(state) {
+	return { state };
+}
+function isTypedQuery(value) {
+	return "state" in value;
+}
+async function queryRows(source, query) {
+	const state = isTypedQuery(query) ? query.state : query;
+	return await source.queryRows(state);
+}
+async function queryComparisonRows(source, current, previous) {
+	const [currentRows, previousRows] = await Promise.all([queryRows(source, current), queryRows(source, previous)]);
+	return {
+		current: currentRows,
+		previous: previousRows
+	};
+}
+export { AttachedTableMissingError, ENGINE_QUERY_CAPABILITIES, coerceRow, coerceRows, createAttachedTableSource, createEngineQuerySource, createSqlQuerySource, queryComparisonRows, queryRows, rewriteForTableSource, runAnalyzerWithEngine, typedQuery };

package/dist/_chunks/types.d.mts

@@ -13,6 +13,7 @@ interface ResolverAdapter<TableKey extends string = string> {
   dateColRef: (tableKey: TableKey) => SQL;
   urlToPathExpr: (col: string) => string;
   siteIdColRef?: (tableKey: TableKey) => SQL;
+  searchTypeColRef?: (tableKey: TableKey) => SQL;
   dimExprSql: (dim: Dimension, tableKey: TableKey) => SQL;
   metricSql: (metric: Metric, tableKey: TableKey) => SQL;
   dimensionPredicates: (filters: InternalFilter[], tableKey: TableKey) => SQL[];
@@ -29,6 +30,8 @@ interface ResolverOptions<TableKey extends string = string> {
   adapter: ResolverAdapter<TableKey>;
   /** Optional site scope. Required for multi-tenant D1; omitted for parquet. */
   siteId?: string | number;
+  /** Optional searchType scope. Required for multi-tenant Iceberg; omitted for parquet. */
+  searchType?: string;
 }
 interface ResolvedSQL {
   sql: string;

package/dist/index.d.mts

@@ -5,7 +5,9 @@ import { InspectionVerdict, SchedulePolicy, ScheduleState, fixedPolicy, inspecti
 import { CommitRetryOptions, ICEBERG_FIELD_ID_BASE, ICEBERG_PARTITION_COLUMNS, ICEBERG_PARTITION_SPEC, ICEBERG_SCHEMAS, ICEBERG_TABLES, IcebergAppendSinkOptions, IcebergCatalogConfig, IcebergColumn, IcebergColumnType, IcebergConnection, IcebergListedDataFile, IcebergPartitionField, IcebergPartitionSpec, IcebergPartitionSpecField, IcebergPartitionTransform, IcebergPrimitiveType, IcebergS3Config, IcebergSchema, IcebergSchemaField, IcebergTableName, IcebergTableOpResult, IcebergTableSpec, ListIcebergDataFilesOptions, LocalIcebergSinkOptions, Sink, SinkCapabilities, SinkCloseResult, SinkOptions, SinkSlice, SinkWriteResult, connectIcebergCatalog, createIcebergTables, dropIcebergTables, ensureIcebergNamespace, icebergAppendRetrying, icebergPartitionSpecFor, icebergSchemaFor, icebergTableSpec, isCommitRateLimited, listIcebergDataFiles, listIcebergTables } from "./_chunks/sink.mjs";
 import { GscApiRow, IngestOptions, RowAccumulator, RowAccumulatorOptions, assembleDatesRow, createRowAccumulator, toPath, toSumPosition, transformGscRow } from "./ingest.mjs";
 import { FILES_PLACEHOLDER, ResolvedQuery, resolveParquetSQL, substituteNamedFiles } from "./_chunks/planner.mjs";
+import { createIcebergResolverAdapter, createParquetResolverAdapter, pgResolverAdapter } from "./_chunks/pg-adapter.mjs";
 import { rebuildDailyFromHourly } from "./rollups.mjs";
+import { ENGINE_QUERY_CAPABILITIES, createSqlQuerySource } from "./_chunks/index.mjs";
 import { bindLiterals, formatLiteral } from "./sql-bind.mjs";
 import { Grain as Grain$1, Row as Row$1, TableName as TableName$1 } from "@gscdump/contracts";
 declare function coerceRow(row: Row$1): Row$1;
@@ -179,4 +181,4 @@ declare const MIN_SYNC_IMPRESSIONS = 1;
 declare const MIN_COUNTRY_IMPRESSIONS = 10;
 declare const MAX_SITEMAP_URLS_PER_SITE = 50000;
 declare const MAX_TRACKED_URLS_PER_SITE = 200000;
-export { type CodecCtx, type ColumnDef, type ColumnType, type CommitRetryOptions, type CompactionThresholds, type CompactionTier, type CreateIngestAccumulatorOptions, DEFAULT_SEARCH_TYPE, type DataSource, type DateWeight, type DrizzleSchema, type DuckDBFactory, type DuckDBHandle, type EngineOptions, FILES_PLACEHOLDER, type FileSetRef, type FinalizeOptions, type FinalizeResult, type GcCtx, type Grain, type GscApiRow, ICEBERG_FIELD_ID_BASE, ICEBERG_PARTITION_COLUMNS, ICEBERG_PARTITION_SPEC, ICEBERG_SCHEMAS, ICEBERG_TABLES, type IcebergAppendSink, type IcebergAppendSinkOptions, type IcebergCatalogConfig, type IcebergColumn, type IcebergColumnType, type IcebergConnection, type IcebergListedDataFile, type IcebergPartitionField, type IcebergPartitionSpec, type IcebergPartitionSpecField, type IcebergPartitionTransform, type IcebergPrimitiveType, type IcebergS3Config, type IcebergSchema, type IcebergSchemaField, type IcebergTableName, type IcebergTableOpResult, type IcebergTableSpec, type InMemorySink, type IngestAccumulator, type IngestAccumulatorCtx, type IngestAccumulatorEngine, type IngestAccumulatorHooks, type IngestOptions, type InspectionVerdict, type ListIcebergDataFilesOptions, type ListLiveFilter, type LocalIcebergSinkOptions, type LockScope, MAX_DAY_BYTES, MAX_GSC_PAGES_R2, MAX_SITEMAP_URLS_PER_SITE, MAX_TRACKED_URLS_PER_SITE, MIN_COUNTRY_IMPRESSIONS, MIN_SYNC_IMPRESSIONS, type ManifestEntry, type ManifestPurgeResult, type ManifestStore, type ParquetCodec, type PurgeFilter, type PurgeResult, type PurgeUrlsResult, type QueryCtx, type QueryExecuteOptions, type QueryExecuteResult, type QueryExecutor, type QueryResult, RAW_DAILY_COMPACT_THRESHOLD, ROW_LIMIT_R2, type ResolvedQuery, type Row, type RowAccumulator, type RowAccumulatorOptions, type RunSQLOptions, SCHEMAS, type SchedulePolicy, type ScheduleState, type SearchType, type Sink, type SinkCapabilities, type SinkCloseResult, type SinkOptions, type SinkSlice, type SinkWriteResult, type StorageEngine, type StoredRow, type SyncState, type SyncStateDetail, type SyncStateFilter, type SyncStateKind, type SyncStateScope, type SyncTableName, TABLES_BY_SEARCH_TYPE, TABLE_METADATA, TABLE_TIERS, TIER_PRIORITY, type TableName, type TableSchema, type TableTier, type TenantCtx, type TieredTableName, WEIGHT_PRIORITY, type Watermark, type WatermarkFilter, type WatermarkScope, type WriteCtx, type WriteResult, allTables, assembleDatesRow, bindLiterals, canonicalEmptyParquetSchema, coerceRow, coerceRows, connectIcebergCatalog, countRawDailies, countries, createDuckDBCodec, createDuckDBExecutor, createIcebergAppendSink, createIcebergTables, createInMemorySink, createIngestAccumulator, createNoopIngestAccumulator, createRowAccumulator, createStorageEngine, currentSchemaVersion, dates, dayPartition, dedupeOverlappingTiers, dimensionToColumn, drizzleSchema, dropIcebergTables, ensureIcebergNamespace, enumeratePartitions, fixedPolicy, formatLiteral, gcOrphansImpl, getDateWeight, getTableTier, getTablesForTier, hourPartition, hourly_pages, icebergAppendRetrying, icebergPartitionSpecFor, icebergSchemaFor, icebergTableSpec, inferLegacyTier, inferSearchType, inferTable, inspectionPolicy, isCommitRateLimited, listIcebergDataFiles, listIcebergTables, objectKey, page_queries, pages, parseEnabledSearchTypes, queries, rebuildDailyFromHourly, resolveParquetSQL, sitemapPolicy, splitOverlappingTiers, substituteNamedFiles, toPath, toSumPosition, transformGscRow, validateEnabledSearchTypes };
+export { type CodecCtx, type ColumnDef, type ColumnType, type CommitRetryOptions, type CompactionThresholds, type CompactionTier, type CreateIngestAccumulatorOptions, DEFAULT_SEARCH_TYPE, type DataSource, type DateWeight, type DrizzleSchema, type DuckDBFactory, type DuckDBHandle, ENGINE_QUERY_CAPABILITIES, type EngineOptions, FILES_PLACEHOLDER, type FileSetRef, type FinalizeOptions, type FinalizeResult, type GcCtx, type Grain, type GscApiRow, ICEBERG_FIELD_ID_BASE, ICEBERG_PARTITION_COLUMNS, ICEBERG_PARTITION_SPEC, ICEBERG_SCHEMAS, ICEBERG_TABLES, type IcebergAppendSink, type IcebergAppendSinkOptions, type IcebergCatalogConfig, type IcebergColumn, type IcebergColumnType, type IcebergConnection, type IcebergListedDataFile, type IcebergPartitionField, type IcebergPartitionSpec, type IcebergPartitionSpecField, type IcebergPartitionTransform, type IcebergPrimitiveType, type IcebergS3Config, type IcebergSchema, type IcebergSchemaField, type IcebergTableName, type IcebergTableOpResult, type IcebergTableSpec, type InMemorySink, type IngestAccumulator, type IngestAccumulatorCtx, type IngestAccumulatorEngine, type IngestAccumulatorHooks, type IngestOptions, type InspectionVerdict, type ListIcebergDataFilesOptions, type ListLiveFilter, type LocalIcebergSinkOptions, type LockScope, MAX_DAY_BYTES, MAX_GSC_PAGES_R2, MAX_SITEMAP_URLS_PER_SITE, MAX_TRACKED_URLS_PER_SITE, MIN_COUNTRY_IMPRESSIONS, MIN_SYNC_IMPRESSIONS, type ManifestEntry, type ManifestPurgeResult, type ManifestStore, type ParquetCodec, type PurgeFilter, type PurgeResult, type PurgeUrlsResult, type QueryCtx, type QueryExecuteOptions, type QueryExecuteResult, type QueryExecutor, type QueryResult, RAW_DAILY_COMPACT_THRESHOLD, ROW_LIMIT_R2, type ResolvedQuery, type Row, type RowAccumulator, type RowAccumulatorOptions, type RunSQLOptions, SCHEMAS, type SchedulePolicy, type ScheduleState, type SearchType, type Sink, type SinkCapabilities, type SinkCloseResult, type SinkOptions, type SinkSlice, type SinkWriteResult, type StorageEngine, type StoredRow, type SyncState, type SyncStateDetail, type SyncStateFilter, type SyncStateKind, type SyncStateScope, type SyncTableName, TABLES_BY_SEARCH_TYPE, TABLE_METADATA, TABLE_TIERS, TIER_PRIORITY, type TableName, type TableSchema, type TableTier, type TenantCtx, type TieredTableName, WEIGHT_PRIORITY, type Watermark, type WatermarkFilter, type WatermarkScope, type WriteCtx, type WriteResult, allTables, assembleDatesRow, bindLiterals, canonicalEmptyParquetSchema, coerceRow, coerceRows, connectIcebergCatalog, countRawDailies, countries, createDuckDBCodec, createDuckDBExecutor, createIcebergAppendSink, createIcebergResolverAdapter, createIcebergTables, createInMemorySink, createIngestAccumulator, createNoopIngestAccumulator, createParquetResolverAdapter, createRowAccumulator, createSqlQuerySource, createStorageEngine, currentSchemaVersion, dates, dayPartition, dedupeOverlappingTiers, dimensionToColumn, drizzleSchema, dropIcebergTables, ensureIcebergNamespace, enumeratePartitions, fixedPolicy, formatLiteral, gcOrphansImpl, getDateWeight, getTableTier, getTablesForTier, hourPartition, hourly_pages, icebergAppendRetrying, icebergPartitionSpecFor, icebergSchemaFor, icebergTableSpec, inferLegacyTier, inferSearchType, inferTable, inspectionPolicy, isCommitRateLimited, listIcebergDataFiles, listIcebergTables, objectKey, page_queries, pages, parseEnabledSearchTypes, pgResolverAdapter, queries, rebuildDailyFromHourly, resolveParquetSQL, sitemapPolicy, splitOverlappingTiers, substituteNamedFiles, toPath, toSumPosition, transformGscRow, validateEnabledSearchTypes };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { coerceRow, coerceRows } from "./_chunks/coerce.mjs";
+import { ENGINE_QUERY_CAPABILITIES, coerceRow, coerceRows, createSqlQuerySource } from "./_chunks/source.mjs";
 import { SCHEMAS, TABLE_METADATA, allTables, countries, currentSchemaVersion, dates, dimensionToColumn, drizzleSchema, hourly_pages, inferTable, page_queries, pages, queries } from "./_chunks/schema.mjs";
 import { DEFAULT_SEARCH_TYPE, dayPartition, hourPartition, inferLegacyTier, inferSearchType, objectKey } from "./_chunks/storage.mjs";
 import { FILES_PLACEHOLDER, RAW_DAILY_COMPACT_THRESHOLD, countRawDailies, dedupeOverlappingTiers, enumeratePartitions, resolveParquetSQL, splitOverlappingTiers, substituteNamedFiles } from "./_chunks/parquet-plan.mjs";
@@ -7,6 +7,7 @@ import { MAX_DAY_BYTES, canonicalEmptyParquetSchema, createDuckDBCodec, createDu
 import { ICEBERG_FIELD_ID_BASE, ICEBERG_PARTITION_COLUMNS, ICEBERG_PARTITION_SPEC, ICEBERG_SCHEMAS, ICEBERG_TABLES, icebergTableSpec } from "./_chunks/iceberg-schema.mjs";
 import { assembleDatesRow, createRowAccumulator, toPath, toSumPosition, transformGscRow } from "./ingest.mjs";
 import "./planner.mjs";
+import { createIcebergResolverAdapter, createParquetResolverAdapter, pgResolverAdapter } from "./_chunks/resolver.mjs";
 import { rebuildDailyFromHourly } from "./rollups.mjs";
 import { fixedPolicy, inspectionPolicy, sitemapPolicy } from "./schedule.mjs";
 import { icebergAppend, icebergCreateTable, icebergDropTable, icebergManifests, restCatalogConnect, restCatalogCreateNamespace, restCatalogListTables, restCatalogLoadTable, s3SignedResolver } from "icebird";
@@ -529,4 +530,4 @@ const MIN_SYNC_IMPRESSIONS = 1;
 const MIN_COUNTRY_IMPRESSIONS = 10;
 const MAX_SITEMAP_URLS_PER_SITE = 5e4;
 const MAX_TRACKED_URLS_PER_SITE = 2e5;
-export { DEFAULT_SEARCH_TYPE, FILES_PLACEHOLDER, ICEBERG_FIELD_ID_BASE, ICEBERG_PARTITION_COLUMNS, ICEBERG_PARTITION_SPEC, ICEBERG_SCHEMAS, ICEBERG_TABLES, MAX_DAY_BYTES, MAX_GSC_PAGES_R2, MAX_SITEMAP_URLS_PER_SITE, MAX_TRACKED_URLS_PER_SITE, MIN_COUNTRY_IMPRESSIONS, MIN_SYNC_IMPRESSIONS, RAW_DAILY_COMPACT_THRESHOLD, ROW_LIMIT_R2, SCHEMAS, TABLES_BY_SEARCH_TYPE, TABLE_METADATA, TABLE_TIERS, TIER_PRIORITY, WEIGHT_PRIORITY, allTables, assembleDatesRow, bindLiterals, canonicalEmptyParquetSchema, coerceRow, coerceRows, connectIcebergCatalog, countRawDailies, countries, createDuckDBCodec, createDuckDBExecutor, createIcebergAppendSink, createIcebergTables, createInMemorySink, createIngestAccumulator, createNoopIngestAccumulator, createRowAccumulator, createStorageEngine, currentSchemaVersion, dates, dayPartition, dedupeOverlappingTiers, dimensionToColumn, drizzleSchema, dropIcebergTables, ensureIcebergNamespace, enumeratePartitions, fixedPolicy, formatLiteral, gcOrphansImpl, getDateWeight, getTableTier, getTablesForTier, hourPartition, hourly_pages, icebergAppendRetrying, icebergPartitionSpecFor, icebergSchemaFor, icebergTableSpec, inferLegacyTier, inferSearchType, inferTable, inspectionPolicy, isCommitRateLimited, listIcebergDataFiles, listIcebergTables, objectKey, page_queries, pages, parseEnabledSearchTypes, queries, rebuildDailyFromHourly, resolveParquetSQL, sitemapPolicy, splitOverlappingTiers, substituteNamedFiles, toPath, toSumPosition, transformGscRow, validateEnabledSearchTypes };
+export { DEFAULT_SEARCH_TYPE, ENGINE_QUERY_CAPABILITIES, FILES_PLACEHOLDER, ICEBERG_FIELD_ID_BASE, ICEBERG_PARTITION_COLUMNS, ICEBERG_PARTITION_SPEC, ICEBERG_SCHEMAS, ICEBERG_TABLES, MAX_DAY_BYTES, MAX_GSC_PAGES_R2, MAX_SITEMAP_URLS_PER_SITE, MAX_TRACKED_URLS_PER_SITE, MIN_COUNTRY_IMPRESSIONS, MIN_SYNC_IMPRESSIONS, RAW_DAILY_COMPACT_THRESHOLD, ROW_LIMIT_R2, SCHEMAS, TABLES_BY_SEARCH_TYPE, TABLE_METADATA, TABLE_TIERS, TIER_PRIORITY, WEIGHT_PRIORITY, allTables, assembleDatesRow, bindLiterals, canonicalEmptyParquetSchema, coerceRow, coerceRows, connectIcebergCatalog, countRawDailies, countries, createDuckDBCodec, createDuckDBExecutor, createIcebergAppendSink, createIcebergResolverAdapter, createIcebergTables, createInMemorySink, createIngestAccumulator, createNoopIngestAccumulator, createParquetResolverAdapter, createRowAccumulator, createSqlQuerySource, createStorageEngine, currentSchemaVersion, dates, dayPartition, dedupeOverlappingTiers, dimensionToColumn, drizzleSchema, dropIcebergTables, ensureIcebergNamespace, enumeratePartitions, fixedPolicy, formatLiteral, gcOrphansImpl, getDateWeight, getTableTier, getTablesForTier, hourPartition, hourly_pages, icebergAppendRetrying, icebergPartitionSpecFor, icebergSchemaFor, icebergTableSpec, inferLegacyTier, inferSearchType, inferTable, inspectionPolicy, isCommitRateLimited, listIcebergDataFiles, listIcebergTables, objectKey, page_queries, pages, parseEnabledSearchTypes, pgResolverAdapter, queries, rebuildDailyFromHourly, resolveParquetSQL, sitemapPolicy, splitOverlappingTiers, substituteNamedFiles, toPath, toSumPosition, transformGscRow, validateEnabledSearchTypes };

package/dist/period/index.d.mts

@@ -1,2 +1,2 @@
-import { AnalysisPeriod, ComparisonMode, ComparisonPeriod, PadTimeseriesOptions, ResolveWindowOptions, ResolvedWindow, WindowPreset, comparisonOf, defaultEndDate, defaultStartDate, padTimeseries, periodOf, resolveWindow, windowToComparisonPeriod, windowToPeriod } from "../_chunks/index.mjs";
+import { AnalysisPeriod, ComparisonMode, ComparisonPeriod, PadTimeseriesOptions, ResolveWindowOptions, ResolvedWindow, WindowPreset, comparisonOf, defaultEndDate, defaultStartDate, padTimeseries, periodOf, resolveWindow, windowToComparisonPeriod, windowToPeriod } from "../_chunks/index2.mjs";
 export { AnalysisPeriod, ComparisonMode, ComparisonPeriod, PadTimeseriesOptions, ResolveWindowOptions, ResolvedWindow, WindowPreset, comparisonOf, defaultEndDate, defaultStartDate, padTimeseries, periodOf, resolveWindow, windowToComparisonPeriod, windowToPeriod };

package/dist/report/index.d.mts

@@ -1,5 +1,5 @@
 import { AnalysisParams, AnalysisResult } from "../_chunks/analysis-types.mjs";
-import { ComparisonMode, ResolvedWindow, WindowPreset } from "../_chunks/index.mjs";
+import { ComparisonMode, ResolvedWindow, WindowPreset } from "../_chunks/index2.mjs";
 /** Status vocabulary mirrors `ActionPrioritySourceStatus`. */
 type ReportStepStatus = 'pending' | 'running' | 'done' | 'skipped' | 'error';
 type ReportSeverity = 'info' | 'low' | 'medium' | 'high';

package/dist/resolver/index.d.mts

@@ -1,5 +1,6 @@
 import { SearchType as SearchType$1, TableName as TableName$1 } from "../_chunks/storage.mjs";
 import { ComparisonFilter, ExtraQuery, ResolvedComparisonSQL, ResolvedSQL, ResolvedSQLOptimized, ResolverAdapter, ResolverOptions } from "../_chunks/types.mjs";
+import { PgTableKey, createIcebergResolverAdapter, createParquetResolverAdapter, pgResolverAdapter } from "../_chunks/pg-adapter.mjs";
 import { LogicalDataset, LogicalDataset as LogicalDataset$1, PlannerCapabilities, UnresolvableDatasetError, inferDataset as inferLogicalDataset, isDatasetResolvable } from "gscdump/query/plan";
 import { SQL } from "drizzle-orm";
 import { Grain, TableName } from "@gscdump/contracts";
@@ -24,6 +25,7 @@ interface SqlFragmentsConfig<TableKey extends string> {
   regexPredicate: (expr: SQL, pattern: string, negate: boolean) => SQL;
   tableLabel: string;
   includeSiteId: boolean;
+  includeSearchType?: boolean;
   urlToPathExpr?: (col: string) => string;
   /**
    * Override the FROM-clause table reference. Default emits the bound drizzle
@@ -46,6 +48,7 @@ interface SqlFragments<TableKey extends string> {
   tableRef: (tableKey: TableKey) => SQL;
   dateColRef: (tableKey: TableKey) => SQL;
   siteIdColRef?: (tableKey: TableKey) => SQL;
+  searchTypeColRef?: (tableKey: TableKey) => SQL;
   dimExprSql: (dim: Dimension, tableKey: TableKey) => SQL;
   metricSql: (metric: Metric, tableKey: TableKey) => SQL;
   havingPredicates: (filters: InternalFilter[], tableKey: TableKey) => SQL[];
@@ -82,20 +85,6 @@ declare function dimensionValue(row: Record<string, unknown>, dimension: string)
 declare function matchesDimensionFilter(row: Record<string, unknown>, filter: InternalFilter): boolean;
 declare function matchesMetricFilter(row: Record<string, unknown>, filter: InternalFilter): boolean;
 declare function matchesTopLevelPage(row: Record<string, unknown>): boolean;
-type PgTableKey = TableName;
-declare const pgResolverAdapter: ResolverAdapter<PgTableKey>;
-/**
- * Parquet-aware variant of {@link pgResolverAdapter}. Identical SQL output
- * except FROM clauses emit `read_parquet({{FILES}}, union_by_name = true) AS
- * "${tk}"`. The runSQL pipeline substitutes `{{FILES}}` with R2 object keys
- * resolved from the manifest. The `AS "${tk}"` alias is mandatory — drizzle
- * compiles `colRef` to table-qualified `"pages"."url"`, which would not
- * resolve against an unaliased FROM.
- *
- * Single-use: build a fresh adapter per query. Cheap (no I/O) and avoids
- * accidental adapter caching that would lock in a stale `{{FILES}}` set.
- */
-declare function createParquetResolverAdapter(): ResolverAdapter<PgTableKey>;
 interface RunQueryCtx {
   userId: string;
   siteId: string;
@@ -175,4 +164,4 @@ interface AssertSchemaInSyncOptions {
   mode: 'exact' | 'superset';
 }
 declare function assertSchemaInSync(options: AssertSchemaInSyncOptions): void;
-export { type AssertSchemaInSyncOptions, type ComparisonFilter, type ComparisonQueryResult, type CreateResolverAdapterConfig, DIMENSION_SURFACES, type DimensionBinding, type DimensionSurface, type ExtraQuery, LOGICAL_DATASETS, type LogicalDataset, type LogicalDatasetDefinition, type OptimizedQueryResult, type PgTableKey, type ResolvedComparisonSQL, type ResolvedSQL, type ResolvedSQLOptimized, type ResolverAdapter, type ResolverOptions, type RunQueryCtx, type RunSQLFn, type SqlFragments, type SqlFragmentsConfig, UnresolvableDatasetError, assertDimensionsSupported, assertSchemaInSync, buildExtrasQueries, buildTotalsSql, createParquetResolverAdapter, createResolverAdapter, createSqlFragments, dimensionColumn, dimensionValue, getDimensionFilters, getFilterDimensions, getInternalFilters, inferLogicalDataset, isDatasetResolvable, matchesDimensionFilter, matchesMetricFilter, matchesTopLevelPage, mergeExtras, metricValue, pgResolverAdapter, resolveComparisonSQL, resolveToSQL, resolveToSQLOptimized, runComparisonQuery, runOptimizedQuery, supportsDimensionOnSurface };
+export { type AssertSchemaInSyncOptions, type ComparisonFilter, type ComparisonQueryResult, type CreateResolverAdapterConfig, DIMENSION_SURFACES, type DimensionBinding, type DimensionSurface, type ExtraQuery, LOGICAL_DATASETS, type LogicalDataset, type LogicalDatasetDefinition, type OptimizedQueryResult, type PgTableKey, type ResolvedComparisonSQL, type ResolvedSQL, type ResolvedSQLOptimized, type ResolverAdapter, type ResolverOptions, type RunQueryCtx, type RunSQLFn, type SqlFragments, type SqlFragmentsConfig, UnresolvableDatasetError, assertDimensionsSupported, assertSchemaInSync, buildExtrasQueries, buildTotalsSql, createIcebergResolverAdapter, createParquetResolverAdapter, createResolverAdapter, createSqlFragments, dimensionColumn, dimensionValue, getDimensionFilters, getFilterDimensions, getInternalFilters, inferLogicalDataset, isDatasetResolvable, matchesDimensionFilter, matchesMetricFilter, matchesTopLevelPage, mergeExtras, metricValue, pgResolverAdapter, resolveComparisonSQL, resolveToSQL, resolveToSQLOptimized, runComparisonQuery, runOptimizedQuery, supportsDimensionOnSurface };

package/dist/resolver/index.mjs

@@ -1,2 +1,2 @@
-import { DIMENSION_SURFACES, LOGICAL_DATASETS, UnresolvableDatasetError, assertDimensionsSupported, assertSchemaInSync, buildExtrasQueries, buildTotalsSql, createParquetResolverAdapter, createResolverAdapter, createSqlFragments, dimensionColumn, dimensionValue, getDimensionFilters, getFilterDimensions, getInternalFilters, inferLogicalDataset, isDatasetResolvable, matchesDimensionFilter, matchesMetricFilter, matchesTopLevelPage, mergeExtras, metricValue, pgResolverAdapter, resolveComparisonSQL, resolveToSQL, resolveToSQLOptimized, runComparisonQuery, runOptimizedQuery, supportsDimensionOnSurface } from "../_chunks/resolver.mjs";
-export { DIMENSION_SURFACES, LOGICAL_DATASETS, UnresolvableDatasetError, assertDimensionsSupported, assertSchemaInSync, buildExtrasQueries, buildTotalsSql, createParquetResolverAdapter, createResolverAdapter, createSqlFragments, dimensionColumn, dimensionValue, getDimensionFilters, getFilterDimensions, getInternalFilters, inferLogicalDataset, isDatasetResolvable, matchesDimensionFilter, matchesMetricFilter, matchesTopLevelPage, mergeExtras, metricValue, pgResolverAdapter, resolveComparisonSQL, resolveToSQL, resolveToSQLOptimized, runComparisonQuery, runOptimizedQuery, supportsDimensionOnSurface };
+import { DIMENSION_SURFACES, LOGICAL_DATASETS, UnresolvableDatasetError, assertDimensionsSupported, assertSchemaInSync, buildExtrasQueries, buildTotalsSql, createIcebergResolverAdapter, createParquetResolverAdapter, createResolverAdapter, createSqlFragments, dimensionColumn, dimensionValue, getDimensionFilters, getFilterDimensions, getInternalFilters, inferLogicalDataset, isDatasetResolvable, matchesDimensionFilter, matchesMetricFilter, matchesTopLevelPage, mergeExtras, metricValue, pgResolverAdapter, resolveComparisonSQL, resolveToSQL, resolveToSQLOptimized, runComparisonQuery, runOptimizedQuery, supportsDimensionOnSurface } from "../_chunks/resolver.mjs";
+export { DIMENSION_SURFACES, LOGICAL_DATASETS, UnresolvableDatasetError, assertDimensionsSupported, assertSchemaInSync, buildExtrasQueries, buildTotalsSql, createIcebergResolverAdapter, createParquetResolverAdapter, createResolverAdapter, createSqlFragments, dimensionColumn, dimensionValue, getDimensionFilters, getFilterDimensions, getInternalFilters, inferLogicalDataset, isDatasetResolvable, matchesDimensionFilter, matchesMetricFilter, matchesTopLevelPage, mergeExtras, metricValue, pgResolverAdapter, resolveComparisonSQL, resolveToSQL, resolveToSQLOptimized, runComparisonQuery, runOptimizedQuery, supportsDimensionOnSurface };

package/dist/source/index.d.mts

@@ -1,109 +1,3 @@
-import { Row, SearchType as SearchType$1, StorageEngine, TenantCtx } from "../_chunks/storage.mjs";
-import { AnalysisParams, AnalysisResult } from "../_chunks/analysis-types.mjs";
-import { ResolverAdapter } from "../_chunks/types.mjs";
-import { AnalysisQuerySource, AnalysisSourceKind, AnalyzerRegistry, ExecuteSqlOptions, FileSet, QueryRow, SourceCapabilities } from "../_chunks/registry.mjs";
-import { PlannerCapabilities } from "gscdump/query/plan";
-import { BuilderState } from "gscdump/query";
-interface AttachedTableRunner {
-  /**
-   * Run a query with positional (`?`) bound parameters. Return objects keyed
-   * by column name. BIGINT → number coercion is applied by the source factory
-   * (see `coerceRows`); runners only need to handle DATE → ISO string (or
-   * let the analyzer reducer normalize via `num(v)`/`str(v)`).
-   */
-  query: (sql: string, params?: unknown[], signal?: AbortSignal) => Promise<Row[]>;
-}
-interface AttachedTableSourceOptions {
-  /** Schema name the exported DuckDB file was attached under — e.g. `gsc`. */
-  schema: string;
-  /**
-   * Abort in-flight queries when the caller no longer cares about the
-   * result. Every `runner.query` call receives the same signal.
-   */
-  signal?: AbortSignal;
-  /**
-   * List of table names actually attached to this connection. When provided,
-   * `executeSql` short-circuits with a specific "table not attached" error
-   * if the SQL plan references a table that isn't in this list — letting
-   * callers (e.g. the analytics layer) route to cloud fallback without
-   * paying the SQL execution cost. Omit to disable the check.
-   */
-  attachedTables?: readonly string[];
-  /**
-   * Dialect adapter surfaced on the source for analyzers that compose SQL
-   * from a `BuilderState` at plan-build time (e.g. `data-query`,
-   * `data-detail`). Attached-table sources execute pg-flavored DuckDB SQL,
-   * so callers should pass `pgResolverAdapter` here.
-   */
-  adapter?: ResolverAdapter<any>;
-}
-declare class AttachedTableMissingError extends Error {
-  readonly missing: readonly string[];
-  constructor(missing: readonly string[]);
-}
-/**
- * Swap `read_parquet({{KEY}}, union_by_name = true)` for `<schema>.<table>`.
- * Tolerates whitespace variation. Preserves the rest of the SQL verbatim.
- */
-declare function rewriteForTableSource(sql: string, schema: string, fileSets: Record<string, FileSet>): string;
-declare function createAttachedTableSource(runner: AttachedTableRunner, options: AttachedTableSourceOptions): AnalysisQuerySource;
-interface CreateSqlQuerySourceOptions<TKey extends string> {
-  /** Debug-only identifier surfaced on the source for error messages. */
-  name: string;
-  /** Telemetry tag stamped onto analyzer result meta. */
-  kind?: AnalysisSourceKind;
-  /** Dialect-specific adapter; compiles `BuilderState` → `{ sql, params }`. */
-  adapter: ResolverAdapter<TKey>;
-  /** Drives the underlying DB. Called for both typed queries and raw SQL. */
-  execute: (sql: string, params: unknown[]) => Promise<QueryRow[]>;
-  /** Tenant id for multi-tenant dialects; forwarded to `resolveToSQL`. */
-  siteId?: string | number;
-  /** Additional capability flags merged on top of `adapter.capabilities`. */
-  extraCapabilities?: Partial<SourceCapabilities>;
-}
-declare function createSqlQuerySource<TKey extends string>(options: CreateSqlQuerySourceOptions<TKey>): AnalysisQuerySource;
-/**
- * Capabilities the engine query path honors. Matches what the DuckDB compiler
- * passes to `buildLogicalPlan`: regex pushes down; comparison joins and
- * multi-dataset queries belong to the analyzer dispatcher, not the engine's
- * builder-state query path.
- */
-declare const ENGINE_QUERY_CAPABILITIES: PlannerCapabilities;
-interface EngineQuerySourceOptions {
-  engine: StorageEngine;
-  ctx: TenantCtx;
-  /**
-   * Restrict every manifest lookup the source performs to a single search-type
-   * slice. Threads into `engine.query` and `engine.runSQL` so the wrapped
-   * source returns rows from one cohort instead of unioning web + non-web
-   * parquet. Undefined preserves legacy cross-type behaviour for web-only
-   * tenants and admin paths.
-   */
-  searchType?: SearchType$1;
-}
-/**
- * Wraps a storage engine as an `AnalysisQuerySource` with SQL execution.
- * `queryRows` runs typed builder-state queries; `executeSql` delegates to
- * `engine.runSQL` and requires `opts.fileSets` (with a `FILES` entry so the
- * target table can be resolved for partition lookup).
- */
-declare function createEngineQuerySource(options: EngineQuerySourceOptions): AnalysisQuerySource;
-/**
- * Convenience: wrap a storage engine + tenant ctx in a source and dispatch.
- * Equivalent to wrapping `createEngineQuerySource`, with omitted searchType
- * defaulted to web at this public helper boundary.
- */
-declare function runAnalyzerWithEngine(deps: {
-  engine: StorageEngine;
-}, ctx: TenantCtx, params: AnalysisParams, registry: AnalyzerRegistry): Promise<AnalysisResult>;
-interface TypedQuery<TRow> {
-  state: BuilderState;
-  readonly __row?: TRow;
-}
-declare function typedQuery<TRow>(state: BuilderState): TypedQuery<TRow>;
-declare function queryRows<TRow = QueryRow>(source: AnalysisQuerySource, query: BuilderState | TypedQuery<TRow>): Promise<TRow[]>;
-declare function queryComparisonRows<TRow = QueryRow>(source: AnalysisQuerySource, current: BuilderState | TypedQuery<TRow>, previous: BuilderState | TypedQuery<TRow>): Promise<{
-  current: TRow[];
-  previous: TRow[];
-}>;
+import { AnalysisQuerySource, AnalysisSourceKind, ExecuteSqlOptions, FileSet, QueryRow, SourceCapabilities } from "../_chunks/registry.mjs";
+import { AttachedTableMissingError, AttachedTableRunner, AttachedTableSourceOptions, CreateSqlQuerySourceOptions, ENGINE_QUERY_CAPABILITIES, EngineQuerySourceOptions, TypedQuery, createAttachedTableSource, createEngineQuerySource, createSqlQuerySource, queryComparisonRows, queryRows, rewriteForTableSource, runAnalyzerWithEngine, typedQuery } from "../_chunks/index.mjs";
 export { type AnalysisQuerySource, type AnalysisSourceKind, AttachedTableMissingError, type AttachedTableRunner, type AttachedTableSourceOptions, type CreateSqlQuerySourceOptions, ENGINE_QUERY_CAPABILITIES, EngineQuerySourceOptions, type ExecuteSqlOptions, type FileSet, type QueryRow, type SourceCapabilities, TypedQuery, createAttachedTableSource, createEngineQuerySource, createSqlQuerySource, queryComparisonRows, queryRows, rewriteForTableSource, runAnalyzerWithEngine, typedQuery };

package/dist/source/index.mjs

@@ -1,152 +1,2 @@
-import { coerceRows } from "../_chunks/coerce.mjs";
-import "../_chunks/storage.mjs";
-import { assertDimensionsSupported, getFilterDimensions, pgResolverAdapter, resolveToSQL } from "../_chunks/resolver.mjs";
-import { runAnalyzerFromSource } from "../_chunks/dispatch.mjs";
-var AttachedTableMissingError = class extends Error {
-	missing;
-	constructor(missing) {
-		super(`attached-table source: required table(s) not attached: ${missing.join(", ")}`);
-		this.missing = missing;
-		this.name = "AttachedTableMissingError";
-	}
-};
-const ATTACHED_TABLE_CAPABILITIES = {
-	fileSets: true,
-	attachedTables: true,
-	regex: true
-};
-const ATTACHED_TABLE_CAPABILITIES_WITH_ADAPTER = {
-	...ATTACHED_TABLE_CAPABILITIES,
-	adapter: true
-};
-function rewriteForTableSource(sql, schema, fileSets) {
-	let out = sql;
-	for (const [key, fs] of Object.entries(fileSets)) {
-		const pattern = new RegExp(`read_parquet\\(\\s*\\{\\{${key}\\}\\}\\s*,\\s*union_by_name\\s*=\\s*true\\s*\\)`, "g");
-		out = out.replace(pattern, `${schema}.${fs.table}`);
-	}
-	return out;
-}
-function createAttachedTableSource(runner, options) {
-	const { schema, signal, attachedTables, adapter } = options;
-	const attachedSet = attachedTables ? new Set(attachedTables) : null;
-	return {
-		name: "attached-table",
-		kind: "browser",
-		capabilities: adapter ? ATTACHED_TABLE_CAPABILITIES_WITH_ADAPTER : ATTACHED_TABLE_CAPABILITIES,
-		adapter,
-		async queryRows() {
-			throw new Error("attached-table source: queryRows is not supported; use SQL analyzers");
-		},
-		async executeSql(sql, params, opts) {
-			signal?.throwIfAborted();
-			const fileSets = opts?.fileSets ?? {};
-			if (attachedSet) {
-				const missing = [];
-				for (const fs of Object.values(fileSets)) if (!attachedSet.has(fs.table)) missing.push(fs.table);
-				if (missing.length > 0) throw new AttachedTableMissingError(missing);
-			}
-			const rewritten = rewriteForTableSource(sql, schema, fileSets);
-			return coerceRows(await runner.query(rewritten, params ?? [], signal));
-		}
-	};
-}
-function createSqlQuerySource(options) {
-	const { name, kind, adapter, execute, siteId, extraCapabilities } = options;
-	return {
-		name,
-		kind,
-		capabilities: {
-			...adapter.capabilities,
-			...extraCapabilities,
-			adapter: true
-		},
-		adapter,
-		siteId,
-		async queryRows(state) {
-			const resolved = resolveToSQL(state, {
-				adapter,
-				siteId
-			});
-			return coerceRows(await execute(resolved.sql, resolved.params));
-		},
-		async executeSql(sql, params) {
-			return coerceRows(await execute(sql, params ?? []));
-		}
-	};
-}
-function isMetricDimension(dim) {
-	return [
-		"clicks",
-		"impressions",
-		"ctr",
-		"position"
-	].includes(dim);
-}
-const ENGINE_QUERY_CAPABILITIES = {
-	regex: true,
-	multiDataset: false,
-	comparisonJoin: false,
-	windowTotals: false
-};
-const ENGINE_SOURCE_CAPABILITIES = {
-	...ENGINE_QUERY_CAPABILITIES,
-	fileSets: true,
-	adapter: true
-};
-function createEngineQuerySource(options) {
-	const { engine, ctx, searchType } = options;
-	return {
-		name: "engine",
-		kind: "local",
-		capabilities: ENGINE_SOURCE_CAPABILITIES,
-		adapter: pgResolverAdapter,
-		async queryRows(state) {
-			const filterDims = getFilterDimensions(state.filter, isMetricDimension);
-			assertDimensionsSupported([...state.dimensions, ...filterDims], "stored", "engine query source");
-			if (state.dimensions.includes("queryCanonical") || filterDims.includes("queryCanonical")) throw new Error("engine query source does not support queryCanonical; use browser/sqlite query sources for derived dimensions");
-			return coerceRows((await engine.query({
-				...ctx,
-				...searchType !== void 0 ? { searchType } : {}
-			}, state)).rows);
-		},
-		async executeSql(sql, params, opts) {
-			const fileSets = opts?.fileSets;
-			if (!fileSets?.FILES) throw new Error("engine query source: executeSql requires opts.fileSets with a FILES entry");
-			const { rows } = await engine.runSQL({
-				ctx,
-				table: fileSets.FILES.table,
-				fileSets,
-				sql,
-				params: params ?? [],
-				...searchType !== void 0 ? { searchType } : {}
-			});
-			return coerceRows(rows);
-		}
-	};
-}
-async function runAnalyzerWithEngine(deps, ctx, params, registry) {
-	return runAnalyzerFromSource(createEngineQuerySource({
-		engine: deps.engine,
-		ctx,
-		searchType: params.searchType ?? "web"
-	}), params, registry);
-}
-function typedQuery(state) {
-	return { state };
-}
-function isTypedQuery(value) {
-	return "state" in value;
-}
-async function queryRows(source, query) {
-	const state = isTypedQuery(query) ? query.state : query;
-	return await source.queryRows(state);
-}
-async function queryComparisonRows(source, current, previous) {
-	const [currentRows, previousRows] = await Promise.all([queryRows(source, current), queryRows(source, previous)]);
-	return {
-		current: currentRows,
-		previous: previousRows
-	};
-}
+import { AttachedTableMissingError, ENGINE_QUERY_CAPABILITIES, createAttachedTableSource, createEngineQuerySource, createSqlQuerySource, queryComparisonRows, queryRows, rewriteForTableSource, runAnalyzerWithEngine, typedQuery } from "../_chunks/source.mjs";
 export { AttachedTableMissingError, ENGINE_QUERY_CAPABILITIES, createAttachedTableSource, createEngineQuerySource, createSqlQuerySource, queryComparisonRows, queryRows, rewriteForTableSource, runAnalyzerWithEngine, typedQuery };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gscdump/engine",
   "type": "module",
-  "version": "0.23.1",
+  "version": "0.23.2",
   "description": "Append-only Parquet/DuckDB storage engine + planner + adapters for the gscdump pipeline. Node + edge runtimes; opt-in heavy peers.",
   "author": {
     "name": "Harlan Wilton",
@@ -180,8 +180,8 @@
     "drizzle-orm": "^0.45.2",
     "icebird": "^0.8.6",
     "proper-lockfile": "^4.1.2",
-    "@gscdump/contracts": "0.23.1",
-    "gscdump": "0.23.1"
+    "@gscdump/contracts": "0.23.2",
+    "gscdump": "0.23.2"
   },
   "devDependencies": {
     "@duckdb/duckdb-wasm": "^1.32.0",

package/dist/_chunks/coerce.mjs

@@ -1,14 +0,0 @@
-function coerceRow(row) {
-	let mutated = null;
-	for (const [k, v] of Object.entries(row)) if (typeof v === "bigint") {
-		if (!mutated) mutated = { ...row };
-		mutated[k] = Number(v);
-	}
-	return mutated ?? row;
-}
-function coerceRows(rows) {
-	const out = Array.from({ length: rows.length });
-	for (let i = 0; i < rows.length; i++) out[i] = coerceRow(rows[i]);
-	return out;
-}
-export { coerceRow, coerceRows };