@gscdump/lakehouse 1.4.0 → 1.4.2

package/dist/_virtual/node_modules/.pnpm/icebird@0.8.15_patch_hash=d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/fetch.mjs

@@ -0,0 +1,261 @@
+import { parquetMetadataAsync } from "../../../../hyparquet@1.26.2/node_modules/hyparquet/src/metadata.mjs";
+import { asyncBufferFromUrl, cachedAsyncBuffer } from "../../../../hyparquet@1.26.2/node_modules/hyparquet/src/utils.mjs";
+import { parquetReadObjects } from "../../../../hyparquet@1.26.2/node_modules/hyparquet/src/read.mjs";
+import "../../../../hyparquet@1.26.2/node_modules/hyparquet/src/node.mjs";
+import { compressors } from "../../../../hyparquet-compressors@1.1.1/node_modules/hyparquet-compressors/src/compressors.mjs";
+import "../../../../hyparquet-compressors@1.1.1/node_modules/hyparquet-compressors/src/index.mjs";
+import { ByteWriter } from "../../../../hyparquet-writer@0.16.1_patch_hash=7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/src/bytewriter.mjs";
+import "../../../../hyparquet-writer@0.16.1_patch_hash=7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/src/node.mjs";
+import { avroMetadata } from "./avro/avro.metadata.mjs";
+import { avroRead } from "./avro/avro.read.mjs";
+import { puffinReadDeletionVector } from "./puffin/puffin.mjs";
+import { sanitize } from "./utils.mjs";
+function translateS3Url(url) {
+	if (url.startsWith("s3a://") || url.startsWith("s3://")) {
+		const rest = url.slice(url.indexOf("://") + 3);
+		const slashIndex = rest.indexOf("/");
+		if (slashIndex === -1) throw new Error("Invalid S3 URL, missing \"/\" after bucket");
+		return `https://${rest.slice(0, slashIndex)}.s3.amazonaws.com${rest.slice(slashIndex)}`;
+	}
+	return url;
+}
+function urlResolver({ requestInit } = {}) {
+	return {
+		reader(url, byteLength) {
+			return asyncBufferFromUrl({
+				url: translateS3Url(url),
+				byteLength,
+				requestInit
+			});
+		},
+		writer(url, options) {
+			const w = new ByteWriter();
+			w.finish = async function() {
+				const target = translateS3Url(url);
+				const body = w.getBytes().slice();
+				const headers = {};
+				if (requestInit?.headers) new Headers(requestInit.headers).forEach((v, k) => {
+					headers[k] = v;
+				});
+				if (options?.ifNoneMatch) headers["If-None-Match"] = options.ifNoneMatch;
+				const res = await fetch(target, {
+					...requestInit,
+					method: "PUT",
+					headers,
+					body
+				});
+				if (!res.ok) {
+					const err = /* @__PURE__ */ new Error(`PUT ${url}: ${res.status} ${res.statusText}`);
+					err.status = res.status;
+					throw err;
+				}
+			};
+			return w;
+		},
+		async deleter(url) {
+			const res = await fetch(translateS3Url(url), {
+				...requestInit,
+				method: "DELETE"
+			});
+			if (!res.ok && res.status !== 404) throw new Error(`DELETE ${url}: ${res.status} ${res.statusText}`);
+		}
+	};
+}
+function cachingResolver(base) {
+	const cache = /* @__PURE__ */ new Map();
+	const out = { reader(path, byteLength) {
+		let buf = cache.get(path);
+		if (!buf) {
+			buf = (async () => cachedAsyncBuffer(await base.reader(path, byteLength)))();
+			cache.set(path, buf);
+			buf.catch(() => {
+				if (cache.get(path) === buf) cache.delete(path);
+			});
+		}
+		return buf;
+	} };
+	if (base.writer) {
+		const baseWriter = base.writer;
+		out.writer = (path, options) => {
+			const w = baseWriter(path, options);
+			const origFinish = w.finish.bind(w);
+			w.finish = async function() {
+				await origFinish();
+				cache.delete(path);
+			};
+			return w;
+		};
+	}
+	if (base.deleter) {
+		const baseDeleter = base.deleter;
+		out.deleter = async (path) => {
+			await baseDeleter(path);
+			cache.delete(path);
+		};
+	}
+	return out;
+}
+function s3Lister({ requestInit } = {}) {
+	return async function list(url) {
+		const s3parts = s3ParseUrl(url);
+		if (!s3parts) throw new Error(`not an S3 URL: ${url}`);
+		const { bucket, prefix } = s3parts;
+		const listUrl = `https://${bucket}.s3.amazonaws.com/?list-type=2&prefix=${prefix.replace(/\/$/, "")}/&delimiter=/`;
+		const res = await fetch(listUrl, requestInit);
+		if (!res.ok) throw new Error(`${res.status} ${res.statusText}`);
+		return ((await res.text()).match(/<Contents>(.*?)<\/Contents>/gs) || []).map((match) => {
+			const keyMatch = match.match(/<Key>(.*?)<\/Key>/);
+			if (!keyMatch) throw new Error("failed to parse S3 list response");
+			return keyMatch[1].split("/").pop() ?? "";
+		}).filter(Boolean);
+	};
+}
+function s3ParseUrl(url) {
+	if (url.startsWith("s3://") || url.startsWith("s3a://")) {
+		const parts = url.split("/");
+		return {
+			bucket: parts[2],
+			prefix: parts.slice(3).join("/")
+		};
+	}
+	if (url.startsWith("https://s3.amazonaws.com/")) {
+		const parts = url.split("/");
+		return {
+			bucket: parts[3],
+			prefix: parts.slice(4).join("/")
+		};
+	}
+	const m = url.match(/^https:\/\/([a-z0-9][a-z0-9-]*)\.s3(?:[.-][a-z0-9-]+)?\.amazonaws\.com\/(.*)$/);
+	if (m) return {
+		bucket: m[1],
+		prefix: m[2]
+	};
+}
+async function fetchDeleteMaps(deleteEntries, resolver) {
+	const positionDeletesMap = /* @__PURE__ */ new Map();
+	const equalityDeleteGroups = [];
+	await Promise.all(deleteEntries.map(async (deleteEntry) => {
+		const { content, file_path, file_size_in_bytes } = deleteEntry.data_file;
+		const file = cachedAsyncBuffer(await resolver.reader(file_path, Number(file_size_in_bytes)));
+		if (content === 1) if (isDeletionVector(deleteEntry)) {
+			const { referenced_data_file, content_offset, content_size_in_bytes } = deleteEntry.data_file;
+			if (!referenced_data_file) throw new Error("deletion vector missing referenced_data_file");
+			if (content_offset == null) throw new Error("deletion vector missing content_offset");
+			if (content_size_in_bytes == null) throw new Error("deletion vector missing content_size_in_bytes");
+			const positions = await puffinReadDeletionVector(file, {
+				offset: content_offset,
+				length: content_size_in_bytes,
+				referencedDataFile: referenced_data_file
+			});
+			const set = /* @__PURE__ */ new Set();
+			for (const pos of positions) set.add(pos);
+			addPositionDeleteGroup(positionDeletesMap, referenced_data_file, deleteEntry, set);
+		} else {
+			const deleteRows = await parquetReadObjects({
+				file,
+				compressors
+			});
+			const positionsByPath = /* @__PURE__ */ new Map();
+			for (const deleteRow of deleteRows) {
+				const { file_path, pos } = deleteRow;
+				if (!file_path) throw new Error("position delete missing target file path");
+				if (pos === void 0) throw new Error("position delete missing pos");
+				let set = positionsByPath.get(file_path);
+				if (!set) {
+					set = /* @__PURE__ */ new Set();
+					positionsByPath.set(file_path, set);
+				}
+				set.add(pos);
+			}
+			for (const [targetPath, positions] of positionsByPath) addPositionDeleteGroup(positionDeletesMap, targetPath, deleteEntry, positions);
+		}
+		else if (content === 2) {
+			const { sequence_number } = deleteEntry;
+			const equalityIds = deleteEntry.data_file.equality_ids;
+			if (sequence_number === void 0) throw new Error("equality delete missing sequence number");
+			if (!equalityIds?.length) throw new Error("equality delete missing equality_ids");
+			const metadata = await parquetMetadataAsync(file);
+			const columnNamesById = equalityColumnNamesById(metadata, equalityIds);
+			const deleteRows = await parquetReadObjects({
+				file,
+				metadata,
+				columns: equalityIds.map((id) => columnNamesById[id]),
+				compressors
+			});
+			const rows = [];
+			for (const deleteRow of deleteRows) rows.push(equalityPredicate(deleteRow, equalityIds, columnNamesById));
+			equalityDeleteGroups.push({
+				deleteEntry,
+				rows
+			});
+		}
+	}));
+	return {
+		positionDeletesMap,
+		equalityDeleteGroups
+	};
+}
+function addPositionDeleteGroup(positionDeletesMap, targetPath, deleteEntry, positions) {
+	let groups = positionDeletesMap.get(targetPath);
+	if (!groups) {
+		groups = [];
+		positionDeletesMap.set(targetPath, groups);
+	}
+	groups.push({
+		deleteEntry,
+		positions
+	});
+}
+function isDeletionVector(deleteEntry) {
+	const dataFile = deleteEntry.data_file;
+	return dataFile.file_format.toLowerCase() === "puffin" || dataFile.content_offset != null || dataFile.content_size_in_bytes != null;
+}
+function equalityColumnNamesById(parquetMetadata, equalityIds) {
+	const kv = parquetMetadata.key_value_metadata?.find((k) => k.key === "iceberg.schema");
+	if (!kv?.value) throw new Error("equality delete missing iceberg.schema parquet metadata");
+	const schema = JSON.parse(kv.value);
+	const out = {};
+	for (const id of equalityIds) {
+		const field = schema.fields.find((f) => f.id === id);
+		if (!field) throw new Error(`equality delete missing field id ${id} in parquet schema`);
+		out[id] = sanitize(field.name);
+	}
+	return out;
+}
+function equalityPredicate(deleteRow, equalityIds, columnNamesById) {
+	const out = {};
+	for (const id of equalityIds) out[id] = deleteRow[columnNamesById[id]];
+	return out;
+}
+async function resolveText(resolver, path) {
+	const ab = await resolver.reader(path);
+	let buf = await ab.slice(0, ab.byteLength);
+	if (isGzip(buf)) buf = await decompressGzip(buf);
+	return new TextDecoder().decode(buf);
+}
+function isGzip(buf) {
+	if (buf.byteLength < 2) return false;
+	const view = new Uint8Array(buf, 0, 2);
+	return view[0] === 31 && view[1] === 139;
+}
+async function decompressGzip(buf) {
+	if (!globalThis.DecompressionStream) throw new Error("gzip decompression is not supported in this environment");
+	const stream = new Blob([buf]).stream().pipeThrough(new DecompressionStream("gzip"));
+	return await new Response(stream).arrayBuffer();
+}
+async function fetchAvroRecords(url, resolver, byteLength) {
+	const lengthHint = byteLength !== void 0 && Number.isFinite(byteLength) ? byteLength : void 0;
+	const ab = await resolver.reader(url, lengthHint);
+	const buffer = await ab.slice(0, ab.byteLength);
+	const reader = {
+		view: new DataView(buffer),
+		offset: 0
+	};
+	const { metadata, syncMarker } = await avroMetadata(reader);
+	return await avroRead({
+		reader,
+		metadata,
+		syncMarker
+	});
+}
+export { cachingResolver, fetchAvroRecords, fetchDeleteMaps, resolveText, s3Lister, s3ParseUrl, translateS3Url, urlResolver };

