@gscdump/engine 1.4.0 → 1.4.2

package/dist/errors.d.mts

@@ -1,2 +1,115 @@
-import { EngineError, EngineErrorKind, engineErrorToException, engineErrors, isEngineError } from "./_chunks/errors.mjs";
+type EngineErrorKind = 'analyzer-not-found' | 'analyzer-capability-missing' | 'invalid-sql-literal' | 'placeholder-arity-mismatch' | 'invalid-search-types' | 'attached-table-missing' | 'manifest-cas-exhausted' | 'invalid-snapshot-filename' | 'unsupported-snapshot-index-version' | 'invalid-schema-identifier' | 'invalid-year-month' | 'missing-attach-url' | 'manifest-cas-round-lost' | 'iceberg-table-op-failed' | 'sink-table-flush-failed' | 'rollup-build-failed' | 'lock-acquire-timeout';
+type EngineError = {
+  kind: 'analyzer-not-found';
+  tool: string;
+  message: string;
+} | {
+  kind: 'analyzer-capability-missing';
+  tool: string;
+  missing: readonly string[];
+  message: string;
+} | {
+  kind: 'invalid-sql-literal';
+  message: string;
+} | {
+  kind: 'placeholder-arity-mismatch';
+  message: string;
+} | {
+  kind: 'invalid-search-types';
+  message: string;
+  cause?: unknown;
+} | {
+  kind: 'attached-table-missing';
+  missing: readonly string[];
+  message: string;
+} | {
+  kind: 'manifest-cas-exhausted';
+  message: string;
+  siteId: string;
+  table: string;
+  attempts: number;
+} | {
+  kind: 'invalid-snapshot-filename';
+  message: string;
+  fileName: string;
+} | {
+  kind: 'unsupported-snapshot-index-version';
+  message: string;
+  version: unknown;
+} | {
+  kind: 'invalid-schema-identifier';
+  message: string;
+  schema: string;
+} | {
+  kind: 'invalid-year-month';
+  message: string;
+  value: string;
+} | {
+  kind: 'missing-attach-url';
+  message: string;
+  fileName: string;
+} | {
+  kind: 'manifest-cas-round-lost';
+  message: string;
+  siteId: string;
+  table: string;
+  attempt: number;
+} | {
+  kind: 'iceberg-table-op-failed';
+  message: string;
+  op: 'create' | 'drop';
+  table: string;
+  cause?: unknown;
+} | {
+  kind: 'sink-table-flush-failed';
+  message: string;
+  table: string;
+  cause?: unknown;
+} | {
+  kind: 'rollup-build-failed';
+  message: string;
+  id: string;
+  cause?: unknown;
+} | {
+  kind: 'lock-acquire-timeout';
+  message: string;
+  scope: string;
+  timeoutMs: number;
+};
+declare const engineErrors: {
+  readonly analyzerNotFound: (tool: string) => EngineError;
+  readonly analyzerCapabilityMissing: (tool: string, missing: readonly string[]) => EngineError;
+  readonly nonFiniteNumberLiteral: (value: number) => EngineError;
+  readonly controlCharsInLiteral: () => EngineError;
+  readonly uninlinableLiteralType: (type: string) => EngineError;
+  readonly morePlaceholdersThanParams: (have: number) => EngineError;
+  readonly dollarPlaceholderOutOfRange: (n: number, have: number) => EngineError;
+  readonly mixedPlaceholderStyles: () => EngineError;
+  readonly unusedParams: (unused: number) => EngineError;
+  readonly searchTypesNotArray: () => EngineError;
+  readonly unknownSearchType: (value: unknown) => EngineError;
+  readonly searchTypesMissingWeb: () => EngineError;
+  readonly attachedTableMissing: (missing: readonly string[]) => EngineError;
+  readonly manifestCasExhausted: (siteId: string, table: string, attempts: number) => EngineError;
+  readonly invalidSnapshotFilename: (fileName: string) => EngineError;
+  readonly unsupportedSnapshotIndexVersion: (version: unknown) => EngineError;
+  readonly invalidSchemaIdentifier: (schema: string) => EngineError;
+  readonly invalidYearMonth: (value: string) => EngineError;
+  readonly missingAttachUrl: (fileName: string) => EngineError;
+  readonly manifestCasRoundLost: (siteId: string, table: string, attempt: number) => EngineError;
+  readonly icebergTableOpFailed: (op: 'create' | 'drop', table: string, cause: unknown) => EngineError;
+  readonly sinkTableFlushFailed: (table: string, cause: unknown) => EngineError;
+  readonly rollupBuildFailed: (id: string, cause: unknown) => EngineError;
+  readonly lockAcquireTimeout: (scope: string, timeoutMs: number) => EngineError;
+};
+declare function isEngineError(value: unknown): value is EngineError;
+/**
+ * Re-raises an `EngineError` value as a generic `Error`, stashing the union under
+ * `.engineError` for stack-walking. Used by the throwing wrappers over the
+ * `Result`-returning cores whose original throws were bare `Error`s (the SQL
+ * binder, sync-config). Modules that historically threw a *named* class
+ * (`AnalyzerCapabilityError`, `AttachedTableMissingError`) provide their own
+ * mapper so the class identity callers match on is preserved.
+ */
+declare function engineErrorToException(error: EngineError): Error;
 export { EngineError, EngineErrorKind, engineErrorToException, engineErrors, isEngineError };

