@gscdump/lakehouse 0.1.0

package/dist/_chunks/catalog.d.mts

@@ -0,0 +1,236 @@
+import { Storage } from "./libs/unstorage.mjs";
+import { IcebergColumnType, IcebergPartitionField, IcebergS3Config } from "./schema.mjs";
+import { cachingResolver, icebergAppend, restCatalogConnect } from "./libs/icebird.mjs";
+/** Injected catalog cache: an unstorage `Storage` plus an optional defer hook. */
+interface CatalogCache {
+  /** unstorage storage instance — the driver is the caller's choice. */
+  storage: Storage;
+  /**
+   * Optional hook to run a cache WRITE off the response critical path, e.g.
+   * Cloudflare's `ctx.waitUntil`. When omitted the writer awaits the put
+   * inline so it is never cut off when the response returns.
+   */
+  defer?: (write: Promise<unknown>) => void;
+}
+/**
+ * Read a cached value. Returns `undefined` on a miss, an expired entry, a
+ * malformed box, or any driver error (the cache is best-effort: a read failure
+ * degrades to a fresh load, never to an error).
+ */
+declare function cacheGet<T>(cache: CatalogCache, key: string, now: number): Promise<T | undefined>;
+/**
+ * Write a cached value with an embedded expiry and a forwarded driver TTL.
+ *
+ * Returns the write promise. With a `defer` hook the write is handed to the
+ * hook and a resolved promise is returned (the response is not blocked on it);
+ * without one the write promise is returned for the caller to await, so a
+ * fire-and-forget put is never silently dropped. Driver errors are swallowed —
+ * a failed cache write must not fail the read.
+ */
+declare function cachePut<T>(cache: CatalogCache, key: string, value: T, ttlMs: number, now: number): Promise<void>;
+/** Minimal shape of an icebird manifest-list `partitions` field-summary. */
+interface IcebergFieldSummary {
+  contains_null: boolean;
+  contains_nan?: boolean | null;
+  lower_bound?: Uint8Array | null;
+  upper_bound?: Uint8Array | null;
+}
+/** Predicate handed to icebird's patched `icebergManifests({ partitionFilter })`. */
+type ManifestPartitionFilter = (partitions: IcebergFieldSummary[] | undefined) => boolean;
+/**
+ * One identity/dims value to prune an `identity`-transform partition field by.
+ *
+ * `'int32'`-encoded fields are deliberately NOT pruned here (mirrors the
+ * original engine behavior): an INT column's bound bytes are a 4-byte int, but
+ * per-team catalogs are single-tenant, so identity pruning on them saves ~nothing
+ * — the per-file partition check in the resolver remains the authoritative
+ * correctness filter. Only `'string'`-encoded identity fields are pruned by
+ * lexicographic UTF-8 bound comparison (the truncated-string-stats case R2 SQL
+ * needs the workaround for).
+ */
+interface PartitionValueMatch {
+  /** Partition field name as declared in the partition spec (e.g. `'site_id'`). */
+  field: string;
+  value: string | number;
+  encoding: 'string' | 'int32';
+}
+/**
+ * Build the `partitionFilter` predicate for a slice of `matches` (identity/dims
+ * value equality) plus an optional `wantedMonths` set (for a `month`-transform
+ * field in `partitionSpec`). Returns `false` to skip a manifest, `true` to keep
+ * it. Keep-all when a manifest carries no `partitions` summaries.
+ */
+declare function buildManifestPartitionFilter(partitionSpec: readonly IcebergPartitionField[], matches: readonly PartitionValueMatch[], wantedMonths?: ReadonlySet<number>): ManifestPartitionFilter;
+/** icebird's lowercase Iceberg primitive types (subset we use). */
+type IcebergPrimitiveType = 'string' | 'int' | 'long' | 'double' | 'date' | 'boolean';
+/** A field in an icebird table `Schema`. */
+interface IcebergSchemaField {
+  id: number;
+  name: string;
+  required: boolean;
+  type: IcebergPrimitiveType;
+}
+/** An icebird table `Schema` (Iceberg `struct`). */
+interface IcebergSchema {
+  'type': 'struct';
+  'schema-id': number;
+  'fields': IcebergSchemaField[];
+}
+/** A field in an icebird `PartitionSpec`. */
+interface IcebergPartitionSpecField {
+  'source-id': number;
+  'field-id': number;
+  'name': string;
+  'transform': 'identity' | 'month';
+}
+/** An icebird `PartitionSpec`. */
+interface IcebergPartitionSpec {
+  'spec-id': number;
+  'fields': IcebergPartitionSpecField[];
+}
+/** A field in an icebird `SortOrder`. */
+interface IcebergSortOrderField {
+  'source-id': number;
+  'transform': 'identity';
+  'direction': 'asc' | 'desc';
+  'null-order': 'nulls-first' | 'nulls-last';
+}
+/** An icebird `SortOrder` (Iceberg write-order). */
+interface IcebergSortOrder {
+  'order-id': number;
+  'fields': IcebergSortOrderField[];
+}
+/** Everything needed to talk to the R2 Data Catalog. */
+interface IcebergCatalogConfig {
+  /** REST catalog URI, e.g. `https://catalog.cloudflarestorage.com/<acct>/<warehouse>`. */
+  catalogUri: string;
+  /** Warehouse identifier, e.g. `<acct>_<bucket>`. */
+  warehouse: string;
+  /** Catalog namespace the dataset's table lives under (e.g. `gsc`, `crawl`). */
+  namespace: string;
+  /** Bearer token for the REST catalog. */
+  catalogToken: string;
+  /** R2 S3 credentials for the warehouse objects. */
+  s3: IcebergS3Config;
+}
+/** The connected catalog context + a signed S3 resolver — the icebird call inputs. */
+interface IcebergConnection {
+  /** icebird REST catalog context, passed as `{ catalog }` to icebird write fns. */
+  catalog: Awaited<ReturnType<typeof restCatalogConnect>>;
+  /** icebird S3 resolver (caching-wrapped), passed as `{ resolver }` to icebird fns. */
+  resolver: ReturnType<typeof cachingResolver>;
+  /** The namespace the dataset's table lives under. */
+  namespace: string;
+}
+declare const ICEBERG_TYPE_MAP: Record<IcebergColumnType, IcebergPrimitiveType>;
+/** Options for {@link connectIcebergCatalog}. */
+interface ConnectIcebergOptions {
+  /**
+   * Optional cross-isolate cache (any unstorage driver). When supplied, the
+   * `/v1/config` REST probe is served from cache on a warm catalog.
+   */
+  cache?: CatalogCache;
+  /** Injectable clock for the cache TTL. Defaults to `Date.now`. */
+  clock?: () => number;
+}
+/**
+ * Connect to the R2 Data Catalog: a REST catalog context + a signed S3
+ * resolver. Runs in Node and in `workerd` — SigV4 is Web Crypto, I/O is
+ * `fetch`, no node builtins.
+ */
+declare function connectIcebergCatalog(config: IcebergCatalogConfig, opts?: ConnectIcebergOptions): Promise<IcebergConnection>;
+/**
+ * Ensure the catalog namespace exists. Idempotent — an "already exists"
+ * response from the REST catalog is swallowed.
+ */
+declare function ensureIcebergNamespace(conn: IcebergConnection): Promise<void>;
+/**
+ * List the table names currently in the catalog namespace.
+ *
+ * A genuinely-empty namespace resolves to `[]`. A LIST *failure* (catalog
+ * unreachable, 401/403, 5xx) propagates rather than being masked as an empty
+ * list — callers must be able to tell "no tables" from "couldn't ask".
+ */
+declare function listIcebergTables(conn: IcebergConnection): Promise<string[]>;
+/** Outcome of a single table create/drop op. */
+interface IcebergTableOpResult {
+  table: string;
+  ok: boolean;
+  error?: string;
+}
+/**
+ * Drop tables from the catalog namespace, purging their data objects.
+ * Defaults to every table currently in the namespace.
+ */
+declare function dropIcebergTables(conn: IcebergConnection, tables?: readonly string[]): Promise<IcebergTableOpResult[]>;
+/** Tunable retry policy for {@link icebergAppendRetrying}. */
+interface CommitRetryOptions {
+  /** Total attempts, including the first. Default 6. */
+  maxAttempts?: number;
+  /** Base (ms) for the exponential back-off ceiling. Default 1000. */
+  baseDelayMs?: number;
+  /** Hard cap (ms) on the back-off ceiling. Default 20_000. */
+  maxDelayMs?: number;
+  /** Injectable sleep — tests pass a synchronous no-op. */
+  sleep?: (ms: number) => Promise<void>;
+  /** Injectable RNG for the jitter — tests pass a deterministic value. */
+  random?: () => number;
+  /**
+   * Idempotency token stamped into the appended snapshot's summary
+   * (`lakehouse.append-id`) and matched by the landed-check. When omitted it is
+   * DERIVED from the records' content, making the token STABLE across
+   * PROCESSES, not just within one call's retry loop.
+   */
+  appendId?: string;
+}
+/**
+ * True when `err` is an R2 Data Catalog commit rate-limit response
+ * (`429 too many commits to this table`).
+ */
+declare function isCommitRateLimited(err: unknown): boolean;
+/**
+ * `icebergAppend` wrapped with retry on R2 Data Catalog 429 commit
+ * rate-limits, using full-jitter exponential back-off, plus a landed-check
+ * idempotency guard so a 429 whose commit actually landed is never re-applied
+ * (see `deriveAppendId`/`appendAlreadyLanded`).
+ */
+declare function icebergAppendRetrying(args: Parameters<typeof icebergAppend>[0], options?: CommitRetryOptions): Promise<void>;
+/** A data file in the current snapshot's manifest, scoped to one partition. */
+interface IcebergListedDataFile {
+  filePath: string;
+  objectKey: string;
+  bytes: number;
+  rowCount: number;
+}
+/** Minimal profiler contract — start a named span, get back an end callback. */
+interface QueryProfiler {
+  start: (name: string) => ((meta?: Record<string, unknown>) => void) | undefined;
+}
+interface ResolveIcebergDataFilesOptions {
+  namespace: string;
+  table: string;
+  /** Partition spec for this table — used both for the manifest prune and the per-file check. */
+  partitionSpec: readonly {
+    sourceColumn: string;
+    transform: 'identity' | 'month';
+    name: string;
+  }[];
+  /** Identity/dims values to match. */
+  matches: readonly PartitionValueMatch[];
+  /** Inclusive date range. Every month touched by `[start, end]` is scanned. */
+  range: {
+    start: string;
+    end: string;
+  };
+  cache?: CatalogCache;
+  clock?: () => number;
+  profiler?: QueryProfiler;
+}
+/**
+ * List the parquet data files in the current snapshot of `table`, filtered to
+ * one partition slice (`matches` + `range`). Generic over the partition spec —
+ * the `IcebergDataset.resolveDataFiles` method is a thin wrapper that supplies
+ * the def's own spec + identity/dims values.
+ */
+declare function resolveIcebergDataFiles(conn: IcebergConnection, opts: ResolveIcebergDataFilesOptions): Promise<IcebergListedDataFile[]>;
+export { CatalogCache, CommitRetryOptions, ConnectIcebergOptions, ICEBERG_TYPE_MAP, IcebergCatalogConfig, IcebergConnection, IcebergFieldSummary, IcebergListedDataFile, IcebergPartitionSpec, IcebergPartitionSpecField, IcebergPrimitiveType, IcebergSchema, IcebergSchemaField, IcebergSortOrder, IcebergSortOrderField, IcebergTableOpResult, ManifestPartitionFilter, PartitionValueMatch, QueryProfiler, ResolveIcebergDataFilesOptions, buildManifestPartitionFilter, cacheGet, cachePut, connectIcebergCatalog, dropIcebergTables, ensureIcebergNamespace, icebergAppendRetrying, isCommitRateLimited, listIcebergTables, resolveIcebergDataFiles };