package/dist/_virtual/node_modules/.pnpm/icebird@0.8.15_patch_hash=d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/index.mjs

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

package/dist/_virtual/node_modules/.pnpm/icebird@0.8.15_patch_hash=d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/json.mjs

@@ -0,0 +1,147 @@
+const MAX_SAFE = BigInt(Number.MAX_SAFE_INTEGER);
+function parseIcebergJson(text) {
+	let i = 0;
+	function skipWs() {
+		while (i < text.length) {
+			const c = text.charCodeAt(i);
+			if (c !== 32 && c !== 9 && c !== 10 && c !== 13) break;
+			i++;
+		}
+	}
+	function parseString() {
+		if (text[i] !== "\"") throw new Error(`expected " at ${i}`);
+		i++;
+		let s = "";
+		while (i < text.length) {
+			const c = text[i++];
+			if (c === "\"") return s;
+			if (c !== "\\") {
+				s += c;
+				continue;
+			}
+			const e = text[i++];
+			if (e === "u") {
+				s += String.fromCharCode(parseInt(text.slice(i, i + 4), 16));
+				i += 4;
+			} else if (e === "n") s += "\n";
+			else if (e === "t") s += "	";
+			else if (e === "r") s += "\r";
+			else if (e === "b") s += "\b";
+			else if (e === "f") s += "\f";
+			else s += e;
+		}
+		throw new Error("unterminated string");
+	}
+	function parseNumber() {
+		const start = i;
+		if (text[i] === "-") i++;
+		while (text[i] >= "0" && text[i] <= "9") i++;
+		const intEnd = i;
+		let isFloat = false;
+		if (text[i] === ".") {
+			isFloat = true;
+			i++;
+			while (text[i] >= "0" && text[i] <= "9") i++;
+		}
+		if (text[i] === "e" || text[i] === "E") {
+			isFloat = true;
+			i++;
+			if (text[i] === "+" || text[i] === "-") i++;
+			while (text[i] >= "0" && text[i] <= "9") i++;
+		}
+		if (isFloat) return Number(text.slice(start, i));
+		const intStr = text.slice(start, intEnd);
+		if (intStr.length >= 16) {
+			const n = BigInt(intStr);
+			if (n > MAX_SAFE || n < -MAX_SAFE) return n;
+		}
+		return Number(intStr);
+	}
+	function parseLiteral(lit, val) {
+		if (text.slice(i, i + lit.length) !== lit) throw new Error(`bad literal at ${i}`);
+		i += lit.length;
+		return val;
+	}
+	function parseValue() {
+		skipWs();
+		const ch = text[i];
+		if (ch === "\"") return parseString();
+		if (ch === "{") return parseObject();
+		if (ch === "[") return parseArray();
+		if (ch === "t") return parseLiteral("true", true);
+		if (ch === "f") return parseLiteral("false", false);
+		if (ch === "n") return parseLiteral("null", null);
+		return parseNumber();
+	}
+	function parseObject() {
+		i++;
+		skipWs();
+		const obj = {};
+		if (text[i] === "}") {
+			i++;
+			return obj;
+		}
+		while (true) {
+			skipWs();
+			const key = parseString();
+			skipWs();
+			if (text[i] !== ":") throw new Error(`expected : at ${i}`);
+			i++;
+			obj[key] = parseValue();
+			skipWs();
+			if (text[i] === ",") {
+				i++;
+				continue;
+			}
+			if (text[i] === "}") {
+				i++;
+				return obj;
+			}
+			throw new Error(`expected , or } at ${i}`);
+		}
+	}
+	function parseArray() {
+		i++;
+		skipWs();
+		const arr = [];
+		if (text[i] === "]") {
+			i++;
+			return arr;
+		}
+		while (true) {
+			arr.push(parseValue());
+			skipWs();
+			if (text[i] === ",") {
+				i++;
+				continue;
+			}
+			if (text[i] === "]") {
+				i++;
+				return arr;
+			}
+			throw new Error(`expected , or ] at ${i}`);
+		}
+	}
+	const value = parseValue();
+	skipWs();
+	if (i !== text.length) throw new Error(`unexpected trailing input at ${i}`);
+	return value;
+}
+function stringifyIcebergJson(value, indent = 2) {
+	const pad = " ".repeat(indent);
+	function serialize(val, depth) {
+		if (typeof val === "bigint") return val.toString();
+		if (val === null || typeof val !== "object") return JSON.stringify(val);
+		const inner = pad.repeat(depth + 1);
+		const outer = pad.repeat(depth);
+		if (Array.isArray(val)) {
+			if (val.length === 0) return "[]";
+			return `[\n${val.map((v) => inner + serialize(v === void 0 ? null : v, depth + 1)).join(",\n")}\n${outer}]`;
+		}
+		const keys = Object.keys(val).filter((k) => val[k] !== void 0);
+		if (keys.length === 0) return "{}";
+		return `{\n${keys.map((k) => `${inner}${JSON.stringify(k)}: ${serialize(val[k], depth + 1)}`).join(",\n")}\n${outer}}`;
+	}
+	return serialize(value, 0);
+}
+export { parseIcebergJson, stringifyIcebergJson };

