@gscdump/engine 0.7.1 → 0.7.2

package/dist/period/index.mjs

@@ -0,0 +1,150 @@
+import { MS_PER_DAY, daysAgo, toIsoDate } from "gscdump";
+function defaultEndDate() {
+	return daysAgo(3);
+}
+function defaultStartDate() {
+	return daysAgo(31);
+}
+function periodOf(params) {
+	return {
+		startDate: params.startDate || defaultStartDate(),
+		endDate: params.endDate || defaultEndDate()
+	};
+}
+function comparisonOf(params) {
+	if (!params.prevStartDate || !params.prevEndDate) throw new Error(`${params.type} analysis requires prevStartDate and prevEndDate`);
+	return {
+		current: periodOf(params),
+		previous: {
+			startDate: params.prevStartDate,
+			endDate: params.prevEndDate
+		}
+	};
+}
+function parseIso(s) {
+	return /* @__PURE__ */ new Date(`${s}T00:00:00Z`);
+}
+function addDays(d, n) {
+	return new Date(d.getTime() + n * MS_PER_DAY);
+}
+function daysBetween(start, end) {
+	return Math.round((parseIso(end).getTime() - parseIso(start).getTime()) / MS_PER_DAY) + 1;
+}
+function resolveWindow(opts) {
+	const anchor = opts.anchor ? parseIso(opts.anchor) : /* @__PURE__ */ new Date();
+	const anchorIso = toIsoDate(anchor);
+	let start;
+	let end;
+	switch (opts.preset) {
+		case "last-7d":
+			end = anchorIso;
+			start = toIsoDate(addDays(anchor, -6));
+			break;
+		case "last-28d":
+			end = anchorIso;
+			start = toIsoDate(addDays(anchor, -27));
+			break;
+		case "last-30d":
+			end = anchorIso;
+			start = toIsoDate(addDays(anchor, -29));
+			break;
+		case "last-90d":
+			end = anchorIso;
+			start = toIsoDate(addDays(anchor, -89));
+			break;
+		case "last-180d":
+			end = anchorIso;
+			start = toIsoDate(addDays(anchor, -179));
+			break;
+		case "last-365d":
+			end = anchorIso;
+			start = toIsoDate(addDays(anchor, -364));
+			break;
+		case "mtd":
+			end = anchorIso;
+			start = toIsoDate(new Date(Date.UTC(anchor.getUTCFullYear(), anchor.getUTCMonth(), 1)));
+			break;
+		case "ytd":
+			end = anchorIso;
+			start = toIsoDate(new Date(Date.UTC(anchor.getUTCFullYear(), 0, 1)));
+			break;
+		case "custom":
+			if (!opts.start || !opts.end) throw new Error("resolveWindow: preset=custom requires start and end");
+			start = opts.start;
+			end = opts.end;
+			break;
+	}
+	const days = daysBetween(start, end);
+	const result = {
+		start,
+		end,
+		days
+	};
+	const mode = opts.comparison ?? "none";
+	if (mode === "prev-period") {
+		const prevEnd = toIsoDate(addDays(parseIso(start), -1));
+		result.comparison = {
+			start: toIsoDate(addDays(parseIso(prevEnd), -(days - 1))),
+			end: prevEnd
+		};
+	} else if (mode === "yoy") {
+		const prevEnd = toIsoDate(addDays(parseIso(end), -365));
+		result.comparison = {
+			start: toIsoDate(addDays(parseIso(start), -365)),
+			end: prevEnd
+		};
+	}
+	return result;
+}
+function windowToPeriod(w) {
+	return {
+		startDate: w.start,
+		endDate: w.end
+	};
+}
+function windowToComparisonPeriod(w) {
+	if (!w.comparison) return void 0;
+	return {
+		current: {
+			startDate: w.start,
+			endDate: w.end
+		},
+		previous: {
+			startDate: w.comparison.start,
+			endDate: w.comparison.end
+		}
+	};
+}
+const DEFAULT_FILL = {
+	clicks: 0,
+	impressions: 0,
+	ctr: 0,
+	position: 0
+};
+function padTimeseries(rows, options) {
+	const { startDate, endDate } = options;
+	const dateKey = options.dateKey ?? "date";
+	const fill = options.fill ?? DEFAULT_FILL;
+	const byDate = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const d = String(row[dateKey]);
+		const bucket = byDate.get(d);
+		if (bucket) bucket.push(row);
+		else byDate.set(d, [row]);
+	}
+	const result = [];
+	const start = /* @__PURE__ */ new Date(`${startDate}T00:00:00Z`);
+	const end = /* @__PURE__ */ new Date(`${endDate}T00:00:00Z`);
+	if (Number.isNaN(start.getTime()) || Number.isNaN(end.getTime())) throw new Error(`padTimeseries: invalid date range ${startDate}..${endDate}`);
+	for (let cursorMs = start.getTime(), endMs = end.getTime(); cursorMs <= endMs; cursorMs += MS_PER_DAY) {
+		const dateStr = toIsoDate(new Date(cursorMs));
+		const existing = byDate.get(dateStr);
+		if (existing) result.push(...existing);
+		else result.push({
+			...fill,
+			[dateKey]: dateStr
+		});
+	}
+	return result;
+}
+export { comparisonOf, defaultEndDate, defaultStartDate, padTimeseries, periodOf, resolveWindow, windowToComparisonPeriod, windowToPeriod };