package/dist/gc.mjs

@@ -0,0 +1,92 @@
+import { tenantPrefix } from "./layout.mjs";
+const DEFAULT_HOURLY_RETENTION_MS = 2160 * 60 * 60 * 1e3;
+const VERSION_RE = /__v(\d+)\.parquet$/;
+function parseLockScope(key) {
+	const match = VERSION_RE.exec(key);
+	if (!match) return void 0;
+	const parts = key.slice(0, match.index).split("/");
+	if (parts.length < 4) return void 0;
+	const userPart = parts[0];
+	if (!userPart.startsWith("u_")) return void 0;
+	const userId = userPart.slice(2);
+	const partition = parts.slice(-2).join("/");
+	const table = parts[parts.length - 3];
+	return {
+		userId,
+		siteId: parts.length >= 5 ? parts.slice(1, -3).join("/") : void 0,
+		table,
+		partition
+	};
+}
+async function gcOrphansImpl(deps, now, graceMs, opts = {}) {
+	const cutoff = now - graceMs;
+	const retired = await deps.manifestStore.listRetired(cutoff);
+	if (retired.length > 0) {
+		await deps.dataSource.delete(retired.map((e) => e.objectKey));
+		await deps.manifestStore.delete(retired);
+	}
+	let hourlyDeleted = 0;
+	if (opts.userId) {
+		const hourlyCutoff = now - (opts.hourlyRetentionMs ?? DEFAULT_HOURLY_RETENTION_MS);
+		const expiredHourly = (await deps.manifestStore.listAll({
+			userId: opts.userId,
+			siteId: opts.siteId
+		})).filter((e) => e.partition.startsWith("hourly/") && e.createdAt < hourlyCutoff);
+		if (expiredHourly.length > 0) {
+			await deps.dataSource.delete(expiredHourly.map((e) => e.objectKey));
+			await deps.manifestStore.delete(expiredHourly);
+			hourlyDeleted = expiredHourly.length;
+		}
+	}
+	let sweptOrphans = 0;
+	if (opts.userId) {
+		const prefix = tenantPrefix({
+			userId: opts.userId,
+			siteId: opts.siteId
+		});
+		const knownEntries = await deps.manifestStore.listAll({
+			userId: opts.userId,
+			siteId: opts.siteId
+		});
+		const knownSet = new Set(knownEntries.map((e) => e.objectKey));
+		const orphans = [];
+		const keyStream = deps.dataSource.streamList ? deps.dataSource.streamList(prefix) : async function* () {
+			const all = await deps.dataSource.list(prefix);
+			for (const k of all) yield k;
+		}();
+		for await (const key of keyStream) {
+			if (knownSet.has(key)) continue;
+			const match = VERSION_RE.exec(key);
+			if (!match) continue;
+			if (Number(match[1]) <= cutoff) orphans.push(key);
+		}
+		const byScope = /* @__PURE__ */ new Map();
+		for (const key of orphans) {
+			const scope = parseLockScope(key);
+			if (!scope) continue;
+			const sk = `${scope.userId}|${scope.siteId ?? ""}|${scope.table}|${scope.partition}`;
+			const bucket = byScope.get(sk) ?? {
+				scope,
+				keys: []
+			};
+			bucket.keys.push(key);
+			byScope.set(sk, bucket);
+		}
+		for (const { scope, keys } of byScope.values()) await deps.manifestStore.withLock(scope, async () => {
+			const known = await deps.manifestStore.listAll({
+				userId: scope.userId,
+				siteId: scope.siteId,
+				table: scope.table,
+				partitions: [scope.partition]
+			});
+			const knownInScope = new Set(known.map((e) => e.objectKey));
+			const stillOrphans = keys.filter((k) => !knownInScope.has(k));
+			if (stillOrphans.length > 0) {
+				await deps.dataSource.delete(stillOrphans);
+				sweptOrphans += stillOrphans.length;
+			}
+		});
+	}
+	return { deleted: retired.length + sweptOrphans + hourlyDeleted };
+}
+export { gcOrphansImpl };