package/dist/_virtual/node_modules/.pnpm/icebird@0.8.15_patch_hash=d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/manifest.mjs

@@ -0,0 +1,84 @@
+import { fetchAvroRecords, urlResolver } from "./fetch.mjs";
+async function icebergManifests({ metadata, resolver, snapshotId, partitionFilter }) {
+	resolver ??= urlResolver();
+	const rawTarget = snapshotId ?? metadata["current-snapshot-id"];
+	if (rawTarget == null || rawTarget < 0) throw new Error("No current snapshot id found in table metadata");
+	const targetId = BigInt(rawTarget);
+	const snapshot = metadata.snapshots?.find((s) => BigInt(s["snapshot-id"]) === targetId);
+	if (!snapshot) throw new Error(`Snapshot ${rawTarget} not found in metadata`);
+	let manifests = [];
+	if (snapshot["manifest-list"]) {
+		const manifestListUrl = snapshot["manifest-list"];
+		manifests = await fetchAvroRecords(manifestListUrl, resolver);
+	} else if (snapshot.manifests) manifests = snapshot.manifests;
+	else throw new Error("No manifest information found in snapshot");
+	if (partitionFilter) manifests = manifests.filter((manifest) => {
+		let keep = true;
+		try {
+			keep = partitionFilter(manifest.partitions, manifest.partition_spec_id ?? 0, manifest) !== false;
+		} catch {
+			keep = true;
+		}
+		return keep;
+	});
+	return await fetchManifests(manifests, resolver);
+}
+const MANIFEST_FETCH_CONCURRENCY = 8;
+async function fetchOneManifest(manifest, resolver) {
+	const url = manifest.manifest_path;
+	const entries = await fetchAvroRecords(url, resolver, Number(manifest.manifest_length));
+	for (const entry of entries) {
+		entry.partition_spec_id = manifest.partition_spec_id ?? 0;
+		if (entry.sequence_number === void 0) entry.sequence_number = manifest.sequence_number ?? 0n;
+		if (entry.status === 1) {
+			if (entry.sequence_number === void 0) entry.sequence_number = manifest.sequence_number;
+			if (entry.file_sequence_number === void 0) entry.file_sequence_number = manifest.sequence_number;
+		} else if (entry.sequence_number === void 0 || entry.file_sequence_number === void 0) throw new Error("iceberg manifest entry missing sequence number");
+	}
+	assignFirstRowIds(manifest, entries);
+	return {
+		url,
+		entries
+	};
+}
+async function fetchManifests(manifests, resolver) {
+	const results = new Array(manifests.length);
+	let next = 0;
+	async function worker() {
+		while (next < manifests.length) {
+			const i = next++;
+			results[i] = await fetchOneManifest(manifests[i], resolver);
+		}
+	}
+	const poolSize = Math.min(MANIFEST_FETCH_CONCURRENCY, manifests.length);
+	const workers = [];
+	for (let w = 0; w < poolSize; w++) workers.push(worker());
+	await Promise.all(workers);
+	return results;
+}
+function assignFirstRowIds(manifest, entries) {
+	if (manifest.content !== 0 || manifest.first_row_id == null) return;
+	let nextFirstRowId = BigInt(manifest.first_row_id);
+	for (const entry of entries) {
+		const dataFile = entry.data_file;
+		if (dataFile.content !== 0) continue;
+		if (dataFile.first_row_id == null) {
+			dataFile.first_row_id = nextFirstRowId;
+			nextFirstRowId += BigInt(dataFile.record_count);
+		}
+	}
+}
+function splitManifestEntries(manifests) {
+	const dataEntries = [];
+	const deleteEntries = [];
+	for (const { entries } of manifests) for (const entry of entries) {
+		if (entry.status === 2) continue;
+		if (entry.data_file.content) deleteEntries.push(entry);
+		else dataEntries.push(entry);
+	}
+	return {
+		dataEntries,
+		deleteEntries
+	};
+}
+export { icebergManifests, splitManifestEntries };

