@gscdump/engine 0.19.0 → 0.19.2

package/dist/_chunks/engine.mjs

@@ -1,4 +1,4 @@
-import { r as currentSchemaVersion, t as SCHEMAS } from "./schema.mjs";
+import { i as dedupeByNaturalKey, r as currentSchemaVersion, t as SCHEMAS } from "./schema.mjs";
 import { a as inferSearchType, c as objectKey, d as tenantPrefix, n as dayPartition, r as hourPartition } from "./storage.mjs";
 import { c as dedupeOverlappingTiers, i as substituteNamedFiles, n as compileLogicalQueryPlan, o as compactTieredImpl } from "./parquet-plan.mjs";
 import { sqlEscape } from "../sql-bind.mjs";
@@ -57,7 +57,7 @@ function createDuckDBCodec(factory) {
 				const outName = db.makeTempPath("parquet");
 				const fileList = inputUris.map((u) => `'${sqlEscape(u)}'`).join(", ");
 				try {
-					await db.query(`COPY (SELECT * FROM read_parquet([${fileList}], union_by_name=true)) TO '${sqlEscape(outName)}' (FORMAT PARQUET)`);
+					await db.query(`COPY (${dedupedMergeSql(ctx.table, fileList)}) TO '${sqlEscape(outName)}' (FORMAT PARQUET)`);
 					const bytes = await db.copyFileToBuffer(outName);
 					const countRows = await db.query(`SELECT count(*)::BIGINT AS n FROM read_parquet('${sqlEscape(outName)}')`);
 					const rowCount = Number(countRows[0]?.n ?? 0);
@@ -82,7 +82,7 @@ function createDuckDBCodec(factory) {
 			}
 			try {
 				const fileList = inNames.map((n) => `'${sqlEscape(n)}'`).join(", ");
-				await db.query(`COPY (SELECT * FROM read_parquet([${fileList}], union_by_name = true)) TO '${sqlEscape(outName)}' (FORMAT PARQUET)`);
+				await db.query(`COPY (${dedupedMergeSql(ctx.table, fileList)}) TO '${sqlEscape(outName)}' (FORMAT PARQUET)`);
 				registered.push(outName);
 				const bytes = await db.copyFileToBuffer(outName);
 				const countRows = await db.query(`SELECT count(*)::BIGINT AS n FROM read_parquet('${sqlEscape(outName)}')`);
@@ -98,6 +98,12 @@ function createDuckDBCodec(factory) {
 		}
 	};
 }
+function dedupedMergeSql(table, fileListSql) {
+	const base = `SELECT * FROM read_parquet([${fileListSql}], union_by_name = true)`;
+	const key = SCHEMAS[table].sortKey;
+	if (key.length === 0) return base;
+	return `${base} QUALIFY row_number() OVER (PARTITION BY ${key.map((c) => `"${c.replace(/"/g, "\"\"")}"`).join(", ")}) = 1`;
+}
 function rewriteEmptyFileSets(sql, placeholders, defaultTable, placeholderTables) {
 	let out = sql;
 	for (const [name, keys] of Object.entries(placeholders)) {
@@ -273,6 +279,23 @@ function normalizeRow(table, row) {
 		url: normalized
 	};
 }
+const DAILY_PARTITION_RE = /^daily\/(\d{4}-\d{2}-\d{2})$/;
+function queryRangeOf(partitions) {
+	if (!partitions) return void 0;
+	let min;
+	let max;
+	for (const p of partitions) {
+		const m = DAILY_PARTITION_RE.exec(p);
+		if (!m) continue;
+		const d = m[1];
+		if (min === void 0 || d < min) min = d;
+		if (max === void 0 || d > max) max = d;
+	}
+	return min !== void 0 ? {
+		start: min,
+		end: max
+	} : void 0;
+}
 function createStorageEngine(opts) {
 	const { dataSource, manifestStore, codec, executor } = opts;
 	const defaultNow = opts.now ?? (() => Date.now());
@@ -295,7 +318,7 @@ function createStorageEngine(opts) {
 				partitions: [partition],
 				searchType: inferSearchType({ searchType })
 			});
-			const normalizedRows = rows.map((r) => normalizeRow(ctx.table, r));
+			const normalizedRows = dedupeByNaturalKey(ctx.table, rows.map((r) => normalizeRow(ctx.table, r)));
 			const key = objectKey(ctx, ctx.table, partition, now, searchType);
 			const { bytes: writtenBytes, rowCount } = await codec.writeRows({ table: ctx.table }, normalizedRows, key, dataSource);
 			let bytes = writtenBytes;
@@ -406,7 +429,7 @@ function createStorageEngine(opts) {
 				table: ref.table,
 				partitions: ref.partitions,
 				...opts.searchType !== void 0 ? { searchType: opts.searchType } : {}
-			})).map((e) => e.objectKey)];
+			}), queryRangeOf(ref.partitions)).map((e) => e.objectKey)];
 		}));
 		opts.signal?.throwIfAborted();
 		const fileKeys = {};