package/dist/iceberg/append-sink.d.mts

@@ -0,0 +1,14 @@
+import { IcebergAppendSinkOptions, Sink } from "../sink.mjs";
+type IcebergAppendSink = Sink;
+/**
+ * Create an `IcebergAppendSink` over the R2 Data Catalog.
+ *
+ * `emit` buffers; `close()` commits one `icebergAppend()` per table touched.
+ * The catalog connection (REST context + signed S3 resolver) is established
+ * lazily on the first flush and reused — a sink that is opened and closed
+ * with no rows never touches the network. `options.connect` is forwarded so
+ * Worker callers can share the `/v1/config` context through a durable cache;
+ * without it every fresh sink/isolate must probe the catalog again.
+ */
+declare function createIcebergAppendSink(options: IcebergAppendSinkOptions): IcebergAppendSink;
+export { IcebergAppendSink, createIcebergAppendSink };

package/dist/iceberg/append-sink.mjs

@@ -0,0 +1,142 @@
+import { engineErrors } from "../errors.mjs";
+import { DEFAULT_PARTITION_KEY_ENCODING, gscDataset } from "./schema.mjs";
+import { connectIcebergCatalog, icebergAppendRetrying } from "./catalog.mjs";
+const DAY_MILLIS = 864e5;
+const INT32_MIN = -2147483648;
+const INT32_MAX = 2147483647;
+function toIcebergDate(value) {
+	if (typeof value === "string") {
+		const ms = Date.parse(`${value}T00:00:00Z`);
+		if (Number.isNaN(ms)) throw new TypeError(`toIcebergDate: invalid date string '${value}'`);
+		return Math.floor(ms / DAY_MILLIS);
+	}
+	if (value instanceof Date) {
+		const ms = value.getTime();
+		if (Number.isNaN(ms)) throw new TypeError("toIcebergDate: invalid Date (NaN)");
+		return Math.floor(ms / DAY_MILLIS);
+	}
+	return value;
+}
+function coerceJsonSafe(value) {
+	if (typeof value === "bigint") return Number(value);
+	return value;
+}
+function toIntPartitionSiteId(value) {
+	if (value == null || typeof value === "string" && value.trim() === "") throw new TypeError("toRecords: slice.ctx.siteId is required for int partition encoding");
+	if (typeof value !== "string" && typeof value !== "number" && typeof value !== "bigint") throw new TypeError(`toRecords: int partition site_id must be a safe integer, got '${String(value)}'`);
+	const siteId = Number(value);
+	if (!Number.isSafeInteger(siteId)) throw new TypeError(`toRecords: int partition site_id must be a safe integer, got '${String(value)}'`);
+	if (siteId < INT32_MIN || siteId > INT32_MAX) throw new TypeError(`toRecords: int partition site_id must fit Iceberg INT, got '${String(value)}'`);
+	return siteId;
+}
+function dedupeByIdentity(table, records) {
+	if (records.length < 2) return records;
+	const key = gscDataset(table, "int").tableSpec.identityColumns;
+	const seen = /* @__PURE__ */ new Map();
+	for (const rec of records) {
+		let identity = "";
+		for (let index = 0; index < key.length; index++) {
+			if (index > 0) identity += "\0";
+			identity += `${rec[key[index]] ?? ""}`;
+		}
+		seen.set(identity, rec);
+	}
+	return seen.size === records.length ? records : [...seen.values()];
+}
+function sortByClusterKey(table, records) {
+	const cols = gscDataset(table, "int").tableSpec.clusterKey ?? [];
+	if (cols.length === 0 || records.length < 2) return records;
+	return records.slice().sort((a, b) => {
+		for (const col of cols) {
+			const av = a[col];
+			const bv = b[col];
+			if (av === bv) continue;
+			if (av == null) return -1;
+			if (bv == null) return 1;
+			if (typeof av === "number" && typeof bv === "number") return av - bv;
+			const as = String(av);
+			const bs = String(bv);
+			if (as !== bs) return as < bs ? -1 : 1;
+		}
+		return 0;
+	});
+}
+function toRecords(slice, rows, encoding) {
+	const siteVal = encoding === "int" ? toIntPartitionSiteId(slice.ctx.siteId) : slice.ctx.siteId ?? "";
+	const searchVal = gscDataset(slice.table, encoding).def.dims.search_type.toPartitionValue(slice.searchType);
+	return rows.map((row) => {
+		const out = {};
+		for (const k in row) out[k] = coerceJsonSafe(row[k]);
+		out.date = toIcebergDate(out.date);
+		out.site_id = siteVal;
+		out.search_type = searchVal;
+		return out;
+	});
+}
+function createIcebergAppendSink(options) {
+	let connection;
+	const encoding = options.encoding ?? DEFAULT_PARTITION_KEY_ENCODING;
+	const buffers = /* @__PURE__ */ new Map();
+	function connect() {
+		connection ??= connectIcebergCatalog(options.catalog, options.connect);
+		return connection;
+	}
+	return {
+		capabilities: { appendOnly: true },
+		async emit(slice, rows) {
+			if (rows.length === 0) return { rowCount: 0 };
+			const records = toRecords(slice, rows, encoding);
+			const buffer = buffers.get(slice.table);
+			if (buffer) for (let i = 0; i < records.length; i++) buffer.push(records[i]);
+			else buffers.set(slice.table, records);
+			return { rowCount: records.length };
+		},
+		async close() {
+			const flushed = [];
+			const failed = [];
+			if (buffers.size === 0) return {
+				flushed,
+				failed
+			};
+			const conn = await connect().then((c) => c, (cause) => {
+				connection = void 0;
+				return { connectError: cause };
+			});
+			if ("connectError" in conn) {
+				for (const [table, records] of buffers) if (records.length > 0) failed.push({
+					table,
+					error: engineErrors.sinkTableFlushFailed(table, conn.connectError)
+				});
+				buffers.clear();
+				return {
+					flushed,
+					failed
+				};
+			}
+			for (const [table, records] of buffers) {
+				if (records.length === 0) continue;
+				const deduped = sortByClusterKey(table, dedupeByIdentity(table, records));
+				await icebergAppendRetrying({
+					catalog: conn.catalog,
+					namespace: conn.namespace,
+					table,
+					resolver: conn.resolver,
+					records: deduped
+				}, options.commitRetry).then(() => {
+					flushed.push(table);
+				}, (cause) => {
+					failed.push({
+						table,
+						error: engineErrors.sinkTableFlushFailed(table, cause)
+					});
+				});
+			}
+			buffers.clear();
+			return {
+				flushed,
+				failed
+			};
+		}
+	};
+}
+export { createIcebergAppendSink };