package/dist/resolver/index.d.mts

@@ -1,4 +1,5 @@
 import { a as ResolvedSQLOptimized, i as ResolvedSQL, n as ExtraQuery, o as ResolverAdapter, r as ResolvedComparisonSQL, s as ResolverOptions, t as ComparisonFilter } from "../_chunks/types.mjs";
+import { a as RowQuerySource, c as isSqlQuerySource, i as QueryRow, n as ExecuteSqlOptions, o as SourceCapabilities, r as FileSet, s as SqlQuerySource, t as AnalysisQuerySource } from "../_chunks/source-types.mjs";
 import { LogicalDataset, LogicalDataset as LogicalDataset$1, PlannerCapabilities } from "gscdump/query/plan";
 import { SQL } from "drizzle-orm";
 import { TableName } from "gscdump/contracts";
@@ -73,33 +74,6 @@ declare function mergeExtras(rows: Record<string, unknown>[], extrasResults: {
   key: string;
   results: Record<string, unknown>[];
 }[]): Record<string, unknown>[];
-type QueryRow = Record<string, unknown>;
-interface FileSet {
-  table: TableName;
-  partitions: string[];
-}
-interface ExecuteSqlOptions {
-  fileSets?: Record<string, FileSet>;
-}
-interface SourceCapabilities extends PlannerCapabilities {
-  attachedTables?: boolean;
-  fileSets?: boolean;
-  localSource?: boolean;
-}
-interface RowQuerySource {
-  name?: string;
-  capabilities: SourceCapabilities;
-  queryRows: (state: BuilderState) => Promise<QueryRow[]>;
-  readonly executeSql?: undefined;
-}
-interface SqlQuerySource {
-  name?: string;
-  capabilities: SourceCapabilities;
-  queryRows: (state: BuilderState) => Promise<QueryRow[]>;
-  executeSql: (sql: string, params?: unknown[], opts?: ExecuteSqlOptions) => Promise<QueryRow[]>;
-}
-type AnalysisQuerySource = RowQuerySource | SqlQuerySource;
-declare function isSqlQuerySource(s: AnalysisQuerySource): s is SqlQuerySource;
 interface CreateSqlQuerySourceOptions<TKey extends string> {
   /** Debug-only identifier surfaced on the source for error messages. */
   name: string;

package/dist/resolver/index.mjs

@@ -1,91 +1,3 @@
-import { t as SCHEMAS } from "../_chunks/schema.mjs";
 import { _ as resolveToSQL, a as createResolverAdapter, c as LOGICAL_DATASETS, d as inferLogicalDataset, f as supportsDimensionOnSurface, g as resolveComparisonSQL, h as mergeExtras, i as compileSqlite, l as assertDimensionsSupported, m as buildTotalsSql, n as pgResolverAdapter, o as createSqlFragments, p as buildExtrasQueries, r as compilePg, s as DIMENSION_SURFACES, t as createParquetResolverAdapter, u as dimensionColumn, v as resolveToSQLOptimized } from "../_chunks/pg-adapter.mjs";
-import { normalizeUrl } from "gscdump/normalize";
-function createSqlQuerySource(options) {
-	const { name, adapter, execute, siteId, extraCapabilities } = options;
-	return {
-		name,
-		capabilities: {
-			...adapter.capabilities,
-			...extraCapabilities
-		},
-		async queryRows(state) {
-			const resolved = resolveToSQL(state, {
-				adapter,
-				siteId
-			});
-			return execute(resolved.sql, resolved.params);
-		},
-		executeSql(sql, params) {
-			return execute(sql, params ?? []);
-		}
-	};
-}
-function collectInternalFilters(filter) {
-	if (!filter || !("_filters" in filter)) return [];
-	const flat = filter._filters;
-	const nested = filter._nestedGroups?.flatMap((group) => collectInternalFilters(group)) ?? [];
-	return [...flat, ...nested];
-}
-function getInternalFilters(filter) {
-	return collectInternalFilters(filter);
-}
-function getDimensionFilters(filter, isMetricDimension) {
-	return collectInternalFilters(filter).filter((f) => f.dimension !== "date" && !isMetricDimension(f.dimension) && f.operator !== "topLevel" && !f.operator.startsWith("metric"));
-}
-function getFilterDimensions(filter, isMetricDimension) {
-	return getDimensionFilters(filter, isMetricDimension).map((f) => f.dimension);
-}
-function metricValue(row, metric) {
-	const value = row[metric];
-	if (typeof value === "number") return value;
-	if (typeof value === "bigint") return Number(value);
-	if (value == null) return 0;
-	return Number(value);
-}
-function dimensionValue(row, dimension) {
-	const value = row[dimension];
-	return value == null ? "" : String(value);
-}
-function matchesDimensionFilter(row, filter) {
-	const raw = dimensionValue(row, filter.dimension);
-	const value = filter.dimension === "page" ? normalizeUrl(raw) : raw;
-	switch (filter.operator) {
-		case "equals": return value === filter.expression;
-		case "notEquals": return value !== filter.expression;
-		case "contains": return raw.includes(filter.expression);
-		case "notContains": return !raw.includes(filter.expression);
-		case "includingRegex": return new RegExp(filter.expression).test(raw);
-		case "excludingRegex": return !new RegExp(filter.expression).test(raw);
-		default: return true;
-	}
-}
-function matchesMetricFilter(row, filter) {
-	const value = metricValue(row, filter.dimension);
-	const target = Number(filter.expression);
-	switch (filter.operator) {
-		case "metricGte": return value >= target;
-		case "metricGt": return value > target;
-		case "metricLte": return value <= target;
-		case "metricLt": return value < target;
-		case "metricBetween": return value >= target && value <= Number(filter.expression2);
-		default: return true;
-	}
-}
-function matchesTopLevelPage(row) {
-	return (normalizeUrl(dimensionValue(row, "page")).match(/\//g)?.length ?? 0) <= 1;
-}
-function assertSchemaInSync(options) {
-	const { label, schema, tableKeyToName, mode } = options;
-	for (const [key, table] of Object.entries(schema)) {
-		const sourceCols = SCHEMAS[tableKeyToName(key)].columns.map((c) => c.name).sort();
-		const drizzleCols = Object.keys(table[Symbol.for("drizzle:Columns")] ?? {}).sort();
-		const missing = sourceCols.filter((c) => !drizzleCols.includes(c));
-		const extra = mode === "exact" ? drizzleCols.filter((c) => !sourceCols.includes(c)) : [];
-		if (missing.length > 0 || extra.length > 0) throw new Error(`${label} drizzle schema for '${key}' drifted from SCHEMAS. Missing: [${missing.join(", ")}]. Extra: [${extra.join(", ")}].`);
-	}
-}
-function isSqlQuerySource(s) {
-	return typeof s.executeSql === "function";
-}
+import { a as getFilterDimensions, c as matchesMetricFilter, d as createSqlQuerySource, i as getDimensionFilters, l as matchesTopLevelPage, n as assertSchemaInSync, o as getInternalFilters, r as dimensionValue, s as matchesDimensionFilter, t as isSqlQuerySource, u as metricValue } from "../_chunks/resolver.mjs";
 export { DIMENSION_SURFACES, LOGICAL_DATASETS, assertDimensionsSupported, assertSchemaInSync, buildExtrasQueries, buildTotalsSql, compilePg, compileSqlite, createParquetResolverAdapter, createResolverAdapter, createSqlFragments, createSqlQuerySource, dimensionColumn, dimensionValue, getDimensionFilters, getFilterDimensions, getInternalFilters, inferLogicalDataset, isSqlQuerySource, matchesDimensionFilter, matchesMetricFilter, matchesTopLevelPage, mergeExtras, metricValue, pgResolverAdapter, resolveComparisonSQL, resolveToSQL, resolveToSQLOptimized, supportsDimensionOnSurface };

package/dist/scope.d.mts

@@ -1,7 +1,7 @@
 import { SQL } from "drizzle-orm";
 /**
- * Structural subset of `ResolvedWindow` from `@gscdump/analysis/period`.
- * Inlined here so engine doesn't take a downstream dependency on analysis;
+ * Structural subset of `ResolvedWindow` from `@gscdump/engine/period`.
+ * Inlined here to avoid the cross-module type import in this leaf module;
  * any object with `start`/`end` strings (and optional `days`) satisfies it.
  */
 interface ResolvedWindow {
@@ -26,7 +26,7 @@ declare function buildTableScope(table: Record<string, any>, opts: ScopedRunnerO
 declare function mergeScope(scope: TableScope, ...extra: SQL[]): SQL | undefined;
 /**
  * Bind `buildTableScope` + `mergeScope` to a specific drizzle schema. Engine
- * adapters (`engine-sqlite`, `engine-wasm`) call this once at module load and
+ * adapters (`engine-sqlite`, `engine-duckdb-wasm`) call this once at module load and
  * re-export the returned `scopeFor` / `mergeScope` so consumers get a typed
  * `keyof Schema` table parameter without each adapter re-implementing the
  * pass-through wrapper.

package/dist/source/index.d.mts

@@ -0,0 +1,78 @@
+import { D as StorageEngine, P as TenantCtx, w as Row } from "../_chunks/storage.mjs";
+import { n as AnalysisResult, t as AnalysisParams } from "../_chunks/analysis-types.mjs";
+import { i as QueryRow, r as FileSet, s as SqlQuerySource, t as AnalysisQuerySource } from "../_chunks/source-types.mjs";
+import { t as AnalyzerRegistry } 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. The runner MUST coerce BIGINT → number and 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[];
+}
+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;
+/**
+ * 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;
+}
+/**
+ * Wraps a storage engine as a `SqlQuerySource`. `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): SqlQuerySource;
+/**
+ * Convenience: wrap a storage engine + tenant ctx in a source and dispatch.
+ * Equivalent to
+ * `runAnalyzerFromSource(createEngineQuerySource({ engine, ctx }), params, registry)`.
+ */
+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, type AttachedTableRunner, type AttachedTableSourceOptions, ENGINE_QUERY_CAPABILITIES, EngineQuerySourceOptions, TypedQuery, createAttachedTableSource, createEngineQuerySource, queryComparisonRows, queryRows, rewriteForTableSource, runAnalyzerWithEngine, typedQuery };

package/dist/source/index.mjs

@@ -0,0 +1,113 @@
+import { l as assertDimensionsSupported } from "../_chunks/pg-adapter.mjs";
+import { a as getFilterDimensions } from "../_chunks/resolver.mjs";
+import { n as runAnalyzerFromSource } from "../_chunks/dispatch.mjs";
+var AttachedTableMissingError = class extends Error {
+	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
+};
+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 } = options;
+	const attachedSet = attachedTables ? new Set(attachedTables) : null;
+	return {
+		name: "attached-table",
+		capabilities: ATTACHED_TABLE_CAPABILITIES,
+		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 await runner.query(rewritten, params ?? [], signal);
+		}
+	};
+}
+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,
+	localSource: true
+};
+function createEngineQuerySource(options) {
+	const { engine, ctx } = options;
+	return {
+		name: "engine",
+		capabilities: ENGINE_SOURCE_CAPABILITIES,
+		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 (await engine.query(ctx, 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 ?? []
+			});
+			return rows;
+		}
+	};
+}
+async function runAnalyzerWithEngine(deps, ctx, params, registry) {
+	return runAnalyzerFromSource(createEngineQuerySource({
+		engine: deps.engine,
+		ctx
+	}), 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, createAttachedTableSource, createEngineQuerySource, queryComparisonRows, queryRows, rewriteForTableSource, runAnalyzerWithEngine, typedQuery };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gscdump/engine",
   "type": "module",
-  "version": "0.7.1",
+  "version": "0.7.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",
@@ -23,91 +23,128 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.mts",
-      "import": "./dist/index.mjs"
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
     },
     "./contracts": {
       "types": "./dist/contracts.d.mts",
-      "import": "./dist/contracts.mjs"
+      "import": "./dist/contracts.mjs",
+      "default": "./dist/contracts.mjs"
     },
     "./snapshot": {
       "types": "./dist/snapshot.d.mts",
-      "import": "./dist/snapshot.mjs"
+      "import": "./dist/snapshot.mjs",
+      "default": "./dist/snapshot.mjs"
     },
     "./planner": {
       "types": "./dist/planner.d.mts",
-      "import": "./dist/planner.mjs"
+      "import": "./dist/planner.mjs",
+      "default": "./dist/planner.mjs"
     },
     "./schema": {
       "types": "./dist/schema.d.mts",
-      "import": "./dist/schema.mjs"
+      "import": "./dist/schema.mjs",
+      "default": "./dist/schema.mjs"
     },
     "./ingest": {
       "types": "./dist/ingest.d.mts",
-      "import": "./dist/ingest.mjs"
+      "import": "./dist/ingest.mjs",
+      "default": "./dist/ingest.mjs"
     },
     "./sql": {
       "types": "./dist/sql-bind.d.mts",
-      "import": "./dist/sql-bind.mjs"
+      "import": "./dist/sql-bind.mjs",
+      "default": "./dist/sql-bind.mjs"
     },
     "./sql-fragments": {
       "types": "./dist/sql-fragments.d.mts",
-      "import": "./dist/sql-fragments.mjs"
-    },
-    "./rollups": {
-      "types": "./dist/rollups.d.mts",
-      "import": "./dist/rollups.mjs"
+      "import": "./dist/sql-fragments.mjs",
+      "default": "./dist/sql-fragments.mjs"
     },
     "./entities": {
       "types": "./dist/entities.d.mts",
-      "import": "./dist/entities.mjs"
+      "import": "./dist/entities.mjs",
+      "default": "./dist/entities.mjs"
     },
     "./node": {
       "types": "./dist/adapters/duckdb-node.d.mts",
-      "import": "./dist/adapters/duckdb-node.mjs"
+      "import": "./dist/adapters/duckdb-node.mjs",
+      "default": "./dist/adapters/duckdb-node.mjs"
     },
     "./node-harness": {
       "types": "./dist/adapters/node-harness.d.mts",
-      "import": "./dist/adapters/node-harness.mjs"
+      "import": "./dist/adapters/node-harness.mjs",
+      "default": "./dist/adapters/node-harness.mjs"
     },
     "./filesystem": {
       "types": "./dist/adapters/filesystem.d.mts",
-      "import": "./dist/adapters/filesystem.mjs"
+      "import": "./dist/adapters/filesystem.mjs",
+      "default": "./dist/adapters/filesystem.mjs"
     },
     "./http": {
       "types": "./dist/adapters/http.d.mts",
-      "import": "./dist/adapters/http.mjs"
+      "import": "./dist/adapters/http.mjs",
+      "default": "./dist/adapters/http.mjs"
     },
     "./hyparquet": {
       "types": "./dist/adapters/hyparquet.d.mts",
-      "import": "./dist/adapters/hyparquet.mjs"
+      "import": "./dist/adapters/hyparquet.mjs",
+      "default": "./dist/adapters/hyparquet.mjs"
     },
     "./r2": {
       "types": "./dist/adapters/r2.d.mts",
-      "import": "./dist/adapters/r2.mjs"
+      "import": "./dist/adapters/r2.mjs",
+      "default": "./dist/adapters/r2.mjs"
     },
     "./r2-manifest": {
       "types": "./dist/adapters/r2-manifest.d.mts",
-      "import": "./dist/adapters/r2-manifest.mjs"
+      "import": "./dist/adapters/r2-manifest.mjs",
+      "default": "./dist/adapters/r2-manifest.mjs"
     },
     "./resolver": {
       "types": "./dist/resolver/index.d.mts",
-      "import": "./dist/resolver/index.mjs"
+      "import": "./dist/resolver/index.mjs",
+      "default": "./dist/resolver/index.mjs"
+    },
+    "./analyzer": {
+      "types": "./dist/analyzer/index.d.mts",
+      "import": "./dist/analyzer/index.mjs",
+      "default": "./dist/analyzer/index.mjs"
+    },
+    "./analysis-types": {
+      "types": "./dist/analysis-types.d.mts",
+      "import": "./dist/analysis-types.mjs",
+      "default": "./dist/analysis-types.mjs"
+    },
+    "./period": {
+      "types": "./dist/period/index.d.mts",
+      "import": "./dist/period/index.mjs",
+      "default": "./dist/period/index.mjs"
+    },
+    "./source": {
+      "types": "./dist/source/index.d.mts",
+      "import": "./dist/source/index.mjs",
+      "default": "./dist/source/index.mjs"
     },
     "./scope": {
       "types": "./dist/scope.d.mts",
-      "import": "./dist/scope.mjs"
+      "import": "./dist/scope.mjs",
+      "default": "./dist/scope.mjs"
     },
     "./arrow": {
       "types": "./dist/arrow-utils.d.mts",
-      "import": "./dist/arrow-utils.mjs"
+      "import": "./dist/arrow-utils.mjs",
+      "default": "./dist/arrow-utils.mjs"
     },
     "./inspection-sqlite-node": {
       "types": "./dist/adapters/inspection-sqlite-node.d.mts",
-      "import": "./dist/adapters/inspection-sqlite-node.mjs"
+      "import": "./dist/adapters/inspection-sqlite-node.mjs",
+      "default": "./dist/adapters/inspection-sqlite-node.mjs"
     },
     "./inspection-sqlite-browser": {
       "types": "./dist/adapters/inspection-sqlite-browser.d.mts",
-      "import": "./dist/adapters/inspection-sqlite-browser.mjs"
+      "import": "./dist/adapters/inspection-sqlite-browser.mjs",
+      "default": "./dist/adapters/inspection-sqlite-browser.mjs"
     }
   },
   "main": "./dist/index.mjs",
@@ -145,7 +182,7 @@
   "dependencies": {
     "drizzle-orm": "^0.45.2",
     "proper-lockfile": "^4.1.2",
-    "gscdump": "0.7.1"
+    "gscdump": "0.7.2"
   },
   "devDependencies": {
     "@duckdb/duckdb-wasm": "^1.32.0",