package/dist/_chunks/parquet-plan.mjs

@@ -1,4 +1,4 @@
-import { i as dimensionToColumn, r as currentSchemaVersion } from "./schema.mjs";
+import { a as dimensionToColumn, r as currentSchemaVersion } from "./schema.mjs";
 import { a as inferSearchType, c as objectKey, f as weekPartition, l as quarterOfMonth, n as dayPartition, o as mondayOfWeek, s as monthPartition, u as quarterPartition } from "./storage.mjs";
 import { METRIC_EXPR, escapeLike, topLevelPagePredicateSql } from "../sql-fragments.mjs";
 import { MS_PER_DAY } from "gscdump";
@@ -186,9 +186,12 @@ function partitionSpan(partition) {
 		};
 	}
 }
-function splitOverlappingTiers(entries) {
+function splitOverlappingTiers(entries, queryRange) {
+	const rangeStartMs = queryRange ? Date.parse(`${queryRange.start}T00:00:00Z`) : void 0;
+	const rangeEndMs = queryRange ? Date.parse(`${queryRange.end}T00:00:00Z`) : void 0;
 	const spanned = [];
 	const kept = [];
+	const subsumed = [];
 	for (const entry of entries) {
 		const span = partitionSpan(entry.partition);
 		if (!span) {
@@ -196,7 +199,14 @@ function splitOverlappingTiers(entries) {
 			continue;
 		}
 		const days = [];
-		for (let t = span.startMs; t <= span.endMs; t += MS_PER_DAY) days.push(t);
+		for (let t = span.startMs; t <= span.endMs; t += MS_PER_DAY) {
+			if (rangeStartMs !== void 0 && (t < rangeStartMs || t > rangeEndMs)) continue;
+			days.push(t);
+		}
+		if (queryRange && days.length === 0) {
+			subsumed.push(entry);
+			continue;
+		}
 		spanned.push({
 			entry,
 			rank: span.rank,
@@ -205,7 +215,6 @@ function splitOverlappingTiers(entries) {
 	}
 	spanned.sort((a, b) => a.rank - b.rank || b.entry.createdAt - a.entry.createdAt);
 	const coveredBySearchType = /* @__PURE__ */ new Map();
-	const subsumed = [];
 	for (const { entry, days } of spanned) {
 		const slice = inferSearchType(entry);
 		let covered = coveredBySearchType.get(slice);
@@ -225,8 +234,8 @@ function splitOverlappingTiers(entries) {
 		subsumed
 	};
 }
-function dedupeOverlappingTiers(entries) {
-	return splitOverlappingTiers(entries).kept;
+function dedupeOverlappingTiers(entries, queryRange) {
+	return splitOverlappingTiers(entries, queryRange).kept;
 }
 function monthEndMs(month) {
 	const [y, m] = month.split("-").map(Number);

package/dist/_chunks/resolver.mjs

@@ -1,9 +1,9 @@
-import { t as SCHEMAS, u as drizzleSchema } from "./schema.mjs";
+import { f as drizzleSchema, t as SCHEMAS } from "./schema.mjs";
 import { l as enumeratePartitions } from "./parquet-plan.mjs";
 import { escapeLike } from "../sql-fragments.mjs";
 import "../planner.mjs";
 import { PgDialect } from "drizzle-orm/pg-core";
-import { buildLogicalComparisonPlan, buildLogicalPlan } from "gscdump/query/plan";
+import { UnresolvableDatasetError, buildLogicalComparisonPlan, buildLogicalPlan, inferDataset as inferLogicalDataset, isDatasetResolvable } from "gscdump/query/plan";
 import { normalizeUrl } from "gscdump/normalize";
 import { sql } from "drizzle-orm";
 const DIMENSION_SURFACES = {
@@ -88,19 +88,22 @@ const LOGICAL_DATASETS = {
 			column: "date",
 			surfaces: ["api", "stored"]
 		}
+	} },
+	hourly_pages: { dimensions: {
+		page: {
+			column: "url",
+			surfaces: ["api", "stored"]
+		},
+		date: {
+			column: "date",
+			surfaces: ["api", "stored"]
+		},
+		hour: {
+			column: "hour",
+			surfaces: ["api", "stored"]
+		}
 	} }
 };
-function inferLogicalDataset(dimensions, filterDims = []) {
-	const allDims = new Set([...dimensions, ...filterDims]);
-	const has = (d) => allDims.has(d);
-	if (has("searchAppearance")) return "search_appearance";
-	if (has("page") && (has("query") || has("queryCanonical"))) return "page_keywords";
-	if (has("query") || has("queryCanonical")) return "keywords";
-	if (has("page")) return "pages";
-	if (has("country")) return "countries";
-	if (has("device")) return "devices";
-	return "devices";
-}
 function dimensionColumn(dim, dataset) {
 	return LOGICAL_DATASETS[dataset].dimensions[dim]?.column ?? dim;
 }
@@ -141,6 +144,7 @@ function createSqlFragments(config) {
 		return datasetToTableKey[dataset];
 	}
 	function inferTable(dimensions, filterDims = []) {
+		if (!isDatasetResolvable(dimensions, filterDims)) throw new UnresolvableDatasetError(dimensions, filterDims);
 		return tableKeyForDataset(inferLogicalDataset(dimensions, filterDims));
 	}
 	const urlToPathExpr = urlToPathExprOverride ?? defaultSqliteUrlToPathExpr;
@@ -735,7 +739,8 @@ const PG_BASE_CONFIG = {
 		page_keywords: "page_keywords",
 		countries: "countries",
 		devices: "devices",
-		search_appearance: "search_appearance"
+		search_appearance: "search_appearance",
+		hourly_pages: "hourly_pages"
 	},
 	metricCast: "DOUBLE",
 	regexPredicate: (expr, pattern, negate) => negate ? sql`NOT regexp_matches(${expr}, ${pattern})` : sql`regexp_matches(${expr}, ${pattern})`,
@@ -856,4 +861,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 { LOGICAL_DATASETS as C, supportsDimensionOnSurface as D, inferLogicalDataset as E, DIMENSION_SURFACES as S, dimensionColumn as T, resolveComparisonSQL as _, pgResolverAdapter as a, createResolverAdapter as b, getFilterDimensions as c, matchesMetricFilter as d, matchesTopLevelPage as f, mergeExtras as g, buildTotalsSql as h, createParquetResolverAdapter as i, getInternalFilters as l, buildExtrasQueries as m, runComparisonQuery as n, dimensionValue as o, metricValue as p, runOptimizedQuery as r, getDimensionFilters as s, assertSchemaInSync as t, matchesDimensionFilter as u, resolveToSQL as v, assertDimensionsSupported as w, createSqlFragments as x, resolveToSQLOptimized as y };
+export { LOGICAL_DATASETS as C, inferLogicalDataset as D, dimensionColumn as E, isDatasetResolvable as O, DIMENSION_SURFACES as S, assertDimensionsSupported as T, resolveComparisonSQL as _, pgResolverAdapter as a, createResolverAdapter as b, getFilterDimensions as c, matchesMetricFilter as d, matchesTopLevelPage as f, mergeExtras as g, buildTotalsSql as h, createParquetResolverAdapter as i, supportsDimensionOnSurface as k, getInternalFilters as l, buildExtrasQueries as m, runComparisonQuery as n, dimensionValue as o, metricValue as p, runOptimizedQuery as r, getDimensionFilters as s, assertSchemaInSync as t, matchesDimensionFilter as u, resolveToSQL as v, UnresolvableDatasetError as w, createSqlFragments as x, resolveToSQLOptimized as y };

package/dist/_chunks/schema.d.mts

@@ -1,4 +1,4 @@
-import { ColumnDef, ColumnType, TableName, TableSchema, TableSchema as TableSchema$1 } from "@gscdump/contracts";
+import { ColumnDef, ColumnType, Row, TableName, TableSchema, TableSchema as TableSchema$1 } from "@gscdump/contracts";
 declare const pages: import("drizzle-orm/pg-core").PgTableWithColumns<{
   name: "pages";
   schema: undefined;
@@ -1479,5 +1479,25 @@ declare function currentSchemaVersion(table: TableName): number;
 declare function schemaFor(table: TableName): TableSchema;
 declare function allTables(): readonly TableName[];
 declare function inferTable(dimensions: readonly string[]): TableName;
+/**
+ * Natural-key columns for a table: the `sortKey` dimensions that uniquely
+ * identify a metric row (e.g. `['date', 'url']` for `pages`).
+ */
+declare function naturalKeyColumns(table: TableName): readonly string[];
+/**
+ * Collapse rows that share a natural key (see {@link naturalKeyColumns}) to a
+ * single survivor.
+ *
+ * Correct write and compaction inputs never collide on the natural key — each
+ * (date, dimension) tuple is produced exactly once per slice — so on healthy
+ * data this is a no-op. It exists as a recurrence guard: the 2026-04 monthly
+ * compaction corruption folded a complete month back on top of its own daily
+ * inputs, doubling every row. Absorbing duplicates at every write/compaction
+ * boundary keeps that class of bug from inflating impressions downstream.
+ *
+ * Last occurrence wins. Observed duplicates are byte-identical, so the choice
+ * of survivor is immaterial.
+ */
+declare function dedupeByNaturalKey(table: TableName, rows: readonly Row[]): Row[];
 declare function dimensionToColumn(dim: string, _table: TableName): string;
-export { page_keywords as _, allTables as a, inferTable as c, TABLE_METADATA as d, countries as f, keywords as g, hourly_pages as h, TableSchema$1 as i, schemaFor as l, drizzleSchema as m, ColumnType as n, currentSchemaVersion as o, devices as p, SCHEMAS as r, dimensionToColumn as s, ColumnDef as t, DrizzleSchema as u, pages as v, search_appearance as y };
+export { hourly_pages as _, allTables as a, pages as b, dimensionToColumn as c, schemaFor as d, DrizzleSchema as f, drizzleSchema as g, devices as h, TableSchema$1 as i, inferTable as l, countries as m, ColumnType as n, currentSchemaVersion as o, TABLE_METADATA as p, SCHEMAS as r, dedupeByNaturalKey as s, ColumnDef as t, naturalKeyColumns as u, keywords as v, search_appearance as x, page_keywords as y };

package/dist/_chunks/schema.mjs

@@ -147,9 +147,23 @@ function inferTable(dimensions) {
 	if (dims.has("searchAppearance")) return "search_appearance";
 	return "devices";
 }
+function naturalKeyColumns(table) {
+	return TABLE_METADATA[table].sortKey;
+}
+function dedupeByNaturalKey(table, rows) {
+	const key = TABLE_METADATA[table].sortKey;
+	if (key.length === 0) return rows.slice();
+	const seen = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const r = row;
+		const k = key.map((col) => `${r[col] ?? ""}`).join("\0");
+		seen.set(k, row);
+	}
+	return [...seen.values()];
+}
 function dimensionToColumn(dim, _table) {
 	if (dim === "page") return "url";
 	if (dim === "queryCanonical") return "query_canonical";
 	return dim;
 }
-export { inferTable as a, countries as c, hourly_pages as d, keywords as f, search_appearance as h, dimensionToColumn as i, devices as l, pages as m, allTables as n, schemaFor as o, page_keywords as p, currentSchemaVersion as r, TABLE_METADATA as s, SCHEMAS as t, drizzleSchema as u };
+export { search_appearance as _, dimensionToColumn as a, schemaFor as c, devices as d, drizzleSchema as f, pages as g, page_keywords as h, dedupeByNaturalKey as i, TABLE_METADATA as l, keywords as m, allTables as n, inferTable as o, hourly_pages as p, currentSchemaVersion as r, naturalKeyColumns as s, SCHEMAS as t, countries as u };

package/dist/_chunks/storage.d.mts

@@ -38,13 +38,27 @@ declare function enumeratePartitions(startDate: string, endDate: string): string
  * monthly) still double-counts those boundary days — eliminating that needs
  * per-file date predicates in the SQL, tracked separately. Unrecognised
  * partition shapes (`hourly/`, sidecar keys) are always kept.
+ *
+ * `queryRange` clamps every entry's day-span to the window the caller will
+ * actually read. This is required when `entries` came from a partition-
+ * filtered `listLive` (`runSQL` enumerates only the partitions intersecting
+ * the query): a `monthly/2026-04` whose Apr 27-30 falls past the query end
+ * must not be judged "unsubsumed" just because `weekly/2026-04-27` wasn't
+ * enumerated — those out-of-window days are SQL-filtered to nothing anyway.
+ * Omit `queryRange` when `entries` is the full manifest (e.g. analysis-sources).
  */
-declare function splitOverlappingTiers(entries: ManifestEntry[]): {
+declare function splitOverlappingTiers(entries: ManifestEntry[], queryRange?: {
+  start: string;
+  end: string;
+}): {
   kept: ManifestEntry[];
   subsumed: ManifestEntry[];
 };
 /** Entries worth reading — see {@link splitOverlappingTiers}. */
-declare function dedupeOverlappingTiers(entries: ManifestEntry[]): ManifestEntry[];
+declare function dedupeOverlappingTiers(entries: ManifestEntry[], queryRange?: {
+  start: string;
+  end: string;
+}): ManifestEntry[];
 /**
  * Default `searchType` for entries written before the field landed and for
  * sync paths that don't request a specific type. GSC's own default; the

package/dist/adapters/hyparquet.mjs

@@ -1,4 +1,4 @@
-import { s as TABLE_METADATA, t as SCHEMAS } from "../_chunks/schema.mjs";
+import { i as dedupeByNaturalKey, l as TABLE_METADATA, t as SCHEMAS } from "../_chunks/schema.mjs";
 import { parquetReadObjects } from "hyparquet";
 import { parquetWriteBuffer } from "hyparquet-writer";
 const ROW_GROUP_SIZE = 25e3;
@@ -134,11 +134,12 @@ function createHyparquetCodec(options = {}) {
 				const rows = await decodeParquetToRows(await dataSource.read(key));
 				allRows.push(...rows);
 			}
-			const bytes = encodeRowsToParquet(ctx.table, allRows);
+			const rows = dedupeByNaturalKey(ctx.table, allRows);
+			const bytes = encodeRowsToParquet(ctx.table, rows);
 			await dataSource.write(outputKey, bytes);
 			return {
 				bytes: bytes.byteLength,
-				rowCount: allRows.length
+				rowCount: rows.length
 			};
 		}
 	};

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 import { A as SyncStateKind, B as hourPartition, C as Row, D as SyncState, E as StorageEngine, F as WatermarkFilter, G as RAW_DAILY_COMPACT_THRESHOLD, H as inferSearchType, I as WatermarkScope, J as enumeratePartitions, K as countRawDailies, L as WriteCtx, M as TableName, N as TenantCtx, O as SyncStateDetail, P as Watermark, R as WriteResult, S as QueryResult, T as SearchType, U as objectKey, V as inferLegacyTier, W as CompactionThresholds, Y as splitOverlappingTiers, _ as PurgeUrlsResult, a as EngineOptions, b as QueryExecuteResult, c as Grain, d as ManifestEntry, f as ManifestPurgeResult, g as PurgeResult, h as PurgeFilter, i as DataSource, j as SyncStateScope, k as SyncStateFilter, l as ListLiveFilter, m as ParquetCodec, n as CompactionTier, o as FileSetRef, p as ManifestStore, q as dedupeOverlappingTiers, r as DEFAULT_SEARCH_TYPE, s as GcCtx, t as CodecCtx, u as LockScope, v as QueryCtx, w as RunSQLOptions, x as QueryExecutor, y as QueryExecuteOptions, z as dayPartition } from "./_chunks/storage.mjs";
 import { a as createDuckDBExecutor, i as createDuckDBCodec, n as DuckDBHandle, r as canonicalEmptyParquetSchema, t as DuckDBFactory } from "./_chunks/duckdb.mjs";
-import { _ as page_keywords, a as allTables, c as inferTable, d as TABLE_METADATA, f as countries, g as keywords, h as hourly_pages, i as TableSchema, m as drizzleSchema, n as ColumnType, o as currentSchemaVersion, p as devices, r as SCHEMAS, s as dimensionToColumn, t as ColumnDef, u as DrizzleSchema, v as pages } from "./_chunks/schema.mjs";
+import { _ as hourly_pages, a as allTables, b as pages, c as dimensionToColumn, f as DrizzleSchema, g as drizzleSchema, h as devices, i as TableSchema, l as inferTable, m as countries, n as ColumnType, o as currentSchemaVersion, p as TABLE_METADATA, r as SCHEMAS, t as ColumnDef, v as keywords, y as page_keywords } from "./_chunks/schema.mjs";
 import { InspectionVerdict, SchedulePolicy, ScheduleState, fixedPolicy, inspectionPolicy, sitemapPolicy } from "./schedule.mjs";
 import { GscApiRow, IngestOptions, RowAccumulator, RowAccumulatorOptions, createRowAccumulator, toPath, toSumPosition, transformGscRow } from "./ingest.mjs";
 import { a as substituteNamedFiles, i as resolveParquetSQL, n as ResolvedQuery, t as FILES_PLACEHOLDER } from "./_chunks/planner.mjs";

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { n as coerceRows, t as coerceRow } from "./_chunks/coerce.mjs";
-import { a as inferTable, c as countries, d as hourly_pages, f as keywords, i as dimensionToColumn, l as devices, m as pages, n as allTables, p as page_keywords, r as currentSchemaVersion, s as TABLE_METADATA, t as SCHEMAS, u as drizzleSchema } from "./_chunks/schema.mjs";
+import { a as dimensionToColumn, d as devices, f as drizzleSchema, g as pages, h as page_keywords, l as TABLE_METADATA, m as keywords, n as allTables, o as inferTable, p as hourly_pages, r as currentSchemaVersion, t as SCHEMAS, u as countries } from "./_chunks/schema.mjs";
 import { a as inferSearchType, c as objectKey, i as inferLegacyTier, n as dayPartition, r as hourPartition, t as DEFAULT_SEARCH_TYPE } from "./_chunks/storage.mjs";
 import { a as RAW_DAILY_COMPACT_THRESHOLD, c as dedupeOverlappingTiers, i as substituteNamedFiles, l as enumeratePartitions, r as resolveParquetSQL, s as countRawDailies, t as FILES_PLACEHOLDER, u as splitOverlappingTiers } from "./_chunks/parquet-plan.mjs";
 import { bindLiterals, formatLiteral } from "./sql-bind.mjs";

package/dist/resolver/index.d.mts

@@ -1,6 +1,6 @@
 import { M as TableName$1, T as SearchType$1 } from "../_chunks/storage.mjs";
 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 { LogicalDataset, LogicalDataset as LogicalDataset$1, PlannerCapabilities } from "gscdump/query/plan";
+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";
 import { BuilderState, Dimension, FilterInput, InternalFilter, Metric } from "gscdump/query";
@@ -14,7 +14,6 @@ interface LogicalDatasetDefinition {
 }
 declare const DIMENSION_SURFACES: Record<Dimension, readonly DimensionSurface[]>;
 declare const LOGICAL_DATASETS: Record<LogicalDataset, LogicalDatasetDefinition>;
-declare function inferLogicalDataset(dimensions: readonly Dimension[], filterDims?: readonly Dimension[]): LogicalDataset;
 declare function dimensionColumn(dim: Dimension, dataset: LogicalDataset): string;
 declare function supportsDimensionOnSurface(dim: Dimension, surface: DimensionSurface): boolean;
 declare function assertDimensionsSupported(dimensions: readonly Dimension[], surface: DimensionSurface, context: string): void;
@@ -175,4 +174,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, assertDimensionsSupported, assertSchemaInSync, buildExtrasQueries, buildTotalsSql, createParquetResolverAdapter, createResolverAdapter, createSqlFragments, dimensionColumn, dimensionValue, getDimensionFilters, getFilterDimensions, getInternalFilters, inferLogicalDataset, 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, 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 { C as LOGICAL_DATASETS, D as supportsDimensionOnSurface, E as inferLogicalDataset, S as DIMENSION_SURFACES, T as dimensionColumn, _ as resolveComparisonSQL, a as pgResolverAdapter, b as createResolverAdapter, c as getFilterDimensions, d as matchesMetricFilter, f as matchesTopLevelPage, g as mergeExtras, h as buildTotalsSql, i as createParquetResolverAdapter, l as getInternalFilters, m as buildExtrasQueries, n as runComparisonQuery, o as dimensionValue, p as metricValue, r as runOptimizedQuery, s as getDimensionFilters, t as assertSchemaInSync, u as matchesDimensionFilter, v as resolveToSQL, w as assertDimensionsSupported, x as createSqlFragments, y as resolveToSQLOptimized } from "../_chunks/resolver.mjs";
-export { DIMENSION_SURFACES, LOGICAL_DATASETS, assertDimensionsSupported, assertSchemaInSync, buildExtrasQueries, buildTotalsSql, createParquetResolverAdapter, createResolverAdapter, createSqlFragments, dimensionColumn, dimensionValue, getDimensionFilters, getFilterDimensions, getInternalFilters, inferLogicalDataset, matchesDimensionFilter, matchesMetricFilter, matchesTopLevelPage, mergeExtras, metricValue, pgResolverAdapter, resolveComparisonSQL, resolveToSQL, resolveToSQLOptimized, runComparisonQuery, runOptimizedQuery, supportsDimensionOnSurface };
+import { C as LOGICAL_DATASETS, D as inferLogicalDataset, E as dimensionColumn, O as isDatasetResolvable, S as DIMENSION_SURFACES, T as assertDimensionsSupported, _ as resolveComparisonSQL, a as pgResolverAdapter, b as createResolverAdapter, c as getFilterDimensions, d as matchesMetricFilter, f as matchesTopLevelPage, g as mergeExtras, h as buildTotalsSql, i as createParquetResolverAdapter, k as supportsDimensionOnSurface, l as getInternalFilters, m as buildExtrasQueries, n as runComparisonQuery, o as dimensionValue, p as metricValue, r as runOptimizedQuery, s as getDimensionFilters, t as assertSchemaInSync, u as matchesDimensionFilter, v as resolveToSQL, w as UnresolvableDatasetError, x as createSqlFragments, y as resolveToSQLOptimized } 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 };

package/dist/schema.d.mts

@@ -1,2 +1,2 @@
-import { _ as page_keywords, a as allTables, c as inferTable, d as TABLE_METADATA, f as countries, g as keywords, h as hourly_pages, i as TableSchema, l as schemaFor, m as drizzleSchema, n as ColumnType, o as currentSchemaVersion, p as devices, r as SCHEMAS, s as dimensionToColumn, t as ColumnDef, u as DrizzleSchema, v as pages, y as search_appearance } from "./_chunks/schema.mjs";
-export { type ColumnDef, type ColumnType, type DrizzleSchema, SCHEMAS, TABLE_METADATA, type TableSchema, allTables, countries, currentSchemaVersion, devices, dimensionToColumn, drizzleSchema, hourly_pages, inferTable, keywords, page_keywords, pages, schemaFor, search_appearance };
+import { _ as hourly_pages, a as allTables, b as pages, c as dimensionToColumn, d as schemaFor, f as DrizzleSchema, g as drizzleSchema, h as devices, i as TableSchema, l as inferTable, m as countries, n as ColumnType, o as currentSchemaVersion, p as TABLE_METADATA, r as SCHEMAS, s as dedupeByNaturalKey, t as ColumnDef, u as naturalKeyColumns, v as keywords, x as search_appearance, y as page_keywords } from "./_chunks/schema.mjs";
+export { type ColumnDef, type ColumnType, type DrizzleSchema, SCHEMAS, TABLE_METADATA, type TableSchema, allTables, countries, currentSchemaVersion, dedupeByNaturalKey, devices, dimensionToColumn, drizzleSchema, hourly_pages, inferTable, keywords, naturalKeyColumns, page_keywords, pages, schemaFor, search_appearance };

package/dist/schema.mjs

@@ -1,2 +1,2 @@
-import { a as inferTable, c as countries, d as hourly_pages, f as keywords, h as search_appearance, i as dimensionToColumn, l as devices, m as pages, n as allTables, o as schemaFor, p as page_keywords, r as currentSchemaVersion, s as TABLE_METADATA, t as SCHEMAS, u as drizzleSchema } from "./_chunks/schema.mjs";
-export { SCHEMAS, TABLE_METADATA, allTables, countries, currentSchemaVersion, devices, dimensionToColumn, drizzleSchema, hourly_pages, inferTable, keywords, page_keywords, pages, schemaFor, search_appearance };
+import { _ as search_appearance, a as dimensionToColumn, c as schemaFor, d as devices, f as drizzleSchema, g as pages, h as page_keywords, i as dedupeByNaturalKey, l as TABLE_METADATA, m as keywords, n as allTables, o as inferTable, p as hourly_pages, r as currentSchemaVersion, s as naturalKeyColumns, t as SCHEMAS, u as countries } from "./_chunks/schema.mjs";
+export { SCHEMAS, TABLE_METADATA, allTables, countries, currentSchemaVersion, dedupeByNaturalKey, devices, dimensionToColumn, drizzleSchema, hourly_pages, inferTable, keywords, naturalKeyColumns, page_keywords, pages, schemaFor, search_appearance };

package/dist/source/index.mjs

@@ -1,5 +1,5 @@
 import { n as coerceRows } from "../_chunks/coerce.mjs";
-import { a as pgResolverAdapter, c as getFilterDimensions, v as resolveToSQL, w as assertDimensionsSupported } from "../_chunks/resolver.mjs";
+import { T as assertDimensionsSupported, a as pgResolverAdapter, c as getFilterDimensions, v as resolveToSQL } from "../_chunks/resolver.mjs";
 import { n as runAnalyzerFromSource } from "../_chunks/dispatch.mjs";
 var AttachedTableMissingError = class extends Error {
 	missing;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gscdump/engine",
   "type": "module",
-  "version": "0.19.0",
+  "version": "0.19.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",
@@ -169,8 +169,8 @@
   "dependencies": {
     "drizzle-orm": "^0.45.2",
     "proper-lockfile": "^4.1.2",
-    "gscdump": "0.19.0",
-    "@gscdump/contracts": "0.19.0"
+    "gscdump": "0.19.2",
+    "@gscdump/contracts": "0.19.2"
   },
   "devDependencies": {
     "@duckdb/duckdb-wasm": "^1.32.0",