package/dist/iceberg/catalog.d.mts

@@ -0,0 +1,71 @@
+import { EngineError } from "../errors.mjs";
+import { IcebergTableName, PartitionKeyEncoding } from "./schema.mjs";
+import { icebergCreateTable } from "../node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/types/write/write.mjs";
+import "../node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/types/index.mjs";
+import { Result } from "gscdump/result";
+import { CommitRetryOptions, ConnectIcebergOptions, IcebergCatalogConfig, IcebergConnection, IcebergListedDataFile, QueryProfiler } from "@gscdump/lakehouse";
+type IcebirdCreateTableOptions = Parameters<typeof icebergCreateTable>[0];
+type IcebirdSchema = NonNullable<IcebirdCreateTableOptions['schema']>;
+type IcebirdPartitionSpec = NonNullable<IcebirdCreateTableOptions['partitionSpec']>;
+type IcebirdSortOrder = NonNullable<IcebirdCreateTableOptions['sortOrder']>;
+/**
+ * Build the icebird `Schema` for one of the 9 fact tables from the frozen
+ * `ICEBERG_SCHEMAS` contract. Field ids are advisory — R2 Data Catalog
+ * re-assigns them on `createTable`.
+ */
+declare function icebergSchemaFor(table: IcebergTableName, encoding?: PartitionKeyEncoding): IcebirdSchema;
+/**
+ * Build the icebird `PartitionSpec` for one of the 9 fact tables: the locked
+ * spec `identity(site_id) + identity(search_type) + month(date)`.
+ */
+declare function icebergPartitionSpecFor(table: IcebergTableName, encoding?: PartitionKeyEncoding): IcebirdPartitionSpec;
+/**
+ * Build the icebird `SortOrder` for a fact table from its `clusterKey`
+ * (dimension-first, then `date`).
+ */
+declare function icebergSortOrderFor(table: IcebergTableName, encoding?: PartitionKeyEncoding): IcebirdSortOrder;
+/**
+ * Outcome of a single table create/drop: the table name plus a `Result` —
+ * `Ok(void)` on success, `Err(iceberg-table-op-failed)` carrying the failure
+ * message when the catalog rejects the op. Per-table so a partial
+ * provisioning run is fully observable.
+ */
+interface IcebergTableOpResult {
+  table: string;
+  outcome: Result<void, EngineError>;
+}
+/**
+ * Create the global Iceberg fact tables with the locked partition spec and
+ * the schema derived from {@link ICEBERG_SCHEMAS}. Per-table errors are
+ * captured rather than thrown so a partial run is observable.
+ */
+declare function createIcebergTables(conn: IcebergConnection, tables?: readonly IcebergTableName[], encoding?: PartitionKeyEncoding): Promise<IcebergTableOpResult[]>;
+/**
+ * Drop tables from the catalog namespace, purging their data objects.
+ * Defaults to every table currently in the namespace. Delegates the walk to
+ * `@gscdump/lakehouse`'s generic `dropIcebergTables`, mapping its simpler
+ * `{table, ok, error?}` result back onto the engine's original `Result`-typed
+ * {@link IcebergTableOpResult} contract.
+ */
+declare function dropIcebergTables$1(conn: IcebergConnection, tables?: readonly string[]): Promise<IcebergTableOpResult[]>;
+interface ListIcebergDataFilesOptions {
+  table: IcebergTableName;
+  /** Partition identity column. `number` for `'int'`-encoded catalogs. */
+  siteId: string | number;
+  /** Partition identity column. `number` (int code) for `'int'`-encoded catalogs. */
+  searchType: string | number;
+  encoding?: PartitionKeyEncoding;
+  range: {
+    start: string;
+    end: string;
+  };
+  cache?: import('@gscdump/lakehouse').CatalogCache;
+  clock?: () => number;
+  profiler?: QueryProfiler;
+}
+/**
+ * List the parquet data files in the current snapshot of `table`, filtered to
+ * a single partition slice `(siteId, searchType, month(date) ∈ range)`.
+ */
+declare function listIcebergDataFiles(conn: IcebergConnection, opts: ListIcebergDataFilesOptions): Promise<IcebergListedDataFile[]>;
+export { type CommitRetryOptions, type ConnectIcebergOptions, type IcebergCatalogConfig, IcebergTableOpResult, ListIcebergDataFilesOptions, createIcebergTables, dropIcebergTables$1 as dropIcebergTables, icebergPartitionSpecFor, icebergSchemaFor, icebergSortOrderFor, listIcebergDataFiles };