package/dist/_virtual/node_modules/.pnpm/icebird@0.8.15_patch_hash=d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/metadata.mjs

@@ -0,0 +1,159 @@
+import { parseIcebergJson } from "./json.mjs";
+import { resolveText, s3Lister, urlResolver } from "./fetch.mjs";
+function metadataFileVersionNumber(file) {
+	const match = file.match(/^(?:v(\d+)|(\d+)-.+)(?:\.metadata\.json|\.gz\.metadata\.json|\.metadata\.json\.gz)$/);
+	if (!match) return void 0;
+	return Number(match[1] ?? match[2]);
+}
+function metadataFileVersionName(file) {
+	if (metadataFileVersionNumber(file) === void 0) return void 0;
+	return file.replace(/(?:\.metadata\.json\.gz|\.gz\.metadata\.json|\.metadata\.json)$/, "");
+}
+function metadataVersions(files) {
+	const versions = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		const version = metadataFileVersionNumber(file);
+		const name = metadataFileVersionName(file);
+		if (version === void 0 || name === void 0) continue;
+		const current = versions.get(version);
+		const paddedVersion = String(version).padStart(5, "0");
+		if (current === void 0 || metadataFilePreference(file, paddedVersion) < metadataFilePreference(`${current}.metadata.json`, paddedVersion)) versions.set(version, name);
+	}
+	return [...versions.entries()].sort(([a], [b]) => a - b).map(([, name]) => name);
+}
+function icebergLatestVersion({ tableUrl, resolver, lister }) {
+	resolver ??= urlResolver();
+	lister ??= s3Lister();
+	const url = `${tableUrl}/metadata/version-hint.text`;
+	return resolveText(resolver, url).then((text) => {
+		const version = parseInt(text);
+		if (isNaN(version)) throw new Error(`invalid version: ${text}`);
+		return `v${version}`;
+	}).catch(() => {
+		const metadataDir = `${tableUrl}/metadata`;
+		return lister(metadataDir).then((files) => {
+			const versions = metadataVersions(files);
+			if (versions.length === 0) throw new Error("no metadata files found");
+			return versions[versions.length - 1];
+		});
+	}).catch((err) => {
+		throw new Error(`failed to determine latest iceberg version of ${tableUrl}: ${err.message}`);
+	});
+}
+async function icebergMetadata({ tableUrl, metadataFileName, resolver, lister }) {
+	return (await resolveMetadata({
+		tableUrl,
+		metadataFileName,
+		resolver,
+		lister
+	})).metadata;
+}
+async function resolveMetadata({ tableUrl, metadataFileName, resolver, lister }) {
+	resolver ??= urlResolver();
+	lister ??= s3Lister();
+	if (!metadataFileName) metadataFileName = `${await icebergLatestVersion({
+		tableUrl,
+		resolver,
+		lister
+	})}.metadata.json`;
+	const url = `${tableUrl}/metadata/${metadataFileName}`;
+	try {
+		return {
+			metadata: parseIcebergJson(await resolveText(resolver, url)),
+			metadataFileName
+		};
+	} catch (err) {
+		try {
+			const metadataDir = `${tableUrl}/metadata`;
+			const match = findMetadataFile(await lister(metadataDir), metadataFileName);
+			if (match) return {
+				metadata: parseIcebergJson(await resolveText(resolver, `${metadataDir}/${match}`)),
+				metadataFileName: match
+			};
+		} catch {}
+		throw new Error(`failed to get iceberg metadata: ${err.message}`);
+	}
+}
+function findMetadataFile(files, metadataFileName) {
+	if (files.includes(metadataFileName)) return metadataFileName;
+	const version = metadataFileVersionNumber(metadataFileName);
+	if (version === void 0) return void 0;
+	const versionNum = String(version).padStart(5, "0");
+	return files.filter((f) => metadataFileVersionNumber(f) === version).sort((a, b) => metadataFilePreference(a, versionNum) - metadataFilePreference(b, versionNum))[0];
+}
+async function loadLatestFileCatalogMetadata({ tableUrl, resolver, lister, maxProbe = 64 }) {
+	resolver ??= urlResolver();
+	lister ??= s3Lister();
+	let files;
+	try {
+		files = await lister(`${tableUrl}/metadata`);
+	} catch (err) {
+		const fallback = await hintProbeFallback(resolver, tableUrl, maxProbe);
+		if (fallback) return fallback;
+		throw err;
+	}
+	let highest = -1;
+	let highestFile;
+	for (const file of files) {
+		const v = metadataFileVersionNumber(file);
+		if (v === void 0) continue;
+		if (v > highest) {
+			highest = v;
+			highestFile = file;
+		}
+	}
+	if (highest < 0 || !highestFile) throw new Error(`no metadata files found at ${tableUrl}/metadata`);
+	const metadataLocation = `${tableUrl}/metadata/${highestFile}`;
+	const text = await resolveText(resolver, metadataLocation);
+	return {
+		version: highest,
+		metadata: parseIcebergJson(text),
+		metadataFileName: highestFile,
+		metadataLocation
+	};
+}
+async function hintProbeFallback(resolver, tableUrl, maxProbe) {
+	let hintVersion;
+	try {
+		const text = await resolveText(resolver, `${tableUrl}/metadata/version-hint.text`);
+		const parsed = parseInt(text);
+		if (!isNaN(parsed)) hintVersion = parsed;
+	} catch {}
+	if (hintVersion === void 0 || hintVersion < 0) return void 0;
+	let lastFound = await tryReadVersion(resolver, tableUrl, hintVersion);
+	if (!lastFound) return void 0;
+	let probe = hintVersion + 1;
+	const limit = hintVersion + maxProbe;
+	while (probe <= limit) {
+		const next = await tryReadVersion(resolver, tableUrl, probe);
+		if (!next) break;
+		lastFound = next;
+		probe++;
+	}
+	if (probe > limit) return void 0;
+	return lastFound;
+}
+async function tryReadVersion(resolver, tableUrl, version) {
+	const fileName = `v${version}.metadata.json`;
+	const metadataLocation = `${tableUrl}/metadata/${fileName}`;
+	try {
+		return {
+			version,
+			metadata: parseIcebergJson(await resolveText(resolver, metadataLocation)),
+			metadataFileName: fileName,
+			metadataLocation
+		};
+	} catch {
+		return;
+	}
+}
+function metadataFilePreference(file, paddedVersion) {
+	if (file === `v${Number(paddedVersion)}.metadata.json`) return 0;
+	if (file === `v${Number(paddedVersion)}.gz.metadata.json`) return 1;
+	if (file === `v${Number(paddedVersion)}.metadata.json.gz`) return 2;
+	if (file.startsWith(`${paddedVersion}-`) && file.endsWith(".metadata.json")) return 3;
+	if (file.startsWith(`${paddedVersion}-`) && file.endsWith(".gz.metadata.json")) return 4;
+	if (file.startsWith(`${paddedVersion}-`) && file.endsWith(".metadata.json.gz")) return 5;
+	return 6;
+}
+export { icebergLatestVersion, icebergMetadata, loadLatestFileCatalogMetadata, resolveMetadata };

package/dist/_virtual/node_modules/.pnpm/icebird@0.8.15_patch_hash=d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/prune.mjs

@@ -0,0 +1,4 @@
+import "./schema.mjs";
+import "./write/transform.mjs";
+import "./write/serde.mjs";
+export {};