@gscdump/lakehouse 1.4.0 → 1.4.1

package/dist/node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/write/transform.mjs

@@ -0,0 +1,220 @@
+import { typeName } from "../schema.mjs";
+import { uuidToBytes } from "./conversions.mjs";
+function parseTransform(transform) {
+	if (transform === "identity" || transform === "void" || transform === "year" || transform === "month" || transform === "day" || transform === "hour") return { kind: transform };
+	let m = /^bucket\[(\d+)\]$/.exec(transform);
+	if (m) {
+		const n = parseInt(m[1], 10);
+		if (n > 0) return {
+			kind: "bucket",
+			n
+		};
+	}
+	m = /^truncate\[(\d+)\]$/.exec(transform);
+	if (m) {
+		const w = parseInt(m[1], 10);
+		if (w > 0) return {
+			kind: "truncate",
+			w
+		};
+	}
+	throw new Error(`unsupported partition transform: ${transform}`);
+}
+function transformResultType(transform, sourceType) {
+	const parsed = parseTransform(transform);
+	validateTransformSource(parsed, sourceType);
+	switch (parsed.kind) {
+		case "identity":
+		case "truncate": return sourceType;
+		case "void": return "int";
+		case "year":
+		case "month":
+		case "day":
+		case "hour":
+		case "bucket": return "int";
+	}
+}
+function applyTransform(transform, value, sourceType) {
+	const parsed = parseTransform(transform);
+	validateTransformSource(parsed, sourceType);
+	if (value == null) return null;
+	switch (parsed.kind) {
+		case "identity": return value;
+		case "void": return null;
+		case "year": return yearTransform(value, sourceType);
+		case "month": return monthTransform(value, sourceType);
+		case "day": return dayTransform(value, sourceType);
+		case "hour": return hourTransform(value, sourceType);
+		case "bucket": return bucketTransform(value, sourceType, parsed.n);
+		case "truncate": return truncateTransform(value, sourceType, parsed.w);
+	}
+}
+function dateAsMillis(value, sourceType, transform) {
+	const t = typeName(sourceType);
+	validateTransformSource({ kind: transform }, sourceType);
+	if (value instanceof Date) return value.getTime();
+	const n = typeof value === "bigint" ? value : BigInt(value);
+	switch (t) {
+		case "date": return Number(n) * 864e5;
+		case "timestamp":
+		case "timestamptz": return Number(n / 1000n);
+		default: return Number(n / 1000000n);
+	}
+}
+function yearTransform(v, t) {
+	return new Date(dateAsMillis(v, t, "year")).getUTCFullYear() - 1970;
+}
+function monthTransform(v, t) {
+	const d = new Date(dateAsMillis(v, t, "month"));
+	return (d.getUTCFullYear() - 1970) * 12 + d.getUTCMonth();
+}
+function dayTransform(v, t) {
+	return Math.floor(dateAsMillis(v, t, "day") / 864e5);
+}
+function hourTransform(v, t) {
+	return Math.floor(dateAsMillis(v, t, "hour") / 36e5);
+}
+function bucketTransform(value, sourceType, n) {
+	return (murmur3_32(bucketBytes(value, sourceType), 0) & 2147483647) % n;
+}
+function bucketBytes(value, sourceType) {
+	const t = typeName(sourceType);
+	if (t.startsWith("decimal(")) return decimalToUnscaledBytes(value, t);
+	if (t === "uuid") return uuidToBytes(value, "uuid partition value");
+	if (t.startsWith("fixed[") || t === "binary" || t === "fixed") return value instanceof Uint8Array ? value : new Uint8Array(value);
+	switch (t) {
+		case "int":
+		case "long":
+		case "date":
+		case "time":
+		case "timestamp":
+		case "timestamptz":
+		case "timestamp_ns":
+		case "timestamptz_ns": {
+			let v;
+			if (t === "date") v = value instanceof Date ? BigInt(Math.floor(value.getTime() / 864e5)) : BigInt(value);
+			else if (t === "timestamp" || t === "timestamptz") v = value instanceof Date ? BigInt(value.getTime()) * 1000n : BigInt(value);
+			else if (t === "timestamp_ns" || t === "timestamptz_ns") v = value instanceof Date ? BigInt(value.getTime()) * 1000n : BigInt(value) / 1000n;
+			else v = typeof value === "bigint" ? value : BigInt(value);
+			const out = /* @__PURE__ */ new Uint8Array(8);
+			new DataView(out.buffer).setBigInt64(0, v, true);
+			return out;
+		}
+		case "string": return new TextEncoder().encode(String(value));
+		default: throw new Error(`bucket transform: unsupported source type ${t}`);
+	}
+}
+function decimalToUnscaledBytes(value, decimalType) {
+	const m = /^decimal\((\d+),\s*(\d+)\)$/.exec(decimalType);
+	if (!m) throw new Error(`bucket transform: invalid decimal type ${decimalType}`);
+	const scale = parseInt(m[2], 10);
+	const factor = 10n ** BigInt(scale);
+	const unscaled = typeof value === "bigint" ? value * factor : BigInt(Math.round(Number(value) * Number(factor)));
+	const bytes = [];
+	let v = unscaled;
+	while (true) {
+		const byte = Number(v & 255n);
+		bytes.unshift(byte);
+		v >>= 8n;
+		const sign = byte & 128;
+		if (!sign && v === 0n || sign && v === -1n) break;
+	}
+	return new Uint8Array(bytes);
+}
+function truncateTransform(value, sourceType, w) {
+	const t = typeName(sourceType);
+	if (t.startsWith("decimal(")) {
+		const m = /^decimal\((\d+),\s*(\d+)\)$/.exec(t);
+		if (!m) throw new Error(`truncate transform: invalid decimal type ${t}`);
+		const scale = parseInt(m[2], 10);
+		const factor = 10n ** BigInt(scale);
+		const unscaled = typeof value === "bigint" ? value * factor : BigInt(Math.round(Number(value) * Number(factor)));
+		const W = BigInt(w);
+		const truncated = unscaled - (unscaled % W + W) % W;
+		return Number(truncated) / Number(factor);
+	}
+	if (t === "binary") return (value instanceof Uint8Array ? value : new Uint8Array(value)).slice(0, w);
+	switch (t) {
+		case "int": {
+			const v = Number(value);
+			return v - (v % w + w) % w;
+		}
+		case "long": {
+			const W = BigInt(w);
+			const v = typeof value === "bigint" ? value : BigInt(value);
+			return v - (v % W + W) % W;
+		}
+		case "string": {
+			const s = String(value);
+			let count = 0;
+			let i = 0;
+			while (i < s.length && count < w) {
+				const code = s.codePointAt(i);
+				i += code > 65535 ? 2 : 1;
+				count++;
+			}
+			return s.slice(0, i);
+		}
+		default: throw new Error(`truncate transform: unsupported source type ${t}`);
+	}
+}
+function validateTransformSource(parsed, sourceType) {
+	const t = typeName(sourceType);
+	switch (parsed.kind) {
+		case "identity":
+			if (t === "variant" || t === "geometry" || t.startsWith("geometry(") || t === "geography" || t.startsWith("geography(")) throw new Error(`identity transform: unsupported source type ${t}`);
+			return;
+		case "void": return;
+		case "bucket":
+			if (t === "int" || t === "long" || t.startsWith("decimal(") || t === "date" || t === "time" || t === "timestamp" || t === "timestamptz" || t === "timestamp_ns" || t === "timestamptz_ns" || t === "string" || t === "uuid" || t.startsWith("fixed[") || t === "binary" || t === "fixed") return;
+			throw new Error(`bucket transform: unsupported source type ${t}`);
+		case "truncate":
+			if (t === "int" || t === "long" || t.startsWith("decimal(") || t === "string" || t === "binary") return;
+			throw new Error(`truncate transform: unsupported source type ${t}`);
+		case "year":
+		case "month":
+		case "day":
+			if (t === "date" || t === "timestamp" || t === "timestamptz" || t === "timestamp_ns" || t === "timestamptz_ns") return;
+			throw new Error(`${parsed.kind} transform: unsupported source type ${t}`);
+		case "hour":
+			if (t === "timestamp" || t === "timestamptz" || t === "timestamp_ns" || t === "timestamptz_ns") return;
+			throw new Error("hour transform: unsupported source type " + t);
+	}
+}
+function murmur3_32(data, seed) {
+	const c1 = 3432918353;
+	const c2 = 461845907;
+	const len = data.length;
+	const nBlocks = len >>> 2;
+	let h1 = seed >>> 0;
+	for (let i = 0; i < nBlocks; i++) {
+		const off = i * 4;
+		let k1 = data[off] | data[off + 1] << 8 | data[off + 2] << 16 | data[off + 3] << 24;
+		k1 = Math.imul(k1, c1);
+		k1 = k1 << 15 | k1 >>> 17;
+		k1 = Math.imul(k1, c2);
+		h1 ^= k1;
+		h1 = h1 << 13 | h1 >>> 19;
+		h1 = Math.imul(h1, 5) + 3864292196 | 0;
+	}
+	let k1 = 0;
+	const tail = nBlocks * 4;
+	switch (len & 3) {
+		case 3: k1 ^= data[tail + 2] << 16;
+		case 2: k1 ^= data[tail + 1] << 8;
+		case 1:
+			k1 ^= data[tail];
+			k1 = Math.imul(k1, c1);
+			k1 = k1 << 15 | k1 >>> 17;
+			k1 = Math.imul(k1, c2);
+			h1 ^= k1;
+	}
+	h1 ^= len;
+	h1 ^= h1 >>> 16;
+	h1 = Math.imul(h1, 2246822507);
+	h1 ^= h1 >>> 13;
+	h1 = Math.imul(h1, 3266489909);
+	h1 ^= h1 >>> 16;
+	return h1 >>> 0;
+}
+export { applyTransform, murmur3_32, parseTransform, transformResultType };