package/dist/_chunks/catalog.mjs

@@ -0,0 +1,331 @@
+import { cachingResolver, icebergAppend, icebergDropTable, icebergManifests, restCatalogConnect, restCatalogCreateNamespace, restCatalogListTables, restCatalogLoadTable, s3SignedResolver } from "./libs/icebird.mjs";
+async function cacheGet(cache, key, now) {
+	const boxed = await cache.storage.getItem(key).catch(() => null);
+	if (!boxed || typeof boxed.exp !== "number" || boxed.exp <= now) return void 0;
+	return boxed.v;
+}
+function cachePut(cache, key, value, ttlMs, now) {
+	const boxed = {
+		v: value,
+		exp: now + ttlMs
+	};
+	const write = cache.storage.setItem(key, boxed, { ttl: Math.ceil(ttlMs / 1e3) }).catch(() => {});
+	if (cache.defer) {
+		cache.defer(write);
+		return Promise.resolve();
+	}
+	return write;
+}
+function toUint8(bytes) {
+	if (bytes == null) return null;
+	return bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+}
+function decodeString(bytes) {
+	const u = toUint8(bytes);
+	return u == null ? null : new TextDecoder().decode(u);
+}
+function decodeMonthInt(bytes) {
+	const u = toUint8(bytes);
+	if (u == null) return null;
+	return new DataView(u.buffer, u.byteOffset, u.byteLength).getInt32(0, true);
+}
+function buildManifestPartitionFilter(partitionSpec, matches, wantedMonths) {
+	const fieldIndex = (name) => partitionSpec.findIndex((f) => f.name === name || f.sourceColumn === name);
+	const monthFieldIndex = partitionSpec.findIndex((f) => f.transform === "month");
+	return (partitions) => {
+		if (!partitions || partitions.length === 0) return true;
+		for (const match of matches) {
+			if (match.encoding !== "string") continue;
+			const idx = fieldIndex(match.field);
+			if (idx < 0) continue;
+			const summary = partitions[idx];
+			if (!summary || summary.lower_bound == null && summary.upper_bound == null) continue;
+			const lo = decodeString(summary.lower_bound);
+			const hi = decodeString(summary.upper_bound);
+			const wantStr = String(match.value);
+			if (lo != null && hi != null && (wantStr < lo || wantStr > hi)) return false;
+		}
+		if (wantedMonths && wantedMonths.size > 0 && monthFieldIndex >= 0) {
+			const monthSummary = partitions[monthFieldIndex];
+			if (monthSummary && (monthSummary.lower_bound != null || monthSummary.upper_bound != null)) {
+				const lo = decodeMonthInt(monthSummary.lower_bound);
+				const hi = decodeMonthInt(monthSummary.upper_bound);
+				if (lo != null && hi != null) {
+					let anyInRange = false;
+					for (const wm of wantedMonths) if (wm >= lo && wm <= hi) {
+						anyInRange = true;
+						break;
+					}
+					if (!anyInRange) return false;
+				}
+			}
+		}
+		return true;
+	};
+}
+const ICEBERG_TYPE_MAP = {
+	STRING: "string",
+	INT: "int",
+	LONG: "long",
+	DOUBLE: "double",
+	DATE: "date",
+	BOOLEAN: "boolean"
+};
+const CATALOG_CONFIG_TTL_MS = 3600 * 1e3;
+function catalogConfigKey(config) {
+	return `lakehouse-catalog-cfg\0${config.catalogUri}\0${config.warehouse}`;
+}
+async function connectIcebergCatalog(config, opts = {}) {
+	const now = (opts.clock ?? Date.now)();
+	const requestInit = { headers: { Authorization: `Bearer ${config.catalogToken}` } };
+	let catalog;
+	if (opts.cache) {
+		const cached = await cacheGet(opts.cache, catalogConfigKey(config), now);
+		if (cached) catalog = Object.freeze({
+			type: "rest",
+			url: cached.url,
+			prefix: cached.prefix,
+			defaults: cached.defaults,
+			overrides: cached.overrides,
+			requestInit
+		});
+	}
+	if (!catalog) {
+		catalog = await restCatalogConnect({
+			url: config.catalogUri,
+			warehouse: config.warehouse,
+			requestInit
+		});
+		if (opts.cache) {
+			const toCache = {
+				url: catalog.url,
+				prefix: catalog.prefix,
+				defaults: catalog.defaults,
+				overrides: catalog.overrides
+			};
+			await cachePut(opts.cache, catalogConfigKey(config), toCache, CATALOG_CONFIG_TTL_MS, now);
+		}
+	}
+	const resolver = cachingResolver(s3SignedResolver({
+		accessKeyId: config.s3.accessKeyId,
+		secretAccessKey: config.s3.secretAccessKey,
+		region: config.s3.region ?? "auto",
+		endpoint: config.s3.endpoint,
+		pathStyle: true
+	}));
+	return {
+		catalog,
+		resolver,
+		namespace: config.namespace
+	};
+}
+async function ensureIcebergNamespace(conn) {
+	await restCatalogCreateNamespace(conn.catalog, { namespace: conn.namespace }).catch(() => {});
+}
+async function listIcebergTables(conn) {
+	return (await restCatalogListTables(conn.catalog, { namespace: conn.namespace })).map((t) => t.name).sort();
+}
+async function dropIcebergTables(conn, tables) {
+	const targets = tables ?? (await restCatalogListTables(conn.catalog, { namespace: conn.namespace })).map((t) => t.name);
+	const results = [];
+	for (const table of targets) await icebergDropTable({
+		catalog: conn.catalog,
+		namespace: conn.namespace,
+		table,
+		purgeRequested: true
+	}).then(() => results.push({
+		table,
+		ok: true
+	}), (e) => results.push({
+		table,
+		ok: false,
+		error: e instanceof Error ? e.message : String(e)
+	}));
+	return results;
+}
+const APPEND_ID_SUMMARY_KEY = "lakehouse.append-id";
+const APPEND_LANDED_SCAN_DEPTH = 25;
+function isCommitRateLimited(err) {
+	if (err && typeof err === "object" && err.status === 429) return true;
+	const msg = (err instanceof Error ? err.message : String(err)).toLowerCase();
+	return msg.includes("429") || msg.includes("too many commits") || msg.includes("rate limit");
+}
+function defaultCommitSleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function icebergAppendRetrying(args, options = {}) {
+	const maxAttempts = options.maxAttempts ?? 6;
+	const baseDelayMs = options.baseDelayMs ?? 1e3;
+	const maxDelayMs = options.maxDelayMs ?? 2e4;
+	const sleep = options.sleep ?? defaultCommitSleep;
+	const random = options.random ?? Math.random;
+	const appendId = options.appendId ?? await deriveAppendId(args);
+	const stampedArgs = {
+		...args,
+		snapshotProperties: {
+			...args.snapshotProperties,
+			[APPEND_ID_SUMMARY_KEY]: appendId
+		}
+	};
+	if (await appendAlreadyLanded(args, appendId).catch(() => false)) return;
+	for (let attempt = 0; attempt < maxAttempts; attempt++) {
+		const err = await icebergAppend(stampedArgs).then(() => void 0, (e) => e);
+		if (err === void 0) return;
+		if (await appendAlreadyLanded(args, appendId).catch(() => false)) return;
+		if (!isCommitRateLimited(err) || attempt === maxAttempts - 1) throw err;
+		const ceiling = Math.min(maxDelayMs, baseDelayMs * 2 ** attempt);
+		await sleep(Math.floor(random() * ceiling));
+	}
+}
+async function deriveAppendId(args) {
+	const records = args.records ?? [];
+	if (records.length === 0) return globalThis.crypto.randomUUID();
+	const rowSig = (r) => Object.keys(r).sort().map((k) => `${k}=${String(r[k])}`).join("");
+	const body = records.map(rowSig).sort().join("");
+	const digest = await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(body));
+	return Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function appendAlreadyLanded(args, appendId) {
+	const a = args;
+	if (a.catalog?.type !== "rest" || a.namespace == null || a.table == null) return false;
+	const { metadata } = await restCatalogLoadTable(a.catalog, {
+		namespace: a.namespace,
+		table: a.table
+	});
+	const snapshots = metadata.snapshots ?? [];
+	const from = Math.max(0, snapshots.length - APPEND_LANDED_SCAN_DEPTH);
+	for (let i = snapshots.length - 1; i >= from; i--) if (snapshots[i]?.summary?.[APPEND_ID_SUMMARY_KEY] === appendId) return true;
+	return false;
+}
+const SNAPSHOT_REF_TTL_MS = 1800 * 1e3;
+const RESOLVED_FILES_TTL_MS = 1440 * 60 * 1e3;
+const METADATA_TTL_MS = 1440 * 60 * 1e3;
+const MAX_CACHED_METADATA_BYTES = 2 * 1024 * 1024;
+function snapshotRefKey(namespace, table) {
+	return `lh-snapref\0${namespace}\0${table}`;
+}
+function metadataRefKey(namespace, table, snapshotId) {
+	return `lh-snapmeta\0${namespace}\0${table}\0${snapshotId}`;
+}
+function resolvedFilesKey(namespace, table, snapshotId, matches, wantedMonths) {
+	return `lh-files\0${namespace}\0${table}\0${snapshotId}\0${[...matches].map((m) => `${m.field}=${m.value}`).sort().join(",")}\0${[...wantedMonths].sort((a, b) => a - b).join(",")}`;
+}
+function monthsInRange(range) {
+	const [sy, sm] = range.start.split("-").map(Number);
+	const [ey, em] = range.end.split("-").map(Number);
+	const out = [];
+	let y = sy;
+	let m = sm;
+	while (y < ey || y === ey && m <= em) {
+		out.push(`${y}-${String(m).padStart(2, "0")}`);
+		m++;
+		if (m > 12) {
+			m = 1;
+			y++;
+		}
+	}
+	return out;
+}
+function monthsSinceEpoch(ym) {
+	const [y, m] = ym.split("-").map(Number);
+	return (y - 1970) * 12 + (m - 1);
+}
+function stripBucket(filePath) {
+	if (!filePath.startsWith("s3://")) return filePath;
+	const rest = filePath.slice(5);
+	const slash = rest.indexOf("/");
+	return slash >= 0 ? rest.slice(slash + 1) : rest;
+}
+async function loadSnapshotId(conn, namespace, table, cache, now) {
+	if (cache) {
+		const cached = await cacheGet(cache, snapshotRefKey(namespace, table), now);
+		if (cached !== void 0) return {
+			snapshotId: cached,
+			metadata: null
+		};
+	}
+	const { metadata } = await restCatalogLoadTable(conn.catalog, {
+		namespace,
+		table
+	});
+	const raw = metadata["current-snapshot-id"];
+	const snapshotId = raw == null ? null : String(raw);
+	if (cache) {
+		await cachePut(cache, snapshotRefKey(namespace, table), snapshotId, SNAPSHOT_REF_TTL_MS, now);
+		if (snapshotId != null) {
+			if (JSON.stringify(metadata).length <= MAX_CACHED_METADATA_BYTES) await cachePut(cache, metadataRefKey(namespace, table, snapshotId), metadata, METADATA_TTL_MS, now);
+		}
+	}
+	return {
+		snapshotId,
+		metadata
+	};
+}
+async function resolveIcebergDataFiles(conn, opts) {
+	const { namespace, table } = opts;
+	const profiler = opts.profiler;
+	const now = (opts.clock ?? Date.now)();
+	const wantedMonths = new Set(monthsInRange(opts.range).map(monthsSinceEpoch));
+	const endSnapshot = profiler?.start("iceberg.snapshot");
+	let { snapshotId, metadata } = await loadSnapshotId(conn, namespace, table, opts.cache, now);
+	endSnapshot?.({ cached: metadata == null && snapshotId != null });
+	if (snapshotId == null) return [];
+	const filesKey = resolvedFilesKey(namespace, table, snapshotId, opts.matches, wantedMonths);
+	if (opts.cache) {
+		const endCache = profiler?.start("iceberg.cache");
+		const cached = await cacheGet(opts.cache, filesKey, now);
+		endCache?.({ hit: cached !== void 0 });
+		if (cached !== void 0) return cached;
+	}
+	if (!metadata && opts.cache) {
+		const cachedMeta = await cacheGet(opts.cache, metadataRefKey(namespace, table, snapshotId), now);
+		if (cachedMeta != null) metadata = cachedMeta;
+	}
+	if (!metadata) {
+		const reloaded = await loadSnapshotId(conn, namespace, table, void 0, now);
+		snapshotId = reloaded.snapshotId;
+		metadata = reloaded.metadata;
+		if (snapshotId == null || !metadata) return [];
+	}
+	const endWalk = profiler?.start("iceberg.walk");
+	const partitionFilter = buildManifestPartitionFilter(opts.partitionSpec, opts.matches, wantedMonths);
+	const manifests = await icebergManifests({
+		metadata,
+		resolver: conn.resolver,
+		partitionFilter
+	});
+	const monthFieldName = opts.partitionSpec.find((f) => f.transform === "month")?.name;
+	const out = [];
+	for (const m of manifests) for (const entry of m.entries) {
+		if (entry.status === 2) continue;
+		const df = entry.data_file;
+		if (df.content !== 0) continue;
+		const part = df.partition;
+		let matchesAll = true;
+		for (const match of opts.matches) if (String(part[match.field]) !== String(match.value)) {
+			matchesAll = false;
+			break;
+		}
+		if (!matchesAll) continue;
+		if (monthFieldName) {
+			const month = part[monthFieldName];
+			if (typeof month !== "number" || !wantedMonths.has(month)) continue;
+		}
+		out.push({
+			filePath: df.file_path,
+			objectKey: stripBucket(df.file_path),
+			bytes: Number(df.file_size_in_bytes),
+			rowCount: Number(df.record_count)
+		});
+	}
+	endWalk?.({
+		manifests: manifests.length,
+		files: out.length
+	});
+	if (opts.cache) {
+		const freshKey = resolvedFilesKey(namespace, table, snapshotId, opts.matches, wantedMonths);
+		await cachePut(opts.cache, freshKey, out, RESOLVED_FILES_TTL_MS, now);
+	}
+	return out;
+}
+export { ICEBERG_TYPE_MAP, buildManifestPartitionFilter, cacheGet, cachePut, connectIcebergCatalog, dropIcebergTables, ensureIcebergNamespace, icebergAppendRetrying, isCommitRateLimited, listIcebergTables, resolveIcebergDataFiles };

package/dist/_chunks/libs/@netlify/blobs.d.mts

@@ -0,0 +1,6 @@
+declare global {
+  var netlifyBlobsContext: unknown;
+}
+/**
+ * The context object that we expect in the environment.
+ */

package/dist/_chunks/libs/chokidar.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/_chunks/libs/db0.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/_chunks/libs/denque.d.mts

@@ -0,0 +1 @@
+export { };