@gscdump/engine 1.0.1 → 1.0.3

package/dist/source/index.d.mts

@@ -1,3 +1,104 @@
-import { AnalysisQuerySource, AnalysisSourceKind, ExecuteSqlOptions, FileSet, QueryRow, SourceCapabilities } from "../_chunks/registry.mjs";
-import { AttachedTableMissingError, AttachedTableRunner, AttachedTableSourceOptions, CreateSqlQuerySourceOptions, ENGINE_QUERY_CAPABILITIES, EngineQuerySourceOptions, createAttachedTableSource, createEngineQuerySource, createSqlQuerySource, queryRows, runAnalyzerWithEngine } from "../_chunks/index.mjs";
+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 { EngineError } from "../_chunks/errors.mjs";
+import "../_chunks/contracts.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[];
+  readonly engineError: EngineError;
+  constructor(missing: readonly 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`.
+   * `number` = int-encoded code (`SEARCH_TYPE_INT`) for INT `search_type`
+   * catalogs (bound bare so the int partition prunes); `string` otherwise.
+   */
+  searchType?: 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>;
+declare function queryRows<TRow = QueryRow>(source: AnalysisQuerySource, state: BuilderState): Promise<TRow[]>;
 export { type AnalysisQuerySource, type AnalysisSourceKind, AttachedTableMissingError, type AttachedTableRunner, type AttachedTableSourceOptions, type CreateSqlQuerySourceOptions, ENGINE_QUERY_CAPABILITIES, EngineQuerySourceOptions, type ExecuteSqlOptions, type FileSet, type QueryRow, type SourceCapabilities, createAttachedTableSource, createEngineQuerySource, createSqlQuerySource, queryRows, runAnalyzerWithEngine };

package/dist/source/index.mjs

@@ -1,2 +1,143 @@
-import { AttachedTableMissingError, ENGINE_QUERY_CAPABILITIES, createAttachedTableSource, createEngineQuerySource, createSqlQuerySource, queryRows, runAnalyzerWithEngine } from "../_chunks/source.mjs";
+import { engineErrors } from "../errors.mjs";
+import "../_chunks/layout.mjs";
+import { coerceRows } from "../_chunks/coerce.mjs";
+import { assertDimensionsSupported, getFilterDimensions, pgResolverAdapter, resolveToSQL } from "../_chunks/resolver.mjs";
+import { runAnalyzerFromSource } from "../_chunks/dispatch.mjs";
+var AttachedTableMissingError = class extends Error {
+	missing;
+	engineError;
+	constructor(missing) {
+		const engineError = engineErrors.attachedTableMissing(missing);
+		super(engineError.message);
+		this.missing = missing;
+		this.name = "AttachedTableMissingError";
+		this.engineError = engineError;
+	}
+};
+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);
+}
+async function queryRows(source, state) {
+	return await source.queryRows(state);
+}
 export { AttachedTableMissingError, ENGINE_QUERY_CAPABILITIES, createAttachedTableSource, createEngineQuerySource, createSqlQuerySource, queryRows, runAnalyzerWithEngine };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gscdump/engine",
   "type": "module",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Append-only Parquet/DuckDB storage engine + planner + adapters for the gscdump pipeline. Node + edge runtimes; opt-in heavy peers.",
   "author": {
     "name": "Harlan Wilton",
@@ -51,6 +51,11 @@
       "import": "./dist/ingest.mjs",
       "default": "./dist/ingest.mjs"
     },
+    "./ingest-accumulator": {
+      "types": "./dist/ingest-accumulator.d.mts",
+      "import": "./dist/ingest-accumulator.mjs",
+      "default": "./dist/ingest-accumulator.mjs"
+    },
     "./sink-node": {
       "types": "./dist/sink-node.d.mts",
       "import": "./dist/sink-node.mjs",
@@ -71,6 +76,11 @@
       "import": "./dist/entities.mjs",
       "default": "./dist/entities.mjs"
     },
+    "./entity-keys": {
+      "types": "./dist/entity-keys.d.mts",
+      "import": "./dist/entity-keys.mjs",
+      "default": "./dist/entity-keys.mjs"
+    },
     "./rollups": {
       "types": "./dist/rollups.d.mts",
       "import": "./dist/rollups.mjs",
@@ -166,9 +176,9 @@
   "dependencies": {
     "drizzle-orm": "1.0.0-rc.3",
     "proper-lockfile": "^4.1.2",
-    "@gscdump/contracts": "^1.0.1",
-    "gscdump": "^1.0.1",
-    "@gscdump/lakehouse": "^1.0.1"
+    "@gscdump/contracts": "^1.0.3",
+    "gscdump": "^1.0.3",
+    "@gscdump/lakehouse": "^1.0.3"
   },
   "devDependencies": {
     "@duckdb/duckdb-wasm": "1.33.1-dev57.0",

package/dist/_chunks/duckdb.d.mts

@@ -1,27 +0,0 @@
-import { ParquetCodec, QueryExecutor, Row } from "./storage.mjs";
-interface DuckDBHandle {
-  query: (sql: string, params?: unknown[]) => Promise<Row[]>;
-  registerFileBuffer: (name: string, bytes: Uint8Array) => Promise<void>;
-  copyFileToBuffer: (name: string) => Promise<Uint8Array>;
-  dropFiles: (names: string[]) => Promise<void>;
-  /**
-   * Returns a unique path suitable for `COPY TO '…'` + `copyFileToBuffer`.
-   * In Node this is an absolute path under `os.tmpdir()` so DuckDB doesn't
-   * litter the CWD; in browsers/Workers it's a plain virtual-FS name.
-   */
-  makeTempPath: (ext: string) => string;
-}
-interface DuckDBFactory {
-  getDuckDB: () => Promise<DuckDBHandle>;
-}
-interface DuckDBReadOptions {
-  /**
-   * Maximum non-URI parquet reads held in flight while registering DuckDB
-   * buffers. Defaults to 16; callers handling unusually large files can lower
-   * it to trade latency for peak JS memory.
-   */
-  bufferReadConcurrency?: number;
-}
-declare function createDuckDBCodec(factory: DuckDBFactory, options?: DuckDBReadOptions): ParquetCodec;
-declare function createDuckDBExecutor(factory: DuckDBFactory, options?: DuckDBReadOptions): QueryExecutor;
-export { DuckDBFactory, DuckDBHandle, createDuckDBCodec, createDuckDBExecutor };

package/dist/_chunks/index2.d.mts

@@ -1,53 +0,0 @@
-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 periodOf(params: AnalysisParams): AnalysisPeriod;
-declare function comparisonOf(params: AnalysisParams): ComparisonPeriod;
-declare function resolveWindow(opts: ResolveWindowOptions): ResolvedWindow;
-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, padTimeseries, periodOf, resolveWindow };

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

@@ -1,56 +0,0 @@
-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.
- */
-interface ResolverAdapterOptions {
-  /**
-   * `queryDim` reads canonical from a joined query dimension. `column` is only
-   * for derived canonical rollup relations whose primary relation already
-   * carries a null-free `query_canonical` output column.
-   */
-  queryCanonicalSource?: 'queryDim' | 'column';
-}
-interface R2SqlResolverAdapterOptions extends ResolverAdapterOptions {
-  /**
-   * R2 SQL string partition equality can undercount on identity partitions;
-   * string-encoded catalogs use CONCAT(col, '') in partition predicates. Int
-   * catalogs do not need the workaround and keep bare equality for pruning.
-   */
-  partitionKeyEncoding?: 'string' | 'int';
-}
-declare function createParquetResolverAdapter(options?: ResolverAdapterOptions): 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(options?: ResolverAdapterOptions): ResolverAdapter<PgTableKey>;
-/**
- * R2 SQL adapter for the Iceberg fact tables.
- *
- * It shares the multi-tenant Iceberg schema with `createIcebergResolverAdapter`
- * but models R2 SQL's narrower execution surface: no window-total plans and no
- * comparison joins. Int-partition catalogs are the default and emit bare
- * equality predicates for pruning. Legacy string-partition catalogs must pass
- * `partitionKeyEncoding: 'string'` to emit `CONCAT(partition_col, '') = ?`,
- * working around R2 SQL's partition-string equality undercount while preserving
- * bound params.
- */
-declare function createR2SqlResolverAdapter(options?: R2SqlResolverAdapterOptions): ResolverAdapter<PgTableKey>;
-export { PgTableKey, R2SqlResolverAdapterOptions, ResolverAdapterOptions, createIcebergResolverAdapter, createParquetResolverAdapter, createR2SqlResolverAdapter, pgResolverAdapter };

package/dist/_chunks/planner.d.mts

@@ -1,15 +0,0 @@
-import { TableName } from "./storage.mjs";
-import { LogicalQueryPlan } from "gscdump/query/plan";
-import { BuilderState } from "gscdump/query";
-interface ResolvedQuery {
-  sql: string;
-  params: unknown[];
-  partitions: string[];
-  table: TableName;
-  filesPlaceholder: string;
-}
-declare const FILES_PLACEHOLDER = "{{FILES}}";
-declare function compileLogicalQueryPlan(plan: LogicalQueryPlan, table?: TableName): ResolvedQuery;
-declare function resolveParquetSQL(state: BuilderState, table?: TableName): ResolvedQuery;
-declare function substituteNamedFiles(sql: string, sets: Record<string, string[]>): string;
-export { FILES_PLACEHOLDER, ResolvedQuery, compileLogicalQueryPlan, resolveParquetSQL, substituteNamedFiles };

package/dist/_chunks/source.mjs

@@ -1,143 +0,0 @@
-import { engineErrors } from "../errors.mjs";
-import "./layout.mjs";
-import { coerceRows } from "./coerce.mjs";
-import { assertDimensionsSupported, getFilterDimensions, pgResolverAdapter, resolveToSQL } from "./resolver.mjs";
-import { runAnalyzerFromSource } from "./dispatch.mjs";
-var AttachedTableMissingError = class extends Error {
-	missing;
-	engineError;
-	constructor(missing) {
-		const engineError = engineErrors.attachedTableMissing(missing);
-		super(engineError.message);
-		this.missing = missing;
-		this.name = "AttachedTableMissingError";
-		this.engineError = engineError;
-	}
-};
-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);
-}
-async function queryRows(source, state) {
-	return await source.queryRows(state);
-}
-export { AttachedTableMissingError, ENGINE_QUERY_CAPABILITIES, createAttachedTableSource, createEngineQuerySource, createSqlQuerySource, queryRows, runAnalyzerWithEngine };

package/dist/adapters/duckdb-node.d.mts

@@ -1,7 +0,0 @@
-import { DuckDBHandle } from "../_chunks/duckdb.mjs";
-interface NodeDuckDBOptions {
-  verbose?: boolean;
-}
-declare function createNodeDuckDBHandle(opts?: NodeDuckDBOptions): DuckDBHandle;
-declare function resetNodeDuckDB(): void;
-export { NodeDuckDBOptions, createNodeDuckDBHandle, resetNodeDuckDB };