@gscdump/engine 0.40.2 → 1.0.1

package/dist/_chunks/parquet-plan.mjs

@@ -1,7 +1,252 @@
-import { dimensionToColumn } from "./schema.mjs";
-import { enumeratePartitions } from "./compaction.mjs";
+import { dayPartition, inferSearchType, mondayOfWeek, monthPartition, objectKey, quarterOfMonth, quarterPartition, weekPartition } from "./layout.mjs";
+import { currentSchemaVersion, dimensionToColumn } from "./schema.mjs";
 import { METRIC_EXPR, escapeLike, topLevelPagePredicateSql } from "../sql-fragments.mjs";
+import { MS_PER_DAY } from "gscdump/dates";
 import { buildLogicalPlan } from "gscdump/query/plan";
+const DAILY_PARTITION_RE = /^daily\/(\d{4}-\d{2}-\d{2})$/;
+const WEEKLY_PARTITION_RE = /^weekly\/(\d{4}-\d{2}-\d{2})$/;
+const MONTHLY_PARTITION_RE = /^monthly\/(\d{4}-\d{2})$/;
+const QUARTERLY_PARTITION_RE = /^quarterly\/(\d{4})-Q([1-4])$/;
+const DEFAULT_THRESHOLDS = {
+	raw: 7,
+	d7: 30,
+	d30: 90
+};
+const PENDING_WINDOW_DAYS = 4;
+const STAGES = [
+	{
+		inputTier: "raw",
+		outputTier: "d7",
+		cutoffDays: DEFAULT_THRESHOLDS.raw,
+		bucketKey: (e) => {
+			const m = e.partition.match(DAILY_PARTITION_RE);
+			if (!m) return void 0;
+			return mondayOfWeek(m[1]);
+		},
+		bucketLatestMs: (monday) => Date.parse(`${monday}T00:00:00Z`) + 6 * MS_PER_DAY,
+		outputPartition: weekPartition
+	},
+	{
+		inputTier: "d7",
+		outputTier: "d30",
+		cutoffDays: DEFAULT_THRESHOLDS.d7,
+		bucketKey: (e) => {
+			const m = e.partition.match(WEEKLY_PARTITION_RE);
+			if (!m) return void 0;
+			return m[1].slice(0, 7);
+		},
+		bucketLatestMs: monthEndMs,
+		outputPartition: monthPartition
+	},
+	{
+		inputTier: "d30",
+		outputTier: "d90",
+		cutoffDays: DEFAULT_THRESHOLDS.d30,
+		bucketKey: (e) => {
+			const m = e.partition.match(MONTHLY_PARTITION_RE);
+			if (!m) return void 0;
+			return quarterOfMonth(m[1]);
+		},
+		bucketLatestMs: quarterEndMs,
+		outputPartition: quarterPartition
+	}
+];
+async function compactTieredImpl(deps, ctx, now, overrides = {}) {
+	const thresholds = {
+		...DEFAULT_THRESHOLDS,
+		...overrides
+	};
+	const stagesWithThresholds = STAGES.map((s) => ({
+		...s,
+		cutoffDays: s.outputTier === "d7" ? thresholds.raw : s.outputTier === "d30" ? thresholds.d7 : thresholds.d30
+	}));
+	for (const stage of stagesWithThresholds) await runStage(deps, ctx, stage, now);
+}
+async function runStage(deps, ctx, stage, now) {
+	const cutoff = now - Math.max(stage.cutoffDays, PENDING_WINDOW_DAYS) * MS_PER_DAY;
+	const candidates = await deps.manifestStore.listLive({
+		userId: ctx.userId,
+		siteId: ctx.siteId,
+		table: ctx.table,
+		tier: stage.inputTier
+	});
+	const buckets = /* @__PURE__ */ new Map();
+	for (const entry of candidates) {
+		if (entry.partition.startsWith("hourly/")) continue;
+		const key = stage.bucketKey(entry);
+		if (!key) continue;
+		if (stage.bucketLatestMs(key) >= cutoff) continue;
+		const compositeKey = `${inferSearchType(entry)}\0${key}`;
+		if (!buckets.has(compositeKey)) buckets.set(compositeKey, []);
+		buckets.get(compositeKey).push(entry);
+	}
+	for (const [compositeKey, entries] of buckets) {
+		const [searchType, bucket] = compositeKey.split("\0");
+		const targetPartition = stage.outputPartition(bucket);
+		if (entries.length === 1 && entries[0].partition === targetPartition) continue;
+		await deps.manifestStore.withLock({
+			userId: ctx.userId,
+			siteId: ctx.siteId,
+			table: ctx.table,
+			partition: targetPartition
+		}, async () => {
+			const key = objectKey(ctx, ctx.table, targetPartition, now, searchType);
+			const { bytes, rowCount } = await deps.codec.compactRows({ table: ctx.table }, entries.map((e) => e.objectKey), key, deps.dataSource);
+			const newEntry = {
+				userId: ctx.userId,
+				siteId: ctx.siteId,
+				table: ctx.table,
+				partition: targetPartition,
+				objectKey: key,
+				rowCount,
+				bytes,
+				createdAt: now,
+				schemaVersion: currentSchemaVersion(ctx.table),
+				tier: stage.outputTier,
+				...searchType !== "web" ? { searchType } : {}
+			};
+			await deps.manifestStore.registerVersion(newEntry, entries);
+		});
+	}
+}
+function enumeratePartitions(startDate, endDate) {
+	const out = [];
+	const [sy, sm, sd] = startDate.split("-").map(Number);
+	const [ey, em, ed] = endDate.split("-").map(Number);
+	const start = Date.UTC(sy, sm - 1, sd);
+	const end = Date.UTC(ey, em - 1, ed);
+	if (end < start) return out;
+	const seenWeeks = /* @__PURE__ */ new Set();
+	const seenMonths = /* @__PURE__ */ new Set();
+	const seenQuarters = /* @__PURE__ */ new Set();
+	for (let t = start; t <= end; t += 864e5) {
+		const d = new Date(t);
+		const y = d.getUTCFullYear();
+		const m = String(d.getUTCMonth() + 1).padStart(2, "0");
+		const isoDay = `${y}-${m}-${String(d.getUTCDate()).padStart(2, "0")}`;
+		const isoMonth = `${y}-${m}`;
+		out.push(dayPartition(isoDay));
+		const monday = mondayOfWeek(isoDay);
+		if (!seenWeeks.has(monday)) {
+			seenWeeks.add(monday);
+			out.push(weekPartition(monday));
+		}
+		if (!seenMonths.has(isoMonth)) {
+			seenMonths.add(isoMonth);
+			out.push(monthPartition(isoMonth));
+		}
+		const quarter = quarterOfMonth(isoMonth);
+		if (!seenQuarters.has(quarter)) {
+			seenQuarters.add(quarter);
+			out.push(quarterPartition(quarter));
+		}
+	}
+	return out;
+}
+function partitionSpan(partition) {
+	let m = partition.match(DAILY_PARTITION_RE);
+	if (m) {
+		const ms = Date.parse(`${m[1]}T00:00:00Z`);
+		return {
+			rank: 0,
+			startMs: ms,
+			endMs: ms
+		};
+	}
+	m = partition.match(WEEKLY_PARTITION_RE);
+	if (m) {
+		const ms = Date.parse(`${m[1]}T00:00:00Z`);
+		return {
+			rank: 1,
+			startMs: ms,
+			endMs: ms + 6 * MS_PER_DAY
+		};
+	}
+	m = partition.match(MONTHLY_PARTITION_RE);
+	if (m) {
+		const [y, mo] = m[1].split("-").map(Number);
+		return {
+			rank: 2,
+			startMs: Date.UTC(y, mo - 1, 1),
+			endMs: Date.UTC(y, mo, 0)
+		};
+	}
+	m = partition.match(QUARTERLY_PARTITION_RE);
+	if (m) {
+		const y = Number(m[1]);
+		const q = Number(m[2]);
+		return {
+			rank: 3,
+			startMs: Date.UTC(y, (q - 1) * 3, 1),
+			endMs: Date.UTC(y, q * 3, 0)
+		};
+	}
+}
+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 = [];
+	const clampToRange = Number.isFinite(rangeStartMs) && Number.isFinite(rangeEndMs);
+	for (const entry of entries) {
+		const span = partitionSpan(entry.partition);
+		if (!span) {
+			kept.push(entry);
+			continue;
+		}
+		const startMs = clampToRange ? Math.max(span.startMs, rangeStartMs) : span.startMs;
+		const endMs = clampToRange ? Math.min(span.endMs, rangeEndMs) : span.endMs;
+		if (queryRange && startMs > endMs) {
+			subsumed.push(entry);
+			continue;
+		}
+		spanned.push({
+			entry,
+			rank: span.rank,
+			startMs,
+			endMs
+		});
+	}
+	spanned.sort((a, b) => a.rank - b.rank || b.entry.createdAt - a.entry.createdAt);
+	const coveredBySearchType = /* @__PURE__ */ new Map();
+	for (const { entry, startMs, endMs } of spanned) {
+		const slice = inferSearchType(entry);
+		let covered = coveredBySearchType.get(slice);
+		if (!covered) {
+			covered = /* @__PURE__ */ new Set();
+			coveredBySearchType.set(slice, covered);
+		}
+		let fullyCovered = true;
+		for (let dayMs = startMs; dayMs <= endMs; dayMs += MS_PER_DAY) if (!covered.has(dayMs)) {
+			fullyCovered = false;
+			break;
+		}
+		if (fullyCovered) {
+			subsumed.push(entry);
+			continue;
+		}
+		kept.push(entry);
+		for (let dayMs = startMs; dayMs <= endMs; dayMs += MS_PER_DAY) covered.add(dayMs);
+	}
+	return {
+		kept,
+		subsumed
+	};
+}
+function dedupeOverlappingTiers(entries, queryRange) {
+	return splitOverlappingTiers(entries, queryRange).kept;
+}
+function monthEndMs(month) {
+	const [y, m] = month.split("-").map(Number);
+	return Date.UTC(y, m, 0, 23, 59, 59, 999);
+}
+function quarterEndMs(quarter) {
+	const [yStr, qStr] = quarter.split("-Q");
+	const y = Number(yStr);
+	const q = Number(qStr);
+	return Date.UTC(y, q * 3, 0, 23, 59, 59, 999);
+}
 const FILES_PLACEHOLDER = "{{FILES}}";
 function buildDimensionWhere(filters, table) {
 	const clauses = [];
@@ -136,4 +381,4 @@ function substituteNamedFiles(sql, sets) {
 	for (const [name, keys] of Object.entries(sets)) out = out.replace(new RegExp(`\\{\\{${name}\\}\\}`, "g"), fileList(keys));
 	return out;
 }
-export { FILES_PLACEHOLDER, compileLogicalQueryPlan, resolveParquetSQL, substituteNamedFiles };
+export { FILES_PLACEHOLDER, compactTieredImpl, compileLogicalQueryPlan, dedupeOverlappingTiers, enumeratePartitions, resolveParquetSQL, splitOverlappingTiers, substituteNamedFiles };

package/dist/_chunks/resolver.mjs

@@ -1,5 +1,5 @@
 import { SCHEMAS, drizzleSchema } from "./schema.mjs";
-import { enumeratePartitions } from "./compaction.mjs";
+import { enumeratePartitions } from "./parquet-plan.mjs";
 import { escapeLike } from "../sql-fragments.mjs";
 import "../planner.mjs";
 import { DEFAULT_PARTITION_KEY_ENCODING } from "./schema2.mjs";
@@ -7,6 +7,7 @@ import { UnresolvableDatasetError, buildLogicalComparisonPlan, buildLogicalPlan,
 import { PgDialect, pgTable, varchar } from "drizzle-orm/pg-core";
 import { normalizeUrl } from "gscdump/normalize";
 import { sql } from "drizzle-orm";
+import { and as and$1, gte as gte$1, impressions } from "gscdump/query";
 const DIMENSION_SURFACES = {
 	page: ["api", "stored"],
 	query: ["api", "stored"],
@@ -523,6 +524,16 @@ function joinComma(parts) {
 	return sql.join(parts, sql`, `);
 }
 const ORDER_BY_HELPER_PREFIX = "__order_";
+function withMinimumImpressions(state, options) {
+	if (options.minimumImpressions === void 0) return state;
+	const minimum = Number(options.minimumImpressions);
+	if (!Number.isFinite(minimum) || minimum < 0) throw new RangeError("minimumImpressions must be a finite non-negative number");
+	const guard = gte$1(impressions, minimum);
+	return {
+		...state,
+		prefilter: state.prefilter ? and$1(state.prefilter, guard) : guard
+	};
+}
 function orderByClause(state, prefix = "", columnOverride) {
 	if (state.orderBy) {
 		const safeCol = (columnOverride ?? state.orderBy.column).replace(/\W/g, "");
@@ -628,6 +639,7 @@ function compileCollapsed(adapter, q) {
 	};
 }
 function resolveToSQLOptimized(state, options) {
+	state = withMinimumImpressions(state, options);
 	const { adapter } = options;
 	const { tableKey, groupByDims, hasDate, metrics, wherePredicates, having, queryCanonicalUsed } = buildScope(state, options);
 	const table = adapter.fromSql(tableKey, { queryCanonical: queryCanonicalUsed });
@@ -695,6 +707,7 @@ function resolveToSQLOptimized(state, options) {
 	return compileCollapsed(adapter, sql`WITH aggregated AS (${cte}) SELECT ${joinComma(outerSelect)} FROM aggregated ${orderByClause(state, "", orderByColumnOverride)} ${limitOffsetClause(state)}`);
 }
 function resolveToSQL(state, options) {
+	state = withMinimumImpressions(state, options);
 	const { adapter } = options;
 	const { tableKey, groupByDims, hasDate, metrics, wherePredicates, having, queryCanonicalUsed } = buildScope(state, options);
 	const table = adapter.fromSql(tableKey, { queryCanonical: queryCanonicalUsed });
@@ -729,6 +742,7 @@ function resolveToSQL(state, options) {
 	};
 }
 function buildTotalsSql(state, options) {
+	state = withMinimumImpressions(state, options);
 	const { adapter } = options;
 	const { tableKey, metrics, wherePredicates, queryCanonicalUsed } = buildScope(state, options);
 	const table = adapter.fromSql(tableKey, { queryCanonical: queryCanonicalUsed });
@@ -1203,4 +1217,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, QuerySourceCoverageError, UnresolvableDatasetError, assertDimensionsSupported, assertSchemaInSync, buildExtrasQueries, buildTotalsSql, canonicalRollupCovers, createIcebergResolverAdapter, createParquetResolverAdapter, createR2SqlResolverAdapter, createResolverAdapter, createRollupExtrasOverlay, createSqlFragments, dimensionColumn, dimensionValue, getDimensionFilters, getFilterDimensions, getInternalFilters, inferLogicalDataset, isDatasetResolvable, matchesDimensionFilter, matchesMetricFilter, matchesTopLevelPage, mergeExtras, metricValue, pgResolverAdapter, planCoveredByCanonicalRollup, resolveComparisonSQL, resolveToSQL, resolveToSQLOptimized, runComparisonQuery, runOptimizedQuery, supportsDimensionOnSurface };
+export { DIMENSION_SURFACES, LOGICAL_DATASETS, QuerySourceCoverageError, UnresolvableDatasetError, assertDimensionsSupported, assertSchemaInSync, buildExtrasQueries, buildTotalsSql, canonicalRollupCovers, createIcebergResolverAdapter, createParquetResolverAdapter, createR2SqlResolverAdapter, createResolverAdapter, createRollupExtrasOverlay, createSqlFragments, dimensionColumn, dimensionValue, getDimensionFilters, getFilterDimensions, getInternalFilters, inferLogicalDataset, isDatasetResolvable, matchesDimensionFilter, matchesMetricFilter, matchesTopLevelPage, mergeExtras, metricValue, pgResolverAdapter, resolveComparisonSQL, resolveToSQL, resolveToSQLOptimized, runComparisonQuery, runOptimizedQuery, supportsDimensionOnSurface };

package/dist/_chunks/schema.d.mts

@@ -1,4 +1,4 @@
-import { ColumnDef as ColumnDef$1, ColumnType, Row, 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;
@@ -2145,4 +2145,4 @@ declare function naturalKeyColumns(table: TableName): readonly string[];
  */
 declare function dedupeByNaturalKey(table: TableName, rows: readonly Row[]): Row[];
 declare function dimensionToColumn(dim: string, _table: TableName): string;
-export { type ColumnDef$1 as ColumnDef, type ColumnType, DrizzleSchema, SCHEMAS, TABLE_METADATA, type TableSchema$1 as TableSchema, allTables, countries, currentSchemaVersion, dateColumnsFor, dates, dedupeByNaturalKey, dimensionToColumn, drizzleSchema, hourly_pages, inferTable, naturalKeyColumns, page_queries, pages, queries, search_appearance, search_appearance_page_queries, search_appearance_pages, search_appearance_queries };
+export { type ColumnDef, type ColumnType, DrizzleSchema, SCHEMAS, TABLE_METADATA, type TableSchema$1 as TableSchema, allTables, countries, currentSchemaVersion, dateColumnsFor, dates, dedupeByNaturalKey, dimensionToColumn, drizzleSchema, hourly_pages, inferTable, naturalKeyColumns, page_queries, pages, queries, search_appearance, search_appearance_page_queries, search_appearance_pages, search_appearance_queries };

package/dist/_chunks/sink.d.mts

@@ -1,9 +1,8 @@
 import { Row as Row$1, SearchType, TenantCtx as TenantCtx$1 } from "./storage.mjs";
 import { EngineError } from "./errors.mjs";
 import { icebergCreateTable } from "./libs/icebird.mjs";
-import { CatalogCache, CommitRetryOptions, ConnectIcebergOptions, DEFAULT_PARTITION_KEY_ENCODING as DEFAULT_PARTITION_KEY_ENCODING$1, IcebergCatalogConfig, IcebergColumn, IcebergColumn as IcebergColumn$1, IcebergColumnType, IcebergConnection, IcebergConnection as IcebergConnection$1, IcebergListedDataFile, IcebergListedDataFile as IcebergListedDataFile$1, IcebergPartitionField, IcebergPartitionField as IcebergPartitionField$1, IcebergPartitionSpec, IcebergPartitionSpecField, IcebergPartitionTransform, IcebergPrimitiveType, IcebergS3Config, IcebergSchema, IcebergSchemaField, IcebergSortOrder, IcebergSortOrderField, IcebergTableSpec, IcebergTableSpec as IcebergTableSpec$1, PartitionKeyEncoding, PartitionKeyEncoding as PartitionKeyEncoding$1, QueryProfiler, catalogCacheScope, connectIcebergCatalog, ensureIcebergNamespace, invalidateSnapshotRef, listIcebergTables } from "@gscdump/lakehouse";
 import { Result } from "gscdump/result";
-import { icebergAppendRetrying, isCommitRateLimited } from "@gscdump/lakehouse/unsafe-raw";
+import { CommitRetryOptions, ConnectIcebergOptions, IcebergCatalogConfig, IcebergColumn, IcebergConnection, IcebergListedDataFile, IcebergPartitionField, IcebergS3Config, IcebergTableSpec, PartitionKeyEncoding, PartitionKeyEncoding as PartitionKeyEncoding$1, QueryProfiler } from "@gscdump/lakehouse";
 import { TableName } from "@gscdump/contracts";
 /** The 9 fact tables that exist as global Iceberg tables. */
 type IcebergTableName = Extract<TableName, 'pages' | 'queries' | 'countries' | 'page_queries' | 'dates' | 'search_appearance' | 'search_appearance_pages' | 'search_appearance_queries' | 'search_appearance_page_queries'>;
@@ -45,8 +44,8 @@ declare const ICEBERG_PARTITION_SPEC: readonly IcebergPartitionField[];
 /**
  * Derive the full Iceberg table spec for a table + encoding. Thin wrapper
  * over {@link gscDataset}'s `tableSpec` (ADR-0021 R2-FIXES C5) — kept as a
- * named export so existing `@gscdump/engine/iceberg` consumers see no change
- * to their import surface.
+ * named GSC-specific export. Generic schema authoring types are owned by
+ * `@gscdump/lakehouse`.
  *
  * CONTRACT NOTE: implementation agents must treat the RETURNED VALUE as the
  * source of truth — do not hand-list columns elsewhere.
@@ -254,4 +253,4 @@ interface IcebergAppendSinkOptions extends SinkOptions {
    */
   encoding?: PartitionKeyEncoding$1;
 }
-export { type CatalogCache, type CommitRetryOptions, type ConnectIcebergOptions, DEFAULT_PARTITION_KEY_ENCODING$1 as DEFAULT_PARTITION_KEY_ENCODING, ICEBERG_FIELD_ID_BASE, ICEBERG_PARTITION_COLUMNS, ICEBERG_PARTITION_SPEC, ICEBERG_SCHEMAS, ICEBERG_SCHEMAS_INT, ICEBERG_SCHEMAS_STRING, ICEBERG_TABLES, INT_SEARCH_TYPE, IcebergAppendSinkOptions, type IcebergCatalogConfig, type IcebergColumn$1 as IcebergColumn, type IcebergColumnType, type IcebergConnection$1 as IcebergConnection, type IcebergListedDataFile$1 as IcebergListedDataFile, type IcebergPartitionField$1 as IcebergPartitionField, type IcebergPartitionSpec, type IcebergPartitionSpecField, type IcebergPartitionTransform, type IcebergPrimitiveType, type IcebergS3Config, type IcebergSchema, type IcebergSchemaField, type IcebergSortOrder, type IcebergSortOrderField, IcebergTableName, IcebergTableOpResult, type IcebergTableSpec$1 as IcebergTableSpec, ListIcebergDataFilesOptions, type PartitionKeyEncoding$1 as PartitionKeyEncoding, SEARCH_TYPE_INT, Sink, SinkCapabilities, SinkCloseResult, SinkOptions, SinkSlice, SinkWriteResult, SliceOverwriteWriter, assertIcebergTable, catalogCacheScope, connectIcebergCatalog, createIcebergTables, dropIcebergTables$1 as dropIcebergTables, ensureIcebergNamespace, icebergAppendRetrying, icebergPartitionColumns, icebergPartitionSpecFor, icebergSchemaFor, icebergSchemasFor, icebergSortOrderFor, icebergTableSpec, invalidateSnapshotRef, isCommitRateLimited, isIcebergTable, listIcebergDataFiles, listIcebergTables };
+export { ICEBERG_FIELD_ID_BASE, ICEBERG_PARTITION_COLUMNS, ICEBERG_PARTITION_SPEC, ICEBERG_SCHEMAS, ICEBERG_SCHEMAS_INT, ICEBERG_SCHEMAS_STRING, ICEBERG_TABLES, INT_SEARCH_TYPE, IcebergAppendSinkOptions, type IcebergS3Config, IcebergTableName, IcebergTableOpResult, ListIcebergDataFilesOptions, SEARCH_TYPE_INT, Sink, SinkCapabilities, SinkCloseResult, SinkOptions, SinkSlice, SinkWriteResult, SliceOverwriteWriter, assertIcebergTable, createIcebergTables, dropIcebergTables$1 as dropIcebergTables, icebergPartitionColumns, icebergPartitionSpecFor, icebergSchemaFor, icebergSchemasFor, icebergSortOrderFor, icebergTableSpec, isIcebergTable, listIcebergDataFiles };

package/dist/_chunks/source.mjs

@@ -1,6 +1,6 @@
-import { coerceRows } from "./coerce.mjs";
-import "./layout.mjs";
 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 {
@@ -140,4 +140,4 @@ async function runAnalyzerWithEngine(deps, ctx, params, registry) {
 async function queryRows(source, state) {
 	return await source.queryRows(state);
 }
-export { AttachedTableMissingError, ENGINE_QUERY_CAPABILITIES, createAttachedTableSource, createEngineQuerySource, createSqlQuerySource, queryRows, rewriteForTableSource, runAnalyzerWithEngine };
+export { AttachedTableMissingError, ENGINE_QUERY_CAPABILITIES, createAttachedTableSource, createEngineQuerySource, createSqlQuerySource, queryRows, runAnalyzerWithEngine };

package/dist/_chunks/storage.d.mts

@@ -13,48 +13,6 @@ interface CompactionThresholds {
   d30?: number;
 }
 declare function enumeratePartitions(startDate: string, endDate: string): string[];
-/**
- * Split manifest entries into the set worth reading (`kept`) and the set whose
- * every covered day is already served by a finer-or-newer live entry
- * (`subsumed`).
- *
- * Tiered compaction (daily→weekly→monthly→quarterly) is meant to retire its
- * inputs, but coarse files can outlive their finer counterparts: a D1→R2
- * backfill writes daily files that compact to monthly while a later re-sync
- * writes fresh daily/weekly for the same dates, and same-partition re-writes
- * leave a stale prior version live. All stay live, the resolver unions every
- * live tier whose partition intersects the range, and `union_by_name` sums the
- * overlap — impressions/clicks double-count.
- *
- * Entries are walked finest-tier-first, newest-first within a tier, so a
- * coarse or stale file is dropped only when every day it covers is already
- * claimed. Subsumption is evaluated per searchType — a `web` monthly never
- * cancels a `discover` weekly, they cover disjoint data. Partial
- * month-boundary overlap (a weekly straddling two months alongside a kept
- * 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[], queryRange?: {
-  start: string;
-  end: string;
-}): {
-  kept: ManifestEntry[];
-  subsumed: ManifestEntry[];
-};
-/** Entries worth reading — see {@link splitOverlappingTiers}. */
-declare function dedupeOverlappingTiers(entries: ManifestEntry[], queryRange?: {
-  start: string;
-  end: string;
-}): ManifestEntry[];
 interface WriteCtx extends TenantCtx {
   table: TableName;
   date?: string;
@@ -596,4 +554,4 @@ interface EngineOptions {
   executor: QueryExecutor;
   now?: () => number;
 }
-export { CodecCtx, CompactionThresholds, CompactionTier, DataSource, EngineOptions, FileSetRef, GcCtx, type Grain$1 as Grain, ListLiveFilter, LockScope, ManifestEntry, ManifestPurgeResult, ManifestStore, ParquetCodec, PurgeFilter, PurgeResult, PurgeUrlsResult, QueryCtx, QueryExecuteOptions, QueryExecuteResult, QueryExecutor, QueryProfiler, QueryResult, QuerySpan, type Row$1 as Row, RunSQLOptions, type SearchType$1 as SearchType, StorageEngine, SyncState, SyncStateDetail, SyncStateFilter, SyncStateKind, SyncStateScope, type TableName$1 as TableName, type TenantCtx$1 as TenantCtx, Watermark, WatermarkFilter, WatermarkScope, WriteCtx, WriteResult, dedupeOverlappingTiers, enumeratePartitions, splitOverlappingTiers };
+export { CodecCtx, CompactionThresholds, CompactionTier, DataSource, EngineOptions, FileSetRef, GcCtx, type Grain$1 as Grain, ListLiveFilter, LockScope, ManifestEntry, ManifestPurgeResult, ManifestStore, ParquetCodec, PurgeFilter, PurgeResult, PurgeUrlsResult, QueryCtx, QueryExecuteOptions, QueryExecuteResult, QueryExecutor, QueryProfiler, QueryResult, QuerySpan, type Row$1 as Row, RunSQLOptions, type SearchType$1 as SearchType, StorageEngine, SyncState, SyncStateDetail, SyncStateFilter, SyncStateKind, SyncStateScope, type TableName$1 as TableName, type TenantCtx$1 as TenantCtx, Watermark, WatermarkFilter, WatermarkScope, WriteCtx, WriteResult, enumeratePartitions };

package/dist/_chunks/types.d.mts

@@ -40,6 +40,14 @@ interface ResolverOptions<TableKey extends string = string> {
    * int partition prunes; `string` for the default string-encoded catalogs.
    */
   searchType?: string | number;
+  /**
+   * Optional non-comparison scan guard. When set, direct row/totals queries
+   * add `impressions >= value` before aggregation. This can materially reduce
+   * stored-row reads because zero-impression long-tail rows contribute
+   * nothing to metric aggregates. Comparison SQL deliberately ignores it so
+   * `lost`/`declining` rows remain observable.
+   */
+  minimumImpressions?: number;
 }
 interface ResolvedSQL {
   sql: string;

package/dist/adapters/node.d.mts

@@ -1,8 +1,6 @@
 import { DataSource, StorageEngine } from "../_chunks/storage.mjs";
 import { NodeDuckDBOptions, createNodeDuckDBHandle, resetNodeDuckDB } from "./duckdb-node.mjs";
-import { EngineError } from "../_chunks/errors.mjs";
 import { SnapshotIndex } from "../_chunks/snapshot.mjs";
-import { Result } from "gscdump/result";
 import { SearchType } from "gscdump/query";
 import { Row, TableName } from "@gscdump/contracts";
 interface NodeHarnessOptions {
@@ -74,14 +72,6 @@ interface AttachSnapshotResult {
  * `cold_2024_09`. `hot.duckdb` → `hot`.
  */
 declare function snapshotAlias(fileName: string): string;
-/**
- * Errors-as-values core: validates the snapshot index and presigned-URL map,
- * returning a typed `EngineError` for every modelled failure (bad index version,
- * unsafe schema/YYYY-MM identifier, missing attach URL). Underlying DuckDB
- * `runner` IO failures stay defects and propagate. `attachSnapshotIndex` is the
- * throwing wrapper.
- */
-declare function attachSnapshotIndexResult(runner: SnapshotQueryRunner, opts: AttachSnapshotOptions): Promise<Result<AttachSnapshotResult, EngineError>>;
 declare function attachSnapshotIndex(runner: SnapshotQueryRunner, opts: AttachSnapshotOptions): Promise<AttachSnapshotResult>;
 interface AttachParquetIndexOptions {
   /**
@@ -104,4 +94,4 @@ interface AttachParquetIndexResult {
   tables: string[];
 }
 declare function attachParquetIndex(runner: SnapshotQueryRunner, opts: AttachParquetIndexOptions): Promise<AttachParquetIndexResult>;
-export { type AttachParquetIndexOptions, type AttachParquetIndexResult, type AttachSnapshotOptions, type AttachSnapshotResult, type NodeDuckDBOptions, type NodeHarness, type NodeHarnessOptions, type SnapshotQueryRunner, attachParquetIndex, attachSnapshotIndex, attachSnapshotIndexResult, createNodeDuckDBHandle, createNodeHarness, resetNodeDuckDB, snapshotAlias };
+export { type AttachParquetIndexOptions, type AttachParquetIndexResult, type AttachSnapshotOptions, type AttachSnapshotResult, type NodeDuckDBOptions, type NodeHarness, type NodeHarnessOptions, type SnapshotQueryRunner, attachParquetIndex, attachSnapshotIndex, createNodeDuckDBHandle, createNodeHarness, resetNodeDuckDB, snapshotAlias };

package/dist/adapters/node.mjs

@@ -147,4 +147,4 @@ async function attachSnapshotIndexResult(runner, opts) {
 async function attachSnapshotIndex(runner, opts) {
 	return unwrapResult(await attachSnapshotIndexResult(runner, opts), snapshotAttachErrorToException);
 }
-export { attachParquetIndex, attachSnapshotIndex, attachSnapshotIndexResult, createNodeDuckDBHandle, createNodeHarness, resetNodeDuckDB, snapshotAlias };
+export { attachParquetIndex, attachSnapshotIndex, createNodeDuckDBHandle, createNodeHarness, resetNodeDuckDB, snapshotAlias };

package/dist/analyzer/index.d.mts

@@ -1,6 +1,6 @@
-import { EngineError } from "../_chunks/errors.mjs";
 import { AnalysisParams, AnalysisResult } from "../_chunks/analysis-types.mjs";
 import { AnalysisQuerySource, Analyzer, AnalyzerRegistry, AnalyzerRegistryInit, AnalyzerVariants, BuildContext, DefineAnalyzerOptions, DefinedAnalyzer, Plan, ReduceContext, ReduceCtx, Reducer, RequiredCapability, RowQueriesPlan, SqlExtraQuery, SqlPlan, SqlPlanSpec, TypedRowQuery, createAnalyzerRegistry, defineAnalyzer, requireAdapter } from "../_chunks/registry.mjs";
+import { EngineError } from "../_chunks/errors.mjs";
 declare class AnalyzerCapabilityError extends Error {
   readonly tool: string;
   readonly missing: readonly RequiredCapability[];

package/dist/entities.d.mts

@@ -1,6 +1,6 @@
 import { DataSource } from "./_chunks/storage.mjs";
 import { ScheduleState } from "./schedule.mjs";
-import { ColumnDef, TenantCtx } from "@gscdump/contracts";
+import { TenantCtx } from "@gscdump/contracts";
 interface QueryDimRecord {
   query: string;
   /** Lexical canonical, never empty: NULL/'' folds to the raw query. */
@@ -290,14 +290,6 @@ interface InspectionStore {
 interface CreateInspectionStoreOptions {
   dataSource: DataSource;
 }
-/**
- * Column schema for the append-only inspection-event store + its compacted
- * base. Superset of {@link INSPECTION_PARQUET_COLUMNS}: the 16 promoted columns
- * plus the 8 full-fidelity ones the lossy `materialize` parquet dropped. The
- * event files and `base.parquet` share this schema so DuckDB
- * `read_parquet([...], union_by_name = true)` merges base + events cleanly.
- */
-declare const INSPECTION_EVENT_COLUMNS: readonly ColumnDef[];
 declare function createInspectionStore(opts: CreateInspectionStoreOptions): InspectionStore;
 /** GSC sitemap record we persist. Matches `Schema$WmxSitemap` but as plain JSON. */
 interface SitemapRecord {
@@ -522,4 +514,4 @@ interface CreateEmptyTypesStoreOptions {
   now?: () => number;
 }
 declare function createEmptyTypesStore(opts: CreateEmptyTypesStoreOptions): EmptyTypesStore;
-export { CompactUrlsOptions, CompactUrlsResult, CreateEmptyTypesStoreOptions, CreateIndexingMetadataStoreOptions, CreateInspectionStoreOptions, CreateSitemapStoreOptions, DateRange, DeltaEntry, EmptyTypesDoc, EmptyTypesStore, INSPECTION_EVENT_COLUMNS, INSPECTION_HISTORY_MAX_BYTES, IndexingMetadataIndex, IndexingMetadataRecord, IndexingMetadataStore, InspectionEventRow, InspectionHistoryShard, InspectionIndex, InspectionParquetRow, InspectionRecord, InspectionStore, LoadUrlsOptions, ParsedUrl, QueryDimDeps, QueryDimMeta, QueryDimRecord, QueryDimStore, ReconcileResult, SitemapHistoryDoc, SitemapIndex, SitemapRecord, SitemapStore, SitemapUrlRecord, SnapshotUrlsResult, buildQueryDimRecords, createEmptyTypesStore, createIndexingMetadataStore, createInspectionStore, createQueryDimStore, createSitemapStore, emptyTypesKey, hashUrl, hashUrlList, indexingMetadataIndexKey, inspectionBaseKey, inspectionEventKey, inspectionEventsPrefix, inspectionHistoryPrefix, inspectionHistoryShardKey, inspectionIndexKey, inspectionParquetKey, queryDimMetaKey, queryDimParquetKey, sitemapHistoryKey, sitemapIndexKey, sitemapUrlsDeltaKey, sitemapUrlsIndexKey, sitemapUrlsIndexPrefix };
+export { CompactUrlsOptions, CompactUrlsResult, CreateEmptyTypesStoreOptions, CreateIndexingMetadataStoreOptions, CreateInspectionStoreOptions, CreateSitemapStoreOptions, DateRange, DeltaEntry, EmptyTypesDoc, EmptyTypesStore, INSPECTION_HISTORY_MAX_BYTES, IndexingMetadataIndex, IndexingMetadataRecord, IndexingMetadataStore, InspectionEventRow, InspectionHistoryShard, InspectionIndex, InspectionParquetRow, InspectionRecord, InspectionStore, LoadUrlsOptions, ParsedUrl, QueryDimDeps, QueryDimMeta, QueryDimRecord, QueryDimStore, ReconcileResult, SitemapHistoryDoc, SitemapIndex, SitemapRecord, SitemapStore, SitemapUrlRecord, SnapshotUrlsResult, buildQueryDimRecords, createEmptyTypesStore, createIndexingMetadataStore, createInspectionStore, createQueryDimStore, createSitemapStore, emptyTypesKey, hashUrl, hashUrlList, indexingMetadataIndexKey, inspectionBaseKey, inspectionEventKey, inspectionEventsPrefix, inspectionHistoryPrefix, inspectionHistoryShardKey, inspectionIndexKey, inspectionParquetKey, queryDimMetaKey, queryDimParquetKey, sitemapHistoryKey, sitemapIndexKey, sitemapUrlsDeltaKey, sitemapUrlsIndexKey, sitemapUrlsIndexPrefix };

package/dist/entities.mjs

@@ -1,2 +1,2 @@
-import { INSPECTION_EVENT_COLUMNS, INSPECTION_HISTORY_MAX_BYTES, buildQueryDimRecords, createEmptyTypesStore, createIndexingMetadataStore, createInspectionStore, createQueryDimStore, createSitemapStore, emptyTypesKey, hashUrl, hashUrlList, indexingMetadataIndexKey, inspectionBaseKey, inspectionEventKey, inspectionEventsPrefix, inspectionHistoryPrefix, inspectionHistoryShardKey, inspectionIndexKey, inspectionParquetKey, queryDimMetaKey, queryDimParquetKey, sitemapHistoryKey, sitemapIndexKey, sitemapUrlsDeltaKey, sitemapUrlsIndexKey, sitemapUrlsIndexPrefix } from "./_chunks/entities.mjs";
-export { INSPECTION_EVENT_COLUMNS, INSPECTION_HISTORY_MAX_BYTES, buildQueryDimRecords, createEmptyTypesStore, createIndexingMetadataStore, createInspectionStore, createQueryDimStore, createSitemapStore, emptyTypesKey, hashUrl, hashUrlList, indexingMetadataIndexKey, inspectionBaseKey, inspectionEventKey, inspectionEventsPrefix, inspectionHistoryPrefix, inspectionHistoryShardKey, inspectionIndexKey, inspectionParquetKey, queryDimMetaKey, queryDimParquetKey, sitemapHistoryKey, sitemapIndexKey, sitemapUrlsDeltaKey, sitemapUrlsIndexKey, sitemapUrlsIndexPrefix };
+import { INSPECTION_HISTORY_MAX_BYTES, buildQueryDimRecords, createEmptyTypesStore, createIndexingMetadataStore, createInspectionStore, createQueryDimStore, createSitemapStore, emptyTypesKey, hashUrl, hashUrlList, indexingMetadataIndexKey, inspectionBaseKey, inspectionEventKey, inspectionEventsPrefix, inspectionHistoryPrefix, inspectionHistoryShardKey, inspectionIndexKey, inspectionParquetKey, queryDimMetaKey, queryDimParquetKey, sitemapHistoryKey, sitemapIndexKey, sitemapUrlsDeltaKey, sitemapUrlsIndexKey, sitemapUrlsIndexPrefix } from "./_chunks/entities.mjs";
+export { INSPECTION_HISTORY_MAX_BYTES, buildQueryDimRecords, createEmptyTypesStore, createIndexingMetadataStore, createInspectionStore, createQueryDimStore, createSitemapStore, emptyTypesKey, hashUrl, hashUrlList, indexingMetadataIndexKey, inspectionBaseKey, inspectionEventKey, inspectionEventsPrefix, inspectionHistoryPrefix, inspectionHistoryShardKey, inspectionIndexKey, inspectionParquetKey, queryDimMetaKey, queryDimParquetKey, sitemapHistoryKey, sitemapIndexKey, sitemapUrlsDeltaKey, sitemapUrlsIndexKey, sitemapUrlsIndexPrefix };

package/dist/iceberg/index.d.mts

@@ -1,5 +1,4 @@
-import { CatalogCache, CommitRetryOptions, ConnectIcebergOptions, DEFAULT_PARTITION_KEY_ENCODING, ICEBERG_FIELD_ID_BASE, ICEBERG_PARTITION_COLUMNS, ICEBERG_PARTITION_SPEC, ICEBERG_SCHEMAS, ICEBERG_SCHEMAS_INT, ICEBERG_SCHEMAS_STRING, ICEBERG_TABLES, INT_SEARCH_TYPE, IcebergAppendSinkOptions, IcebergCatalogConfig, IcebergColumn, IcebergColumnType, IcebergConnection, IcebergListedDataFile, IcebergPartitionField, IcebergPartitionSpec, IcebergPartitionSpecField, IcebergPartitionTransform, IcebergPrimitiveType, IcebergS3Config, IcebergSchema, IcebergSchemaField, IcebergSortOrder, IcebergSortOrderField, IcebergTableName, IcebergTableOpResult, IcebergTableSpec, ListIcebergDataFilesOptions, PartitionKeyEncoding, SEARCH_TYPE_INT, Sink, assertIcebergTable, catalogCacheScope, connectIcebergCatalog, createIcebergTables, dropIcebergTables, ensureIcebergNamespace, icebergAppendRetrying, icebergPartitionColumns, icebergPartitionSpecFor, icebergSchemaFor, icebergSchemasFor, icebergSortOrderFor, icebergTableSpec, invalidateSnapshotRef, isCommitRateLimited, isIcebergTable, listIcebergDataFiles, listIcebergTables } from "../_chunks/sink.mjs";
-import { icebergCreateTable, icebergManifests, restCatalogLoadTable } from "../_chunks/libs/icebird.mjs";
+import { ICEBERG_FIELD_ID_BASE, ICEBERG_PARTITION_COLUMNS, ICEBERG_PARTITION_SPEC, ICEBERG_SCHEMAS, ICEBERG_SCHEMAS_INT, ICEBERG_SCHEMAS_STRING, ICEBERG_TABLES, INT_SEARCH_TYPE, IcebergAppendSinkOptions, IcebergTableName, IcebergTableOpResult, ListIcebergDataFilesOptions, SEARCH_TYPE_INT, Sink, assertIcebergTable, createIcebergTables, dropIcebergTables, icebergPartitionColumns, icebergPartitionSpecFor, icebergSchemaFor, icebergSchemasFor, icebergSortOrderFor, icebergTableSpec, isIcebergTable, listIcebergDataFiles } from "../_chunks/sink.mjs";
 type IcebergAppendSink = Sink;
 /**
  * Create an `IcebergAppendSink` over the R2 Data Catalog.
@@ -12,4 +11,4 @@ type IcebergAppendSink = Sink;
  * without it every fresh sink/isolate must probe the catalog again.
  */
 declare function createIcebergAppendSink(options: IcebergAppendSinkOptions): IcebergAppendSink;
-export { type CatalogCache, type CommitRetryOptions, type ConnectIcebergOptions, DEFAULT_PARTITION_KEY_ENCODING, ICEBERG_FIELD_ID_BASE, ICEBERG_PARTITION_COLUMNS, ICEBERG_PARTITION_SPEC, ICEBERG_SCHEMAS, ICEBERG_SCHEMAS_INT, ICEBERG_SCHEMAS_STRING, ICEBERG_TABLES, INT_SEARCH_TYPE, 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 IcebergSortOrder, type IcebergSortOrderField, type IcebergTableName, type IcebergTableOpResult, type IcebergTableSpec, type ListIcebergDataFilesOptions, type PartitionKeyEncoding, SEARCH_TYPE_INT, assertIcebergTable, catalogCacheScope, connectIcebergCatalog, createIcebergAppendSink, createIcebergTables, dropIcebergTables, ensureIcebergNamespace, icebergAppendRetrying, icebergCreateTable, icebergManifests, icebergPartitionColumns, icebergPartitionSpecFor, icebergSchemaFor, icebergSchemasFor, icebergSortOrderFor, icebergTableSpec, invalidateSnapshotRef, isCommitRateLimited, isIcebergTable, listIcebergDataFiles, listIcebergTables, restCatalogLoadTable };
+export { ICEBERG_FIELD_ID_BASE, ICEBERG_PARTITION_COLUMNS, ICEBERG_PARTITION_SPEC, ICEBERG_SCHEMAS, ICEBERG_SCHEMAS_INT, ICEBERG_SCHEMAS_STRING, ICEBERG_TABLES, INT_SEARCH_TYPE, type IcebergAppendSink, type IcebergAppendSinkOptions, type IcebergTableName, type IcebergTableOpResult, type ListIcebergDataFilesOptions, SEARCH_TYPE_INT, assertIcebergTable, createIcebergAppendSink, createIcebergTables, dropIcebergTables, icebergPartitionColumns, icebergPartitionSpecFor, icebergSchemaFor, icebergSchemasFor, icebergSortOrderFor, icebergTableSpec, isIcebergTable, listIcebergDataFiles };

package/dist/iceberg/index.mjs

@@ -1,11 +1,11 @@
-import { TABLE_METADATA } from "../_chunks/schema.mjs";
 import { engineErrors } from "../errors.mjs";
-import { DEFAULT_PARTITION_KEY_ENCODING, ICEBERG_FIELD_ID_BASE, ICEBERG_PARTITION_COLUMNS, ICEBERG_PARTITION_SPEC, ICEBERG_SCHEMAS, ICEBERG_SCHEMAS_INT, ICEBERG_SCHEMAS_STRING, ICEBERG_TABLES, INT_SEARCH_TYPE, SEARCH_TYPE_INT, assertIcebergTable, gscDataset, icebergPartitionColumns, icebergSchemasFor, icebergTableSpec, isIcebergTable } from "../_chunks/schema2.mjs";
-import { icebergCreateTable, icebergManifests, restCatalogLoadTable } from "../_chunks/libs/icebird.mjs";
-import { ICEBERG_TYPE_MAP, catalogCacheScope, connectIcebergCatalog, dropIcebergTables as dropIcebergTables$1, ensureIcebergNamespace, invalidateSnapshotRef, listIcebergTables, resolveIcebergDataFiles } from "@gscdump/lakehouse";
+import { TABLE_METADATA } from "../_chunks/schema.mjs";
+import { DEFAULT_PARTITION_KEY_ENCODING as DEFAULT_PARTITION_KEY_ENCODING$1, ICEBERG_FIELD_ID_BASE, ICEBERG_PARTITION_COLUMNS, ICEBERG_PARTITION_SPEC, ICEBERG_SCHEMAS, ICEBERG_SCHEMAS_INT, ICEBERG_SCHEMAS_STRING, ICEBERG_TABLES, INT_SEARCH_TYPE, SEARCH_TYPE_INT, assertIcebergTable, gscDataset, icebergPartitionColumns, icebergSchemasFor, icebergTableSpec, isIcebergTable } from "../_chunks/schema2.mjs";
+import { icebergCreateTable } from "../_chunks/libs/icebird.mjs";
 import { err, ok } from "gscdump/result";
-import { icebergAppendRetrying, isCommitRateLimited } from "@gscdump/lakehouse/unsafe-raw";
-function icebergSchemaFor(table, encoding = DEFAULT_PARTITION_KEY_ENCODING) {
+import { ICEBERG_TYPE_MAP, connectIcebergCatalog, dropIcebergTables as dropIcebergTables$1, resolveIcebergDataFiles } from "@gscdump/lakehouse";
+import { icebergAppendRetrying } from "@gscdump/lakehouse/unsafe-raw";
+function icebergSchemaFor(table, encoding = DEFAULT_PARTITION_KEY_ENCODING$1) {
 	return {
 		"type": "struct",
 		"schema-id": 0,
@@ -17,7 +17,7 @@ function icebergSchemaFor(table, encoding = DEFAULT_PARTITION_KEY_ENCODING) {
 		}))
 	};
 }
-function icebergPartitionSpecFor(table, encoding = DEFAULT_PARTITION_KEY_ENCODING) {
+function icebergPartitionSpecFor(table, encoding = DEFAULT_PARTITION_KEY_ENCODING$1) {
 	const fields = icebergSchemasFor(encoding)[table].columns;
 	const fieldId = (name) => {
 		const col = fields.find((c) => c.name === name);
@@ -34,7 +34,7 @@ function icebergPartitionSpecFor(table, encoding = DEFAULT_PARTITION_KEY_ENCODIN
 		}))
 	};
 }
-function icebergSortOrderFor(table, encoding = DEFAULT_PARTITION_KEY_ENCODING) {
+function icebergSortOrderFor(table, encoding = DEFAULT_PARTITION_KEY_ENCODING$1) {
 	const fields = icebergSchemasFor(encoding)[table].columns;
 	const fieldId = (name) => {
 		const col = fields.find((c) => c.name === name);
@@ -51,7 +51,7 @@ function icebergSortOrderFor(table, encoding = DEFAULT_PARTITION_KEY_ENCODING) {
 		}))
 	};
 }
-async function createIcebergTables(conn, tables = ICEBERG_TABLES, encoding = DEFAULT_PARTITION_KEY_ENCODING) {
+async function createIcebergTables(conn, tables = ICEBERG_TABLES, encoding = DEFAULT_PARTITION_KEY_ENCODING$1) {
 	const results = [];
 	for (const table of tables) await icebergCreateTable({
 		catalog: conn.catalog,
@@ -76,7 +76,7 @@ async function dropIcebergTables(conn, tables) {
 	}));
 }
 async function listIcebergDataFiles(conn, opts) {
-	const matches = (opts.encoding ?? DEFAULT_PARTITION_KEY_ENCODING) === "string" ? [{
+	const matches = (opts.encoding ?? DEFAULT_PARTITION_KEY_ENCODING$1) === "string" ? [{
 		field: "site_id",
 		value: opts.siteId,
 		encoding: "string"
@@ -178,7 +178,7 @@ function toRecords(slice, rows, encoding) {
 }
 function createIcebergAppendSink(options) {
 	let connection;
-	const encoding = options.encoding ?? DEFAULT_PARTITION_KEY_ENCODING;
+	const encoding = options.encoding ?? DEFAULT_PARTITION_KEY_ENCODING$1;
 	const buffers = /* @__PURE__ */ new Map();
 	function connect() {
 		connection ??= connectIcebergCatalog(options.catalog, options.connect);
@@ -242,4 +242,4 @@ function createIcebergAppendSink(options) {
 		}
 	};
 }
-export { DEFAULT_PARTITION_KEY_ENCODING, ICEBERG_FIELD_ID_BASE, ICEBERG_PARTITION_COLUMNS, ICEBERG_PARTITION_SPEC, ICEBERG_SCHEMAS, ICEBERG_SCHEMAS_INT, ICEBERG_SCHEMAS_STRING, ICEBERG_TABLES, INT_SEARCH_TYPE, SEARCH_TYPE_INT, assertIcebergTable, catalogCacheScope, connectIcebergCatalog, createIcebergAppendSink, createIcebergTables, dropIcebergTables, ensureIcebergNamespace, icebergAppendRetrying, icebergCreateTable, icebergManifests, icebergPartitionColumns, icebergPartitionSpecFor, icebergSchemaFor, icebergSchemasFor, icebergSortOrderFor, icebergTableSpec, invalidateSnapshotRef, isCommitRateLimited, isIcebergTable, listIcebergDataFiles, listIcebergTables, restCatalogLoadTable };
+export { ICEBERG_FIELD_ID_BASE, ICEBERG_PARTITION_COLUMNS, ICEBERG_PARTITION_SPEC, ICEBERG_SCHEMAS, ICEBERG_SCHEMAS_INT, ICEBERG_SCHEMAS_STRING, ICEBERG_TABLES, INT_SEARCH_TYPE, SEARCH_TYPE_INT, assertIcebergTable, createIcebergAppendSink, createIcebergTables, dropIcebergTables, icebergPartitionColumns, icebergPartitionSpecFor, icebergSchemaFor, icebergSchemasFor, icebergSortOrderFor, icebergTableSpec, isIcebergTable, listIcebergDataFiles };