package/dist/iceberg/catalog.mjs

@@ -0,0 +1,109 @@
+import { engineErrors } from "../errors.mjs";
+import { TABLE_METADATA } from "../drizzle-schema.mjs";
+import "../schema.mjs";
+import { DEFAULT_PARTITION_KEY_ENCODING, ICEBERG_PARTITION_SPEC, ICEBERG_TABLES, icebergSchemasFor } from "./schema.mjs";
+import { icebergCreateTable } from "../node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/write/write.mjs";
+import "../node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/index.mjs";
+import { err, ok } from "gscdump/result";
+import { ICEBERG_TYPE_MAP, connectIcebergCatalog, dropIcebergTables, resolveIcebergDataFiles } from "@gscdump/lakehouse";
+import { icebergAppendRetrying } from "@gscdump/lakehouse/unsafe-raw";
+function icebergSchemaFor(table, encoding = DEFAULT_PARTITION_KEY_ENCODING) {
+	return {
+		"type": "struct",
+		"schema-id": 0,
+		"fields": icebergSchemasFor(encoding)[table].columns.map((col) => ({
+			id: col.fieldId,
+			name: col.name,
+			required: col.required,
+			type: ICEBERG_TYPE_MAP[col.type]
+		}))
+	};
+}
+function icebergPartitionSpecFor(table, encoding = DEFAULT_PARTITION_KEY_ENCODING) {
+	const fields = icebergSchemasFor(encoding)[table].columns;
+	const fieldId = (name) => {
+		const col = fields.find((c) => c.name === name);
+		if (!col) throw new Error(`iceberg-catalog: table '${table}' has no '${name}' column`);
+		return col.fieldId;
+	};
+	return {
+		"spec-id": 0,
+		"fields": ICEBERG_PARTITION_SPEC.map((p, i) => ({
+			"source-id": fieldId(p.sourceColumn),
+			"field-id": 1e3 + i,
+			"name": p.name,
+			"transform": p.transform
+		}))
+	};
+}
+function icebergSortOrderFor(table, encoding = DEFAULT_PARTITION_KEY_ENCODING) {
+	const fields = icebergSchemasFor(encoding)[table].columns;
+	const fieldId = (name) => {
+		const col = fields.find((c) => c.name === name);
+		if (!col) throw new Error(`iceberg-catalog: table '${table}' has no '${name}' column`);
+		return col.fieldId;
+	};
+	return {
+		"order-id": 1,
+		"fields": TABLE_METADATA[table].clusterKey.map((col) => ({
+			"source-id": fieldId(col),
+			"transform": "identity",
+			"direction": "asc",
+			"null-order": "nulls-last"
+		}))
+	};
+}
+async function createIcebergTables(conn, tables = ICEBERG_TABLES, encoding = DEFAULT_PARTITION_KEY_ENCODING) {
+	const results = [];
+	for (const table of tables) await icebergCreateTable({
+		catalog: conn.catalog,
+		namespace: conn.namespace,
+		table,
+		schema: icebergSchemaFor(table, encoding),
+		partitionSpec: icebergPartitionSpecFor(table, encoding),
+		sortOrder: icebergSortOrderFor(table, encoding)
+	}).then(() => results.push({
+		table,
+		outcome: ok(void 0)
+	}), (e) => results.push({
+		table,
+		outcome: err(engineErrors.icebergTableOpFailed("create", table, e))
+	}));
+	return results;
+}
+async function dropIcebergTables$1(conn, tables) {
+	return (await dropIcebergTables(conn, tables)).map((r) => ({
+		table: r.table,
+		outcome: r.ok ? ok(void 0) : err(engineErrors.icebergTableOpFailed("drop", r.table, r.error))
+	}));
+}
+async function listIcebergDataFiles(conn, opts) {
+	const matches = (opts.encoding ?? DEFAULT_PARTITION_KEY_ENCODING) === "string" ? [{
+		field: "site_id",
+		value: opts.siteId,
+		encoding: "string"
+	}, {
+		field: "search_type",
+		value: opts.searchType,
+		encoding: "string"
+	}] : [{
+		field: "site_id",
+		value: opts.siteId,
+		encoding: "int32"
+	}, {
+		field: "search_type",
+		value: opts.searchType,
+		encoding: "int32"
+	}];
+	return resolveIcebergDataFiles(conn, {
+		namespace: conn.namespace,
+		table: opts.table,
+		partitionSpec: ICEBERG_PARTITION_SPEC,
+		matches,
+		range: opts.range,
+		cache: opts.cache,
+		clock: opts.clock,
+		profiler: opts.profiler
+	});
+}
+export { connectIcebergCatalog, createIcebergTables, dropIcebergTables$1 as dropIcebergTables, icebergAppendRetrying, icebergPartitionSpecFor, icebergSchemaFor, icebergSortOrderFor, listIcebergDataFiles };