package/dist/node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/write/write.mjs

@@ -0,0 +1,247 @@
+import { loadLatestFileCatalogMetadata } from "../metadata.mjs";
+import { restCatalogCreateTable, restCatalogDropTable, restCatalogLoadTable, restCatalogUpdateTable } from "../catalog/rest.mjs";
+import { loadTable } from "../catalog/loadTable.mjs";
+import { icebergCreate } from "../create.mjs";
+import { fileCatalogCommit } from "./commit.mjs";
+import { prepareAppend, stageSnapshotForAppend, stageSnapshotForAppendBatches } from "./stage.mjs";
+import "./stage-position-delete.mjs";
+import "./stage-deletion-vector.mjs";
+import "./rewrite.mjs";
+const DEFAULT_RETRY = Object.freeze({
+	maxAttempts: 50,
+	initialMs: 50,
+	maxMs: 3e3,
+	factor: 2,
+	totalTimeoutMs: 1800 * 1e3
+});
+async function icebergAppend({ catalog, namespace, table, tableUrl, resolver, records, sortOrderId, snapshotProperties }) {
+	const ctx = await loadTable({
+		catalog,
+		namespace,
+		table,
+		tableUrl,
+		resolver
+	});
+	const prepared = await prepareAppend({
+		tableUrl: ctx.tableUrl,
+		metadata: ctx.metadata,
+		records,
+		resolver: requireResolver(ctx.resolver, "icebergAppend"),
+		sortOrderId
+	});
+	return await commitWithRetry({
+		catalog,
+		target: {
+			namespace,
+			table
+		},
+		ctx,
+		stage: (workingCtx) => stageSnapshotForAppend({
+			tableUrl: workingCtx.tableUrl,
+			metadata: workingCtx.metadata,
+			prepared,
+			resolver: requireResolver(workingCtx.resolver, "icebergAppend"),
+			snapshotProperties
+		})
+	});
+}
+async function icebergAppendBatches({ catalog, namespace, table, tableUrl, resolver, batches, sortOrderId, snapshotProperties }) {
+	const ctx = await loadTable({
+		catalog,
+		namespace,
+		table,
+		tableUrl,
+		resolver
+	});
+	const writer = requireResolver(ctx.resolver, "icebergAppendBatches");
+	const prepared = [];
+	let snapshotId;
+	for await (const records of batches) {
+		if (records.length === 0) continue;
+		const batch = await prepareAppend({
+			tableUrl: ctx.tableUrl,
+			metadata: ctx.metadata,
+			records,
+			resolver: writer,
+			sortOrderId,
+			snapshotId
+		});
+		snapshotId ??= batch.snapshotId;
+		prepared.push(batch);
+	}
+	if (prepared.length === 0) return ctx.metadata;
+	return await commitWithRetry({
+		catalog,
+		target: {
+			namespace,
+			table
+		},
+		ctx,
+		stage: (workingCtx) => stageSnapshotForAppendBatches({
+			tableUrl: workingCtx.tableUrl,
+			metadata: workingCtx.metadata,
+			prepared,
+			resolver: requireResolver(workingCtx.resolver, "icebergAppendBatches"),
+			snapshotProperties
+		})
+	});
+}
+async function icebergCreateTable({ catalog, namespace, table, tableUrl, schema, partitionSpec, sortOrder, properties, formatVersion, stageCreate }) {
+	if (catalog.type === "rest") {
+		if (!namespace || !table) throw new Error("namespace and table are required for rest catalogs");
+		if (!schema) throw new Error("schema is required for rest catalogs");
+		const { metadata } = await restCatalogCreateTable(catalog, {
+			namespace,
+			table,
+			schema,
+			location: tableUrl,
+			partitionSpec,
+			writeOrder: sortOrder,
+			stageCreate,
+			properties
+		});
+		return metadata;
+	}
+	if (!tableUrl) throw new Error("tableUrl is required for file catalogs");
+	return await icebergCreate({
+		tableUrl,
+		resolver: catalog.resolver,
+		schema,
+		formatVersion,
+		partitionSpec,
+		sortOrder,
+		properties,
+		conditionalCommits: catalog.conditionalCommits
+	});
+}
+async function icebergDropTable({ catalog, namespace, table, tableUrl, lister, purgeRequested }) {
+	if (catalog.type === "rest") {
+		if (!namespace || !table) throw new Error("namespace and table are required for rest catalogs");
+		await restCatalogDropTable(catalog, {
+			namespace,
+			table,
+			purgeRequested
+		});
+		return;
+	}
+	if (!tableUrl) throw new Error("tableUrl is required for file catalogs");
+	if (!lister) throw new Error("lister is required to drop a file catalog table");
+	const { deleter } = catalog.resolver;
+	if (!deleter) throw new Error("resolver.deleter is required to drop a file catalog table");
+	const dirs = purgeRequested ? ["metadata", "data"] : ["metadata"];
+	for (const dir of dirs) {
+		const names = await lister(`${tableUrl}/${dir}`).catch(() => []);
+		await Promise.allSettled(names.map((n) => deleter(`${tableUrl}/${dir}/${n}`)));
+	}
+}
+function requireResolver(resolver, caller) {
+	if (!resolver) throw new Error(`${caller}: resolver is required`);
+	return resolver;
+}
+async function commitStaged(catalog, target, ctx, staged) {
+	if (catalog.type === "rest") {
+		const { metadata } = await restCatalogUpdateTable(catalog, {
+			namespace: target.namespace,
+			table: target.table,
+			requirements: staged.requirements,
+			updates: staged.updates
+		});
+		return metadata;
+	}
+	if (!ctx.resolver) throw new Error("resolver is required to commit to a file catalog");
+	return await fileCatalogCommit({
+		tableUrl: ctx.tableUrl,
+		metadata: ctx.metadata,
+		metadataFileName: ctx.metadataFileName,
+		currentVersion: ctx.version,
+		staged,
+		resolver: ctx.resolver,
+		conditionalCommits: catalog.type === "file" && catalog.conditionalCommits
+	});
+}
+async function commitWithRetry({ catalog, target, ctx, stage }) {
+	const retryEnabled = catalog.type === "rest" || catalog.type === "file" && catalog.conditionalCommits === true;
+	const policy = resolveRetryPolicy(ctx.metadata);
+	const startedAt = Date.now();
+	let workingCtx = ctx;
+	for (let attempt = 1; attempt <= policy.maxAttempts; attempt++) {
+		const staged = await stage(workingCtx);
+		try {
+			return await commitStaged(catalog, target, workingCtx, staged);
+		} catch (err) {
+			if (!retryEnabled || !isCommitConflict(err)) throw err;
+			if (attempt === policy.maxAttempts) throw new Error(`${catalog.type} catalog commit failed after ${policy.maxAttempts} attempts due to concurrent commits`);
+			const elapsed = Date.now() - startedAt;
+			if (elapsed >= policy.totalTimeoutMs) throw new Error(`${catalog.type} catalog commit retry budget exhausted after ${attempt} attempts and ${elapsed}ms (limit ${policy.totalTimeoutMs}ms)`);
+			const remaining = policy.totalTimeoutMs - elapsed;
+			await sleep(Math.min(jitteredBackoff(attempt, policy), remaining));
+			workingCtx = await reloadCtx(catalog, target, workingCtx, err);
+		}
+	}
+	throw new Error("unreachable");
+}
+async function reloadCtx(catalog, target, workingCtx, lastErr) {
+	if (catalog.type === "rest") {
+		if (!target.namespace || !target.table) throw lastErr;
+		const { metadata } = await restCatalogLoadTable(catalog, {
+			namespace: target.namespace,
+			table: target.table
+		});
+		return {
+			metadata,
+			metadataFileName: workingCtx.metadataFileName,
+			version: workingCtx.version,
+			tableUrl: workingCtx.tableUrl,
+			resolver: workingCtx.resolver
+		};
+	}
+	if (!workingCtx.resolver) throw lastErr;
+	const fresh = await loadLatestFileCatalogMetadata({
+		tableUrl: workingCtx.tableUrl,
+		resolver: workingCtx.resolver,
+		lister: catalog.lister
+	});
+	return {
+		metadata: fresh.metadata,
+		metadataFileName: fresh.metadataFileName,
+		version: fresh.version,
+		tableUrl: workingCtx.tableUrl,
+		resolver: workingCtx.resolver
+	};
+}
+function resolveRetryPolicy(metadata) {
+	const props = metadata.properties ?? {};
+	const numRetries = parseTableProp(props["commit.retry.num-retries"]);
+	const maxAttempts = numRetries === void 0 ? DEFAULT_RETRY.maxAttempts : numRetries + 1;
+	const initialMs = parseTableProp(props["commit.retry.min-wait-ms"]) ?? DEFAULT_RETRY.initialMs;
+	const maxMs = parseTableProp(props["commit.retry.max-wait-ms"]) ?? DEFAULT_RETRY.maxMs;
+	const totalTimeoutMs = parseTableProp(props["commit.retry.total-timeout-ms"]) ?? DEFAULT_RETRY.totalTimeoutMs;
+	return {
+		maxAttempts,
+		initialMs,
+		maxMs,
+		factor: DEFAULT_RETRY.factor,
+		totalTimeoutMs
+	};
+}
+function parseTableProp(value) {
+	if (value === void 0 || value === null || value === "") return void 0;
+	const n = Number(value);
+	if (!Number.isFinite(n) || n < 0) return void 0;
+	return n;
+}
+function jitteredBackoff(attempt, policy) {
+	if (policy.initialMs === 0 || policy.maxMs === 0) return 0;
+	const base = Math.min(policy.maxMs, policy.initialMs * policy.factor ** (attempt - 1));
+	return Math.floor(Math.random() * base);
+}
+function sleep(ms) {
+	if (ms <= 0) return Promise.resolve();
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isCommitConflict(err) {
+	if (!err || typeof err !== "object") return false;
+	const { status } = err;
+	return status === 412 || status === 409;
+}
+export { icebergAppend, icebergAppendBatches, icebergCreateTable, icebergDropTable };

package/dist/node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/types/catalog/file.d.mts

@@ -0,0 +1 @@
+import "../../src/types.mjs";

package/dist/node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/types/catalog/rest.d.mts

@@ -0,0 +1,76 @@
+import { LoadTableResponse, RestCatalogContext, TableIdentifier } from "../../src/types.mjs";
+/**
+ * Iceberg REST Catalog client.
+ *
+ * Plain async functions over a stateless context object — no classes.
+ * The catalog client never imports from the read path; callers glue the
+ * two together by passing `metadata` and `metadata.location` from
+ * `restCatalogLoadTable` into `icebergRead`.
+ *
+ * @import {LoadTableResponse, PartitionSpec, RestCatalogContext, Schema, SortOrder, StorageCredential, TableIdentifier, TableMetadata, TableRequirement, TableUpdate} from '../../src/types.js'
+ */
+/**
+ * Connect to a REST catalog by fetching `/v1/config`.
+ * Returns a frozen context object that holds the prefix, defaults, overrides
+ * and the user-supplied requestInit (for auth) for use in subsequent calls.
+ *
+ * @param {object} options
+ * @param {string} options.url - catalog base URL, with or without trailing slash
+ * @param {string} [options.warehouse] - optional warehouse query param sent to /v1/config
+ * @param {RequestInit} [options.requestInit] - fetch options (e.g. Authorization header)
+ * @param {(url: string, init?: RequestInit) => Promise<RequestInit>} [options.signRequest] - per-request auth hook
+ * @returns {Promise<RestCatalogContext>}
+ */
+declare function restCatalogConnect({ url, warehouse, requestInit, signRequest }: {
+  url: string;
+  warehouse?: string;
+  requestInit?: RequestInit;
+  signRequest?: (url: string, init?: RequestInit) => Promise<RequestInit>;
+}): Promise<RestCatalogContext>;
+/**
+ * List tables within a namespace.
+ * Follows pagination (`next-page-token`) until exhausted.
+ *
+ * @param {RestCatalogContext} ctx
+ * @param {object} options
+ * @param {string | string[]} options.namespace
+ * @returns {Promise<TableIdentifier[]>}
+ */
+declare function restCatalogListTables(ctx: RestCatalogContext, { namespace }: {
+  namespace: string | string[];
+}): Promise<TableIdentifier[]>;
+/**
+ * Load a single table. Returns the inline TableMetadata, the metadata
+ * file location, and any per-table config the server returned.
+ *
+ * The returned `metadata` and `metadata.location` can be passed directly
+ * into `icebergRead({ tableUrl: metadata.location, metadata })`.
+ *
+ * @param {RestCatalogContext} ctx
+ * @param {object} options
+ * @param {string | string[]} options.namespace
+ * @param {string} options.table
+ * @returns {Promise<LoadTableResponse>}
+ */
+declare function restCatalogLoadTable(ctx: RestCatalogContext, { namespace, table }: {
+  namespace: string | string[];
+  table: string;
+}): Promise<LoadTableResponse>;
+/**
+ * Create a namespace. Returns the namespace as the server stored it (which may
+ * include defaulted properties).
+ *
+ * @param {RestCatalogContext} ctx
+ * @param {object} options
+ * @param {string | string[]} options.namespace
+ * @param {Record<string, string>} [options.properties]
+ * @returns {Promise<{namespace: string[], properties: Record<string, string>}>}
+ */
+declare function restCatalogCreateNamespace(ctx: RestCatalogContext, { namespace, properties }: {
+  namespace: string | string[];
+  properties?: Record<string, string>;
+}): Promise<{
+  namespace: string[];
+  properties: Record<string, string>;
+}>;
+export { restCatalogConnect, restCatalogCreateNamespace, restCatalogListTables, restCatalogLoadTable };

package/dist/node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/types/create.d.mts

@@ -0,0 +1 @@
+import "../src/types.mjs";

package/dist/node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/types/fetch.d.mts

@@ -0,0 +1,36 @@
+import { Resolver } from "../src/types.mjs";
+/**
+ * Wrap a `Resolver` so reads of the same path share one HTTP fetch and
+ * subsequent range reads share one in-memory buffer. Writes and deletes
+ * through the same resolver invalidate the cache entry for their path on
+ * success, so a commit pipeline (`icebergAppend` → reload metadata) sees the
+ * new bytes without manual invalidation.
+ *
+ * - `reader(path)` is memoized by path. The returned buffer is passed through
+ *   `cachedAsyncBuffer` so range reads within a single file are also deduped.
+ *   `byteLength` is a fetch hint and not part of the cache key — the bytes
+ *   are the same either way.
+ * - `writer(path).finish()` invalidates the cache entry only when the
+ *   underlying finish resolves; a rejected finish (e.g. an `If-None-Match: *`
+ *   collision returning 412/409) leaves the cached bytes intact, since the
+ *   server-side object hasn't changed.
+ * - `deleter(path)` invalidates the cache entry on success.
+ * - `writer` and `deleter` are omitted when the base resolver omits them, so
+ *   wrapping a read-only resolver still yields a read-only resolver.
+ *
+ * Iceberg writes are almost entirely create-new-path (data parquets, manifest
+ * avros, snapshot avros, vN.metadata.json all live at fresh paths per
+ * commit). Only `version-hint.text` and equivalent catalog-pointer files are
+ * truly mutated in place, so path-level invalidation is sufficient to keep
+ * single-process write-then-read pipelines consistent.
+ *
+ * Cross-process freshness is out of scope: a reader in process B does not
+ * see writes committed by process A through a different cache. Use a
+ * short-lived resolver, an external coordination layer, or wrap with TTL /
+ * conditional-GET revalidation if you need that.
+ *
+ * @param {Resolver} base
+ * @returns {Resolver}
+ */
+declare function cachingResolver(base: Resolver): Resolver;
+export { cachingResolver };

package/dist/node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/types/index.d.mts

@@ -0,0 +1,13 @@
+import { icebergAppend, icebergCreateTable, icebergDropTable } from "./write/write.mjs";
+import "./create.mjs";
+import "./catalog/file.mjs";
+import { restCatalogConnect, restCatalogCreateNamespace, restCatalogListTables, restCatalogLoadTable } from "./catalog/rest.mjs";
+import { cachingResolver } from "./fetch.mjs";
+import { s3SignedResolver } from "./s3.mjs";
+import "./read.mjs";
+import "./metadata.mjs";
+import { icebergManifests } from "./manifest.mjs";
+import "../../../../squirreling@0.15.0/node_modules/squirreling/src/index.mjs";
+import "./sql/icebergDataSource.mjs";
+import "./sql/icebergQuery.mjs";
+export { cachingResolver, icebergAppend, icebergCreateTable, icebergDropTable, icebergManifests, restCatalogConnect, restCatalogCreateNamespace, restCatalogListTables, restCatalogLoadTable, s3SignedResolver };

package/dist/node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/types/manifest.d.mts

@@ -0,0 +1,30 @@
+import { Manifest, ManifestEntry, Resolver, TableMetadata } from "../src/types.mjs";
+type ManifestList = {
+  url: string;
+  entries: ManifestEntry[];
+}[];
+/**
+ * Predicate applied to each manifest's manifest-list `partitions` field-summary
+ * array before entry fetch. Return `false` to skip the manifest's entry fetch.
+ */
+type ManifestPartitionFilter = (partitions: Manifest['partitions'], partitionSpecId: number, manifest: Manifest) => boolean;
+/**
+ * Returns manifest entries for a snapshot. Defaults to the current snapshot;
+ * pass `snapshotId` to time-travel to a prior snapshot in the metadata's
+ * snapshot log.
+ *
+ * @import {Resolver, TableMetadata, Manifest, ManifestEntry} from '../src/types.js'
+ * @typedef {{ url: string, entries: ManifestEntry[] }[]} ManifestList
+ * @param {object} options
+ * @param {TableMetadata} options.metadata
+ * @param {Resolver} [options.resolver]
+ * @param {number | bigint} [options.snapshotId] - Optional snapshot id; defaults to `current-snapshot-id`.
+ * @returns {Promise<ManifestList>}
+ */
+declare function icebergManifests({ metadata, resolver, snapshotId, partitionFilter }: {
+  metadata: TableMetadata;
+  resolver?: Resolver;
+  snapshotId?: number | bigint;
+  partitionFilter?: ManifestPartitionFilter;
+}): Promise<ManifestList>;
+export { ManifestList, ManifestPartitionFilter, icebergManifests };

package/dist/node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/types/metadata.d.mts

@@ -0,0 +1 @@
+import "../src/types.mjs";

package/dist/node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/types/read.d.mts

@@ -0,0 +1,2 @@
+import "../../../../hyparquet@1.26.2/node_modules/hyparquet/types/node.mjs";
+import "../src/types.mjs";

package/dist/node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/types/s3.d.mts

@@ -0,0 +1,36 @@
+import { Resolver } from "../src/types.mjs";
+/**
+ * @import {Resolver} from '../src/types.js'
+ */
+/**
+ * Build a SigV4-signing `Resolver` for private S3-compatible buckets (AWS S3,
+ * Cloudflare R2, MinIO, etc.). Signs every request with AWS Signature V4
+ * using static credentials. Works in browsers and Node via the Web Crypto API.
+ *
+ * Credentials are taken as inputs; profile/STS/IMDS chains are out of scope.
+ * For Iceberg REST catalogs that vend per-table credentials (R2, AWS Glue),
+ * pass the `s3.*` keys from `restCatalogLoadCredentials` or `LoadTable.config`.
+ *
+ * Accepts paths as `s3://bucket/key`, `s3a://bucket/key`, or full https URLs.
+ *
+ * @param {object} options
+ * @param {string} options.accessKeyId
+ * @param {string} options.secretAccessKey
+ * @param {string} [options.sessionToken] - For temporary credentials (STS/vended).
+ * @param {string} options.region - e.g. 'us-east-1', or 'auto' for R2.
+ * @param {string} [options.endpoint] - HTTPS endpoint root for non-AWS providers
+ *   (e.g. `https://<account>.r2.cloudflarestorage.com`). Defaults to AWS S3.
+ * @param {boolean} [options.pathStyle] - When true, URLs are
+ *   `<endpoint>/<bucket>/<key>`; when false (default), virtual-hosted-style
+ *   `<bucket>.<endpoint-host>/<key>`. R2 requires true.
+ * @returns {Resolver}
+ */
+declare function s3SignedResolver({ accessKeyId, secretAccessKey, sessionToken, region, endpoint, pathStyle }: {
+  accessKeyId: string;
+  secretAccessKey: string;
+  sessionToken?: string;
+  region: string;
+  endpoint?: string;
+  pathStyle?: boolean;
+}): Resolver;
+export { s3SignedResolver };

package/dist/node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/types/sql/icebergDataSource.d.mts

@@ -0,0 +1,2 @@
+import "../../src/types.mjs";
+import "../../../../../squirreling@0.15.0/node_modules/squirreling/src/index.mjs";