package/dist/iceberg/index.d.mts

@@ -1,14 +1,5 @@
-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.
- *
- * `emit` buffers; `close()` commits one `icebergAppend()` per table touched.
- * The catalog connection (REST context + signed S3 resolver) is established
- * lazily on the first flush and reused — a sink that is opened and closed
- * with no rows never touches the network. `options.connect` is forwarded so
- * Worker callers can share the `/v1/config` context through a durable cache;
- * without it every fresh sink/isolate must probe the catalog again.
- */
-declare function createIcebergAppendSink(options: IcebergAppendSinkOptions): IcebergAppendSink;
+import { ICEBERG_FIELD_ID_BASE, ICEBERG_PARTITION_COLUMNS, ICEBERG_PARTITION_SPEC, ICEBERG_SCHEMAS, ICEBERG_SCHEMAS_INT, ICEBERG_SCHEMAS_STRING, ICEBERG_TABLES, INT_SEARCH_TYPE, IcebergTableName, SEARCH_TYPE_INT, assertIcebergTable, icebergPartitionColumns, icebergSchemasFor, icebergTableSpec, isIcebergTable } from "./schema.mjs";
+import { IcebergTableOpResult, ListIcebergDataFilesOptions, createIcebergTables, dropIcebergTables, icebergPartitionSpecFor, icebergSchemaFor, icebergSortOrderFor, listIcebergDataFiles } from "./catalog.mjs";
+import { IcebergAppendSinkOptions } from "../sink.mjs";
+import { IcebergAppendSink, createIcebergAppendSink } from "./append-sink.mjs";
 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 };