@gscdump/engine 0.27.2 → 0.28.1

package/dist/_chunks/libs/icebird.mjs

@@ -0,0 +1,3708 @@
+import { gunzip } from "./hyparquet-compressors.mjs";
+import { asyncBufferFromUrl, cachedAsyncBuffer } from "hyparquet";
+import { ByteWriter, parquetWrite } from "hyparquet-writer";
+import { parseDecimal } from "hyparquet/src/convert.js";
+function readZigZag(reader) {
+	let result = 0;
+	let shift = 0;
+	while (true) {
+		const byte = reader.view.getUint8(reader.offset++);
+		result |= (byte & 127) << shift;
+		if (!(byte & 128)) return result >>> 1 ^ -(result & 1);
+		shift += 7;
+	}
+}
+function readZigZagBigInt(reader) {
+	let result = 0n;
+	let shift = 0n;
+	while (true) {
+		const byte = reader.view.getUint8(reader.offset++);
+		result |= BigInt(byte & 127) << shift;
+		if (!(byte & 128)) return result >> 1n ^ -(result & 1n);
+		shift += 7n;
+	}
+}
+function readAvroString(reader) {
+	const length = readZigZag(reader);
+	const bytes = new Uint8Array(reader.view.buffer, reader.view.byteOffset + reader.offset, length);
+	reader.offset += length;
+	return new TextDecoder().decode(bytes);
+}
+function avroMetadata(reader) {
+	if (reader.view.getUint32(reader.offset) !== 1331849729) throw new Error("avro invalid magic bytes");
+	reader.offset += 4;
+	const metadata = {};
+	let mapCount = readZigZag(reader);
+	while (mapCount !== 0) {
+		if (mapCount < 0) {
+			mapCount = -mapCount;
+			readZigZag(reader);
+		}
+		for (let i = 0; i < mapCount; i++) {
+			const key = readAvroString(reader);
+			metadata[key] = readAvroString(reader);
+		}
+		mapCount = readZigZag(reader);
+	}
+	metadata["avro.schema"] = JSON.parse(metadata["avro.schema"]);
+	if (metadata["schema"]) metadata["schema"] = JSON.parse(metadata["schema"]);
+	if (metadata["iceberg.schema"]) metadata["iceberg.schema"] = JSON.parse(metadata["iceberg.schema"]);
+	const syncMarker = new Uint8Array(reader.view.buffer, reader.view.byteOffset + reader.offset, 16);
+	reader.offset += 16;
+	return {
+		metadata,
+		syncMarker
+	};
+}
+function avroRead({ reader, metadata, syncMarker }) {
+	const blocks = [];
+	while (reader.offset < reader.view.byteLength) {
+		let recordCount = readZigZag(reader);
+		if (recordCount === 0) break;
+		if (recordCount < 0) recordCount = -recordCount;
+		const blockSize = readZigZag(reader);
+		let data = new Uint8Array(reader.view.buffer, reader.view.byteOffset + reader.offset, blockSize);
+		reader.offset += blockSize;
+		const blockSync = new Uint8Array(reader.view.buffer, reader.view.byteOffset + reader.offset, 16);
+		reader.offset += 16;
+		for (let i = 0; i < 16; i++) if (blockSync[i] !== syncMarker[i]) throw new Error("sync marker does not match");
+		const codec = metadata["avro.codec"];
+		if (codec === "deflate") data = gunzip(data);
+		else if (codec !== "null") throw new Error(`unsupported codec: ${codec}`);
+		const { fields } = metadata["avro.schema"];
+		const dataReader = {
+			view: new DataView(data.buffer, data.byteOffset, data.byteLength),
+			offset: 0
+		};
+		for (let i = 0; i < recordCount; i++) {
+			const obj = {};
+			for (const field of fields) {
+				const value = readType(dataReader, field.type);
+				obj[field.name] = value;
+			}
+			blocks.push(obj);
+		}
+	}
+	return blocks;
+}
+function readType(reader, type) {
+	if (type === "null") return;
+	else if (Array.isArray(type)) return readType(reader, type[readZigZag(reader)]);
+	else if (typeof type === "object" && type.type === "record") {
+		const obj = {};
+		for (const subField of type.fields) obj[subField.name] = readType(reader, subField.type);
+		return obj;
+	} else if (typeof type === "object" && type.type === "array") {
+		const arr = [];
+		while (true) {
+			let count = readZigZag(reader);
+			if (count === 0) break;
+			if (count < 0) {
+				count = -count;
+				readZigZag(reader);
+			}
+			for (let i = 0; i < count; i++) arr.push(readType(reader, type.items));
+		}
+		return arr;
+	} else if (typeof type === "object" && type.logicalType) if (type.logicalType === "date" && type.type === "int") {
+		const value = readZigZag(reader);
+		return /* @__PURE__ */ new Date(value * 864e5);
+	} else if (type.logicalType === "time-millis" && type.type === "int") return readZigZag(reader);
+	else if (type.logicalType === "time-micros" && type.type === "long") return readZigZagBigInt(reader);
+	else if (type.logicalType === "timestamp-millis" && type.type === "long") {
+		const value = readZigZagBigInt(reader);
+		return new Date(Number(value));
+	} else if (type.logicalType === "timestamp-micros" && type.type === "long") {
+		const value = readZigZagBigInt(reader);
+		return new Date(Number(value / 1000n));
+	} else if (type.logicalType === "timestamp-nanos" && type.type === "long") {
+		const value = readZigZagBigInt(reader);
+		return new Date(Number(value / 1000000n));
+	} else if (type.logicalType === "decimal" && "precision" in type) {
+		const bytes = type.type === "fixed" ? readFixed(reader, type.size) : readType(reader, type.type);
+		const factor = 10 ** -(type.scale || 0);
+		return parseDecimal(bytes) * factor;
+	} else if (type.logicalType === "uuid" && type.type === "fixed" && type.size === 16) return bytesToUuid(readFixed(reader, 16));
+	else {
+		console.warn(`unknown logical type: ${type.logicalType}`);
+		return type.type === "fixed" ? readFixed(reader, type.size) : readType(reader, type.type);
+	}
+	else if (typeof type === "object" && type.type === "fixed") return readFixed(reader, type.size);
+	else if (type === "boolean") {
+		const value = reader.view.getUint8(reader.offset) === 1;
+		reader.offset++;
+		return value;
+	} else if (type === "int") return readZigZag(reader);
+	else if (type === "long") return readZigZagBigInt(reader);
+	else if (type === "float") {
+		const value = reader.view.getFloat32(reader.offset, true);
+		reader.offset += 4;
+		return value;
+	} else if (type === "double") {
+		const value = reader.view.getFloat64(reader.offset, true);
+		reader.offset += 8;
+		return value;
+	} else if (type === "bytes") {
+		const length = readZigZag(reader);
+		const bytes = new Uint8Array(reader.view.buffer, reader.view.byteOffset + reader.offset, length);
+		reader.offset += length;
+		return bytes;
+	} else if (type === "string") {
+		const length = readZigZag(reader);
+		const bytes = new Uint8Array(reader.view.buffer, reader.view.byteOffset + reader.offset, length);
+		const text = new TextDecoder().decode(bytes);
+		reader.offset += length;
+		return text;
+	} else throw new Error(`unsupported type: ${type}`);
+}
+function readFixed(reader, size) {
+	const bytes = new Uint8Array(reader.view.buffer, reader.view.byteOffset + reader.offset, size);
+	reader.offset += size;
+	return bytes;
+}
+function bytesToUuid(bytes) {
+	let hex = "";
+	for (let i = 0; i < 16; i++) {
+		hex += bytes[i].toString(16).padStart(2, "0");
+		if (i === 3 || i === 5 || i === 7 || i === 9) hex += "-";
+	}
+	return hex;
+}
+function sanitize(name) {
+	let result = "";
+	for (let i = 0; i < name.length; i++) {
+		const ch = name.charAt(i);
+		const isLetter = /^[A-Za-z]$/.test(ch);
+		const isDigit = /^[0-9]$/.test(ch);
+		if (i === 0) if (isLetter || ch === "_") result += ch;
+		else result += isDigit ? "_" + ch : "_x" + ch.charCodeAt(0).toString(16).toUpperCase();
+		else if (isLetter || isDigit || ch === "_") result += ch;
+		else result += "_x" + ch.charCodeAt(0).toString(16).toUpperCase();
+	}
+	return result;
+}
+function bytesToHex$1(bytes) {
+	let hex = "";
+	for (let i = 0; i < bytes.length; i++) hex += bytes[i].toString(16).padStart(2, "0");
+	return hex;
+}
+function uuid4() {
+	if (globalThis.crypto?.randomUUID) return globalThis.crypto.randomUUID();
+	return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+		const r = Math.random() * 16 | 0;
+		return (c === "x" ? r : r & 3 | 8).toString(16);
+	});
+}
+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 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
+	});
+}
+const MAX_SAFE = BigInt(Number.MAX_SAFE_INTEGER);
+function stringifyIcebergJson(value, indent) {
+	const sp = indent ? " ".repeat(indent) : "";
+	function emit(v, depth) {
+		if (typeof v === "bigint") return v.toString();
+		if (v === null) return "null";
+		if (typeof v === "string") return JSON.stringify(v);
+		if (typeof v === "number" || typeof v === "boolean") return JSON.stringify(v);
+		if (Array.isArray(v)) {
+			if (v.length === 0) return "[]";
+			const inner = v.map((x) => emit(x, depth + 1));
+			if (!sp) return "[" + inner.join(",") + "]";
+			const pad = sp.repeat(depth + 1), close = sp.repeat(depth);
+			return "[\n" + pad + inner.join(",\n" + pad) + "\n" + close + "]";
+		}
+		if (typeof v === "object") {
+			const keys = Object.keys(v).filter((k) => v[k] !== void 0);
+			if (keys.length === 0) return "{}";
+			const inner = keys.map((k) => JSON.stringify(k) + (sp ? ": " : ":") + emit(v[k], depth + 1));
+			if (!sp) return "{" + inner.join(",") + "}";
+			const pad = sp.repeat(depth + 1), close = sp.repeat(depth);
+			return "{\n" + pad + inner.join(",\n" + pad) + "\n" + close + "}";
+		}
+		return JSON.stringify(v);
+	}
+	return emit(value, 0);
+}
+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 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: ${err.message}`);
+	});
+}
+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;
+}
+async function restCatalogConnect({ url, warehouse, requestInit }) {
+	const base = url.replace(/\/$/, "");
+	const configUrl = warehouse ? `${base}/v1/config?warehouse=${encodeURIComponent(warehouse)}` : `${base}/v1/config`;
+	const res = await fetch(configUrl, requestInit);
+	if (!res.ok) await throwRestError(res);
+	const body = parseIcebergJson(await res.text());
+	const defaults = body.defaults ?? {};
+	const overrides = body.overrides ?? {};
+	const prefix = overrides.prefix ?? defaults.prefix ?? "";
+	return Object.freeze({
+		type: "rest",
+		url: base,
+		prefix: typeof prefix === "string" ? prefix : "",
+		defaults,
+		overrides,
+		requestInit
+	});
+}
+function restCatalogListTables(ctx, { namespace }) {
+	const ns = encodeNamespace(namespace);
+	return paginate({}, async (query) => {
+		const body = parseIcebergJson(await (await restFetch(ctx, `namespaces/${ns}/tables${query}`)).text());
+		return {
+			items: body.identifiers ?? [],
+			nextPageToken: body["next-page-token"]
+		};
+	});
+}
+async function restCatalogLoadTable(ctx, { namespace, table }) {
+	const body = parseIcebergJson(await (await restFetch(ctx, `namespaces/${encodeNamespace(namespace)}/tables/${encodeURIComponent(table)}`)).text());
+	return {
+		metadataLocation: body["metadata-location"],
+		metadata: body.metadata,
+		config: body.config ?? {}
+	};
+}
+async function restCatalogCreateTable(ctx, { namespace, table, schema, location, partitionSpec, writeOrder, stageCreate, properties }) {
+	const ns = encodeNamespace(namespace);
+	const body = {
+		name: table,
+		schema
+	};
+	if (location !== void 0) body.location = location;
+	if (partitionSpec !== void 0) body["partition-spec"] = partitionSpec;
+	if (writeOrder !== void 0) body["write-order"] = writeOrder;
+	if (stageCreate !== void 0) body["stage-create"] = stageCreate;
+	if (properties !== void 0) body.properties = properties;
+	const responseBody = parseIcebergJson(await (await restFetch(ctx, `namespaces/${ns}/tables`, {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: stringifyIcebergJson(body)
+	})).text());
+	return {
+		metadataLocation: responseBody["metadata-location"],
+		metadata: responseBody.metadata,
+		config: responseBody.config ?? {}
+	};
+}
+async function restCatalogUpdateTable(ctx, { namespace, table, requirements, updates }) {
+	const responseBody = parseIcebergJson(await (await restFetch(ctx, `namespaces/${encodeNamespace(namespace)}/tables/${encodeURIComponent(table)}`, {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: stringifyIcebergJson({
+			requirements,
+			updates
+		})
+	})).text());
+	return {
+		metadataLocation: responseBody["metadata-location"],
+		metadata: responseBody.metadata,
+		config: responseBody.config ?? {}
+	};
+}
+async function restCatalogDropTable(ctx, { namespace, table, purgeRequested }) {
+	await restFetch(ctx, `namespaces/${encodeNamespace(namespace)}/tables/${encodeURIComponent(table)}${purgeRequested ? "?purgeRequested=true" : ""}`, { method: "DELETE" });
+}
+async function restCatalogCreateNamespace(ctx, { namespace, properties }) {
+	const ns = Array.isArray(namespace) ? namespace : namespace.split(".");
+	const body = parseIcebergJson(await (await restFetch(ctx, "namespaces", {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: stringifyIcebergJson({
+			namespace: ns,
+			properties: properties ?? {}
+		})
+	})).text());
+	return {
+		namespace: body.namespace ?? ns,
+		properties: body.properties ?? {}
+	};
+}
+function encodeNamespace(namespace) {
+	return (Array.isArray(namespace) ? namespace : namespace.split(".")).map((p) => encodeURIComponent(p)).join("%1F");
+}
+async function restFetch(ctx, path, init) {
+	const prefixSegment = ctx.prefix ? `${ctx.prefix.replace(/^\/|\/$/g, "")}/` : "";
+	const fullUrl = `${ctx.url}/v1/${prefixSegment}${path}`;
+	const merged = mergeRequestInit(ctx.requestInit, init);
+	const res = await fetch(fullUrl, merged);
+	if (!res.ok) await throwRestError(res);
+	return res;
+}
+function mergeRequestInit(a, b) {
+	if (!a) return b;
+	if (!b) return a;
+	return {
+		...a,
+		...b,
+		headers: {
+			...headersToObject(a.headers),
+			...headersToObject(b.headers)
+		}
+	};
+}
+function headersToObject(h) {
+	if (!h) return {};
+	if (h instanceof Headers) {
+		const out = {};
+		h.forEach((v, k) => {
+			out[k] = v;
+		});
+		return out;
+	}
+	if (Array.isArray(h)) return Object.fromEntries(h);
+	return h;
+}
+async function throwRestError(res) {
+	let detail = "";
+	try {
+		const body = parseIcebergJson(await res.text());
+		if (body?.error) {
+			const { code, type, message } = body.error;
+			detail = `${code ?? res.status} ${type ?? ""}: ${message ?? ""}`.trim();
+		}
+	} catch {}
+	const err = new Error(detail || `${res.status} ${res.statusText}`);
+	err.status = res.status;
+	throw err;
+}
+async function paginate(baseParams, fetchPage) {
+	const out = [];
+	let pageToken;
+	while (true) {
+		const params = { ...baseParams };
+		if (pageToken) params.pageToken = pageToken;
+		const keys = Object.keys(params);
+		const { items, nextPageToken } = await fetchPage(keys.length ? "?" + keys.map((k) => `${k}=${params[k]}`).join("&") : "");
+		out.push(...items);
+		if (!nextPageToken) return out;
+		pageToken = encodeURIComponent(nextPageToken);
+	}
+}
+async function loadTable({ catalog, namespace, table, tableUrl, resolver }) {
+	if (catalog.type === "rest") {
+		if (!namespace || !table) throw new Error("namespace and table are required for rest catalogs");
+		const { metadata } = await restCatalogLoadTable(catalog, {
+			namespace,
+			table
+		});
+		return {
+			metadata,
+			metadataFileName: void 0,
+			tableUrl: metadata.location,
+			resolver
+		};
+	}
+	if (catalog.type === "file") {
+		if (!tableUrl) throw new Error("tableUrl is required for file catalogs");
+		const eff = resolver ?? catalog.resolver;
+		if (catalog.conditionalCommits) {
+			const { metadata, metadataFileName, version } = await loadLatestFileCatalogMetadata({
+				tableUrl,
+				resolver: eff,
+				lister: catalog.lister
+			});
+			return {
+				metadata,
+				metadataFileName,
+				version,
+				tableUrl,
+				resolver: eff
+			};
+		}
+		const { metadata, metadataFileName } = await resolveMetadata({
+			tableUrl,
+			resolver: eff,
+			lister: catalog.lister
+		});
+		return {
+			metadata,
+			metadataFileName,
+			tableUrl,
+			resolver: eff
+		};
+	}
+	throw new Error(`unknown catalog type: ${catalog?.type}`);
+}
+function validateSchemaForVersion(schema, formatVersion) {
+	for (const field of schema.fields) validateFieldForVersion(field, formatVersion, field.name);
+}
+function maxFieldId(fields = []) {
+	let max = 0;
+	for (const field of fields) {
+		if (max < field.id) max = field.id;
+		const nested = maxNestedFieldId(field.type);
+		if (max < nested) max = nested;
+	}
+	return max;
+}
+function maxNestedFieldId(type) {
+	if (typeof type === "string") return 0;
+	if (type.type === "list") {
+		const elementId = type["element-id"] ?? 0;
+		return Math.max(elementId, maxNestedFieldId(type.element));
+	}
+	if (type.type === "map") {
+		const keyId = type["key-id"] ?? 0;
+		const valueId = type["value-id"] ?? 0;
+		return Math.max(keyId, valueId, maxNestedFieldId(type.key), maxNestedFieldId(type.value));
+	}
+	if (type.type === "struct") return maxFieldId(type.fields);
+	return 0;
+}
+const MAX_USER_FIELD_ID = 2147483447;
+function validateFieldForVersion(field, formatVersion, path) {
+	if (typeof field.id === "number" && field.id > MAX_USER_FIELD_ID) throw new Error(`field id ${field.id} is in the reserved range (> ${MAX_USER_FIELD_ID}) (field: ${path})`);
+	if (formatVersion < 3) {
+		checkTypeForV2(field.type, path);
+		if (field["initial-default"] !== void 0) throw new Error(`initial-default requires format-version 3 (field: ${path})`);
+		if (field["write-default"] !== void 0) throw new Error(`write-default requires format-version 3 (field: ${path})`);
+	} else checkV3Default(field, path);
+	checkNestedFieldsForVersion(field.type, formatVersion, path);
+}
+function checkTypeForV2(type, path) {
+	if (typeof type === "string") {
+		if (type === "unknown" || type === "variant" || type === "timestamp_ns" || type === "timestamptz_ns" || type === "geometry" || type.startsWith("geometry(") || type === "geography" || type.startsWith("geography(")) throw new Error(`type ${type} requires format-version 3 (field: ${path})`);
+		return;
+	}
+	if (type.type === "struct") for (const f of type.fields) checkTypeForV2(f.type, `${path}.${f.name}`);
+	else if (type.type === "list") checkTypeForV2(type.element, `${path}.element`);
+	else if (type.type === "map") {
+		checkTypeForV2(type.key, `${path}.key`);
+		checkTypeForV2(type.value, `${path}.value`);
+	}
+}
+function checkV3Default(field, path) {
+	const type = typeName(field.type);
+	if (!requiresNullDefault(type)) return;
+	for (const key of ["initial-default", "write-default"]) if (field[key] != null) throw new Error(`${key} for field ${path} of type ${type} must default to null`);
+}
+function checkNestedFieldsForVersion(type, formatVersion, path) {
+	if (typeof type === "string") return;
+	if (type.type === "struct") for (const f of type.fields) validateFieldForVersion(f, formatVersion, `${path}.${f.name}`);
+	else if (type.type === "list") {
+		checkReservedFieldId(type["element-id"], `${path}.element`);
+		checkNestedFieldsForVersion(type.element, formatVersion, `${path}.element`);
+	} else if (type.type === "map") {
+		checkReservedFieldId(type["key-id"], `${path}.key`);
+		checkReservedFieldId(type["value-id"], `${path}.value`);
+		checkNestedFieldsForVersion(type.key, formatVersion, `${path}.key`);
+		checkNestedFieldsForVersion(type.value, formatVersion, `${path}.value`);
+	}
+}
+function checkReservedFieldId(id, path) {
+	if (typeof id === "number" && id > MAX_USER_FIELD_ID) throw new Error(`field id ${id} is in the reserved range (> ${MAX_USER_FIELD_ID}) (field: ${path})`);
+}
+function typeName(type) {
+	return typeof type === "string" ? type : type.type;
+}
+function requiresNullDefault(type) {
+	return type === "unknown" || type === "variant" || type === "geometry" || type.startsWith("geometry(") || type === "geography" || type.startsWith("geography(");
+}
+function parseDecimalType(type) {
+	const m = /^decimal\((\d+),\s*(\d+)\)$/.exec(type);
+	if (!m) return void 0;
+	return {
+		precision: parseInt(m[1], 10),
+		scale: parseInt(m[2], 10)
+	};
+}
+function decimalRequiredBytes(precision) {
+	const limit = 10n ** BigInt(precision);
+	let n = 1;
+	let bound = 128n;
+	while (limit > bound) {
+		n++;
+		bound <<= 8n;
+	}
+	return n;
+}
+function decimalToFixedBytes(value, precision, scale, label) {
+	const size = decimalRequiredBytes(precision);
+	if (value instanceof Uint8Array) {
+		if (value.length !== size) throw new Error(`expected ${label}`);
+		return value;
+	}
+	if (typeof value !== "number" && typeof value !== "bigint") throw new Error(`expected ${label}`);
+	const factor = 10n ** BigInt(scale);
+	const unscaled = typeof value === "bigint" ? value * factor : BigInt(Math.round(value * Number(factor)));
+	const limit = 10n ** BigInt(precision);
+	if (unscaled >= limit || unscaled <= -limit) throw new Error(`${label} exceeds precision ${precision}`);
+	return bigintToFixedBytes(unscaled, size, label);
+}
+function toUint8Array(value) {
+	return value instanceof Uint8Array ? value : new Uint8Array(value);
+}
+function uuidToBytes(value, label) {
+	if (value instanceof Uint8Array) {
+		if (value.length !== 16) throw new Error(`expected ${label}`);
+		return value;
+	}
+	if (typeof value !== "string") throw new Error(`expected ${label}`);
+	const hex = value.toLowerCase().replace(/-/g, "");
+	if (!/^[0-9a-f]{32}$/.test(hex)) throw new Error(`expected ${label}`);
+	const bytes = new Uint8Array(16);
+	for (let i = 0; i < bytes.length; i++) bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+	return bytes;
+}
+function bigintToFixedBytes(value, size, label) {
+	const bytes = new Uint8Array(size);
+	let v = value;
+	for (let i = size - 1; i >= 0; i--) {
+		bytes[i] = Number(v & 255n);
+		v >>= 8n;
+	}
+	const negative = value < 0n;
+	const signBitSet = (bytes[0] & 128) !== 0;
+	if (!negative && (v !== 0n || signBitSet) || negative && (v !== -1n || !signBitSet)) throw new Error(`${label} does not fit in ${size} bytes`);
+	return bytes;
+}
+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 = 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;
+}
+function groupByPartition(records, schema, partitionSpec) {
+	const sourceFields = partitionSpec.fields.map((pf) => {
+		const sourceId = pf["source-id"];
+		if (sourceId === void 0) throw new Error(`partition field ${pf.name} is missing source-id`);
+		const sourceField = schema.fields.find((f) => f.id === sourceId);
+		if (!sourceField) throw new Error(`partition source field id ${sourceId} not found in schema`);
+		return {
+			partitionName: pf.name,
+			sourceName: sourceField.name,
+			sourceType: sourceField.type,
+			sourceWriteDefault: sourceField["write-default"],
+			transform: pf.transform,
+			resultType: transformResultType(pf.transform, sourceField.type)
+		};
+	});
+	const groups = /* @__PURE__ */ new Map();
+	for (const record of records) {
+		const partition = {};
+		const keyParts = [];
+		for (const { partitionName, sourceName, sourceType, sourceWriteDefault, transform, resultType } of sourceFields) {
+			let v = record[sourceName];
+			if (v === void 0 && sourceWriteDefault !== void 0) v = sourceWriteDefault;
+			partition[partitionName] = applyTransform(transform, v === void 0 ? null : v, sourceType);
+			keyParts.push(partitionKeyPart(partition[partitionName], resultType));
+		}
+		const key = JSON.stringify(keyParts);
+		let group = groups.get(key);
+		if (!group) {
+			group = {
+				partition,
+				records: []
+			};
+			groups.set(key, group);
+		}
+		group.records.push(record);
+	}
+	return [...groups.values()];
+}
+function validatePartitionSpecForWrite(schema, partitionSpec, label = "partition spec") {
+	for (const pf of partitionSpec.fields) {
+		const sourceId = pf["source-id"];
+		if (sourceId === void 0) throw new Error(`${label}: partition field ${pf.name} is missing source-id`);
+		const sourceField = schema.fields.find((f) => f.id === sourceId);
+		if (!sourceField) throw new Error(`${label}: partition source field id ${sourceId} not found in schema`);
+		icebergTypeToAvro(transformResultType(pf.transform, sourceField.type), pf["field-id"]);
+	}
+}
+function partitionAvroSchema(schema, partitionSpec) {
+	return {
+		type: "record",
+		name: "r102",
+		fields: partitionSpec.fields.map((pf) => {
+			const sourceField = schema.fields.find((f) => f.id === pf["source-id"]);
+			if (!sourceField) throw new Error(`partition source field id ${pf["source-id"]} not found`);
+			const resultType = transformResultType(pf.transform, sourceField.type);
+			return {
+				name: pf.name,
+				"field-id": pf["field-id"],
+				default: null,
+				type: ["null", icebergTypeToAvro(resultType, pf["field-id"])]
+			};
+		})
+	};
+}
+function partitionSpecJson(partitionSpec) {
+	return JSON.stringify(partitionSpec.fields);
+}
+function partitionToAvroRecord(partition, schema, partitionSpec) {
+	const out = {};
+	for (const pf of partitionSpec.fields) {
+		const sourceField = schema.fields.find((f) => f.id === pf["source-id"]);
+		if (!sourceField) throw new Error(`partition source field id ${pf["source-id"]} not found`);
+		const resultType = transformResultType(pf.transform, sourceField.type);
+		const value = partition[pf.name];
+		out[pf.name] = value == null ? null : coerceForAvro(value, resultType);
+	}
+	return out;
+}
+function partitionKeyPart(value, type) {
+	if (value === null || value === void 0) return "__null__";
+	const name = typeof type === "string" ? type : type.type;
+	if (name === "uuid") return `uuid:${bytesToHex$1(uuidToBytes(value, "uuid partition value"))}`;
+	if (typeof value === "number" && (name === "float" || name === "double")) return `${name}:${floatPartitionKey(value, name)}`;
+	if (name === "long") return `long:${BigInt(value)}`;
+	if (typeof value === "bigint") return `b:${value.toString()}`;
+	if (value instanceof Date) return `d:${value.getTime()}`;
+	if (value instanceof Uint8Array) return `x:${bytesToHex$1(value)}`;
+	return `${typeof value}:${String(value)}`;
+}
+function floatPartitionKey(value, type) {
+	if (Number.isNaN(value)) return "nan";
+	const bytes = new Uint8Array(type === "float" ? 4 : 8);
+	const view = new DataView(bytes.buffer);
+	if (type === "float") view.setFloat32(0, value, false);
+	else view.setFloat64(0, value, false);
+	return bytesToHex$1(bytes);
+}
+function icebergTypeToAvro(type, fieldId) {
+	const name = typeof type === "string" ? type : type.type;
+	const decimal = parseDecimalType(name);
+	if (decimal) return {
+		type: "fixed",
+		name: `r102_${fieldId}`,
+		size: decimalRequiredBytes(decimal.precision),
+		logicalType: "decimal",
+		precision: decimal.precision,
+		scale: decimal.scale
+	};
+	const fixed = /^fixed\[(\d+)\]$/.exec(name);
+	if (fixed) return {
+		type: "fixed",
+		name: `r102_${fieldId}`,
+		size: parseInt(fixed[1], 10)
+	};
+	switch (name) {
+		case "boolean": return "boolean";
+		case "int": return "int";
+		case "long": return "long";
+		case "float": return "float";
+		case "double": return "double";
+		case "string": return "string";
+		case "uuid": return {
+			type: "fixed",
+			name: `r102_${fieldId}`,
+			size: 16,
+			logicalType: "uuid"
+		};
+		case "binary": return "bytes";
+		case "date": return {
+			type: "int",
+			logicalType: "date"
+		};
+		case "time": return {
+			type: "long",
+			logicalType: "time-micros"
+		};
+		case "timestamp": return {
+			type: "long",
+			logicalType: "timestamp-micros",
+			"adjust-to-utc": false
+		};
+		case "timestamptz": return {
+			type: "long",
+			logicalType: "timestamp-micros",
+			"adjust-to-utc": true
+		};
+		case "timestamp_ns": return {
+			type: "long",
+			logicalType: "timestamp-nanos",
+			"adjust-to-utc": false
+		};
+		case "timestamptz_ns": return {
+			type: "long",
+			logicalType: "timestamp-nanos",
+			"adjust-to-utc": true
+		};
+		default: throw new Error(`unsupported partition source type: ${name}`);
+	}
+}
+function coerceForAvro(value, type) {
+	const name = typeof type === "string" ? type : type.type;
+	if (name === "long") return typeof value === "bigint" ? value : BigInt(value);
+	if (name === "uuid") return uuidToBytes(value, "uuid partition value");
+	const decimal = parseDecimalType(name);
+	if (decimal) return decimalToFixedBytes(value, decimal.precision, decimal.scale, `decimal(${decimal.precision},${decimal.scale}) partition value`);
+	const fixed = /^fixed\[(\d+)\]$/.exec(name);
+	if (fixed) {
+		const bytes = toUint8Array(value);
+		const expected = parseInt(fixed[1], 10);
+		if (bytes.length !== expected) throw new Error(`expected fixed[${expected}] partition value`);
+		return bytes;
+	}
+	return value;
+}
+async function icebergCreate({ tableUrl, resolver, schema, formatVersion, partitionSpec, sortOrder, properties, conditionalCommits }) {
+	if (!tableUrl) throw new Error("tableUrl is required");
+	if (formatVersion === void 0) {
+		const propVersion = properties?.["format-version"];
+		formatVersion = propVersion !== void 0 ? Number(propVersion) : 2;
+	}
+	if (formatVersion !== 2 && formatVersion !== 3) throw new Error(`unsupported format-version: ${formatVersion}`);
+	const metadataVersion = 1;
+	const metadataUrl = `${tableUrl}/metadata/v${metadataVersion}.metadata.json`;
+	const initialSchema = schema ?? {
+		type: "struct",
+		"schema-id": 0,
+		fields: []
+	};
+	validateSchemaForVersion(initialSchema, formatVersion);
+	const initialPartitionSpec = partitionSpec ?? {
+		"spec-id": 0,
+		fields: []
+	};
+	validatePartitionSpecForWrite(initialSchema, initialPartitionSpec);
+	const initialSortOrder = sortOrder ?? {
+		"order-id": 0,
+		fields: []
+	};
+	const metadata = {
+		"format-version": formatVersion,
+		"table-uuid": uuid4(),
+		location: tableUrl,
+		"last-sequence-number": 0,
+		"last-updated-ms": Date.now(),
+		"last-column-id": maxFieldId(initialSchema.fields),
+		"current-schema-id": initialSchema["schema-id"] ?? 0,
+		schemas: [initialSchema],
+		"default-spec-id": initialPartitionSpec["spec-id"],
+		"partition-specs": [initialPartitionSpec],
+		"last-partition-id": maxPartitionFieldId(initialPartitionSpec.fields),
+		"sort-orders": [initialSortOrder],
+		"default-sort-order-id": initialSortOrder["order-id"]
+	};
+	if (properties) metadata.properties = properties;
+	if (formatVersion >= 3) metadata["next-row-id"] = 0;
+	if (!resolver.writer) throw new Error("resolver.writer is required");
+	const metadataWriter = conditionalCommits ? resolver.writer(metadataUrl, { ifNoneMatch: "*" }) : resolver.writer(metadataUrl);
+	const metadataBytes = new TextEncoder().encode(stringifyIcebergJson(metadata, 2));
+	metadataWriter.appendBytes(metadataBytes);
+	await metadataWriter.finish();
+	const versionHintUrl = `${tableUrl}/metadata/version-hint.text`;
+	try {
+		const versionHintWriter = resolver.writer(versionHintUrl);
+		const versionHintBytes = new TextEncoder().encode(String(metadataVersion));
+		versionHintWriter.appendBytes(versionHintBytes);
+		await versionHintWriter.finish();
+	} catch (err) {
+		if (!conditionalCommits) throw err;
+	}
+	return metadata;
+}
+function maxPartitionFieldId(partitionFields = []) {
+	let max = 0;
+	for (const pf of partitionFields) if (max < pf["field-id"]) max = pf["field-id"];
+	return max;
+}
+async function fileCatalogCommit({ tableUrl, metadata, metadataFileName, currentVersion, staged, resolver, conditionalCommits }) {
+	if (!tableUrl) throw new Error("tableUrl is required");
+	if (!resolver?.writer) throw new Error("resolver.writer is required");
+	checkRequirements(metadata, staged.requirements);
+	const updated = applyUpdates(staged.updates.some((up) => up.action === "add-snapshot") ? metadata : {
+		...metadata,
+		"last-updated-ms": Date.now()
+	}, staged.updates);
+	const priorMetadataLog = metadata["metadata-log"] ?? [];
+	const derivedVersion = currentVersion ?? deriveCurrentVersion(priorMetadataLog);
+	const newVersion = derivedVersion + 1;
+	const currentMetadataPath = metadataFileName ? `${tableUrl}/metadata/${metadataFileName}` : `${tableUrl}/metadata/v${derivedVersion}.metadata.json`;
+	const newMetadataPath = `${tableUrl}/metadata/v${newVersion}.metadata.json`;
+	const appendedLog = [...priorMetadataLog, {
+		"timestamp-ms": metadata["last-updated-ms"],
+		"metadata-file": currentMetadataPath
+	}];
+	const max = Number(updated.properties?.["write.metadata.previous-versions-max"] ?? 100);
+	const droppedLog = max > 0 && appendedLog.length > max ? appendedLog.slice(0, appendedLog.length - max) : [];
+	const trimmedLog = droppedLog.length > 0 ? appendedLog.slice(-max) : appendedLog;
+	const newMetadata = {
+		...updated,
+		"metadata-log": trimmedLog
+	};
+	const metaWriter = conditionalCommits ? resolver.writer(newMetadataPath, { ifNoneMatch: "*" }) : resolver.writer(newMetadataPath);
+	metaWriter.appendBytes(new TextEncoder().encode(stringifyIcebergJson(newMetadata, 2)));
+	await metaWriter.finish();
+	try {
+		const hintWriter = resolver.writer(`${tableUrl}/metadata/version-hint.text`);
+		hintWriter.appendBytes(new TextEncoder().encode(String(newVersion)));
+		await hintWriter.finish();
+	} catch {}
+	if (updated.properties?.["write.metadata.delete-after-commit.enabled"] === "true" && droppedLog.length > 0 && resolver.deleter) {
+		const { deleter } = resolver;
+		await Promise.allSettled(droppedLog.map((entry) => deleter(entry["metadata-file"])));
+	}
+	return newMetadata;
+}
+function deriveCurrentVersion(priorMetadataLog) {
+	if (priorMetadataLog.length === 0) return 1;
+	const match = (priorMetadataLog[priorMetadataLog.length - 1]["metadata-file"].split("/").pop() ?? "").match(/^(?:v(\d+)|0*(\d+)-[0-9a-f-]+)\.metadata\.json$/);
+	if (match) return Number(match[1] ?? match[2]) + 1;
+	return priorMetadataLog.length + 1;
+}
+function checkRequirements(metadata, requirements) {
+	for (const req of requirements) if (req.type === "assert-create") throw new Error("requirement failed: assert-create against an existing table");
+	else if (req.type === "assert-table-uuid") {
+		if (metadata["table-uuid"] !== req.uuid) throw new Error(`requirement failed: table-uuid expected ${req.uuid}, got ${metadata["table-uuid"]}`);
+	} else if (req.type === "assert-ref-snapshot-id") {
+		let current = (metadata.refs ?? {})[req.ref]?.["snapshot-id"] ?? null;
+		if (current === null && req.ref === "main") current = metadata["current-snapshot-id"] ?? null;
+		const expected = req["snapshot-id"];
+		if (!(current === expected || current != null && expected != null && BigInt(current) === BigInt(expected))) throw new Error(`requirement failed: ref ${req.ref} expected snapshot ${expected}, got ${current}`);
+	} else if (req.type === "assert-next-row-id") {
+		const current = Number(metadata["next-row-id"] ?? 0);
+		if (current !== req["next-row-id"]) throw new Error(`requirement failed: next-row-id expected ${req["next-row-id"]}, got ${current}`);
+	} else if (req.type === "assert-current-schema-id") {
+		const current = metadata["current-schema-id"];
+		if (current !== req["current-schema-id"]) throw new Error(`requirement failed: current-schema-id expected ${req["current-schema-id"]}, got ${current}`);
+	} else if (req.type === "assert-last-assigned-field-id") {
+		const current = metadata["last-column-id"];
+		if (current !== req["last-assigned-field-id"]) throw new Error(`requirement failed: last-assigned-field-id expected ${req["last-assigned-field-id"]}, got ${current}`);
+	} else if (req.type === "assert-last-assigned-partition-id") {
+		const current = metadata["last-partition-id"];
+		if (current !== req["last-assigned-partition-id"]) throw new Error(`requirement failed: last-assigned-partition-id expected ${req["last-assigned-partition-id"]}, got ${current}`);
+	} else if (req.type === "assert-default-spec-id") {
+		const current = metadata["default-spec-id"];
+		if (current !== req["default-spec-id"]) throw new Error(`requirement failed: default-spec-id expected ${req["default-spec-id"]}, got ${current}`);
+	} else if (req.type === "assert-default-sort-order-id") {
+		const current = metadata["default-sort-order-id"];
+		if (current !== req["default-sort-order-id"]) throw new Error(`requirement failed: default-sort-order-id expected ${req["default-sort-order-id"]}, got ${current}`);
+	} else throw new Error(`unknown requirement: ${JSON.stringify(req)}`);
+}
+function applyUpdates(metadata, updates) {
+	let next = { ...metadata };
+	for (const up of updates) if (up.action === "add-snapshot") {
+		const snap = up.snapshot;
+		const priorSnapshots = next.snapshots ?? [];
+		if (priorSnapshots.some((s) => s["snapshot-id"] === snap["snapshot-id"])) throw new Error(`add-snapshot: snapshot-id ${snap["snapshot-id"]} already exists`);
+		next = {
+			...next,
+			snapshots: [...priorSnapshots, snap],
+			"last-sequence-number": Math.max(next["last-sequence-number"] ?? 0, snap["sequence-number"]),
+			"last-updated-ms": snap["timestamp-ms"]
+		};
+		if (next["format-version"] >= 3 && snap["first-row-id"] !== void 0 && snap["added-rows"] !== void 0) {
+			const nextRowId = snap["first-row-id"] + snap["added-rows"];
+			next["next-row-id"] = Math.max(Number(next["next-row-id"] ?? 0), nextRowId);
+		}
+	} else if (up.action === "set-properties") next = {
+		...next,
+		properties: {
+			...next.properties,
+			...up.updates
+		}
+	};
+	else if (up.action === "remove-properties") {
+		const properties = { ...next.properties };
+		for (const key of up.removals) delete properties[key];
+		next = {
+			...next,
+			properties
+		};
+	} else if (up.action === "add-schema") {
+		const schemas = next.schemas ?? [];
+		let schemaId = up.schema["schema-id"];
+		if (schemaId === -1) schemaId = schemas.reduce((m, s) => Math.max(m, s["schema-id"]), -1) + 1;
+		else if (schemas.some((s) => s["schema-id"] === schemaId)) throw new Error(`add-schema: schema-id ${schemaId} already exists`);
+		const newSchema = {
+			...up.schema,
+			"schema-id": schemaId
+		};
+		validateSchemaForVersion(newSchema, next["format-version"]);
+		const priorLastColumnId = next["last-column-id"] ?? 0;
+		validateAssignedFieldIds(newSchema, currentAssignedIdIndex(schemas, next["current-schema-id"]), priorLastColumnId);
+		validateSchemaEvolution(schemas, newSchema, priorLastColumnId, next["format-version"]);
+		validateNewRequiredFields(newSchema, priorLastColumnId);
+		next = {
+			...next,
+			schemas: [...schemas, newSchema],
+			"last-column-id": Math.max(priorLastColumnId, maxFieldId(newSchema.fields))
+		};
+	} else if (up.action === "set-current-schema") {
+		let id = up["schema-id"];
+		const schemas = next.schemas ?? [];
+		if (id === -1) {
+			if (schemas.length === 0) throw new Error("set-current-schema: table has no schemas");
+			id = schemas[schemas.length - 1]["schema-id"];
+		} else if (!schemas.some((s) => s["schema-id"] === id)) throw new Error(`set-current-schema: schema-id ${id} not found`);
+		next = {
+			...next,
+			"current-schema-id": id
+		};
+	} else if (up.action === "add-sort-order") {
+		const orders = next["sort-orders"] ?? [];
+		let orderId = up["sort-order"]["order-id"];
+		if (orderId === -1) orderId = orders.reduce((m, o) => Math.max(m, o["order-id"]), -1) + 1;
+		else if (orders.some((o) => o["order-id"] === orderId)) throw new Error(`add-sort-order: order-id ${orderId} already exists`);
+		const newOrder = {
+			...up["sort-order"],
+			"order-id": orderId
+		};
+		next = {
+			...next,
+			"sort-orders": [...orders, newOrder]
+		};
+	} else if (up.action === "set-default-sort-order") {
+		let id = up["sort-order-id"];
+		const orders = next["sort-orders"] ?? [];
+		if (id === -1) {
+			if (orders.length === 0) throw new Error("set-default-sort-order: table has no sort orders");
+			id = orders[orders.length - 1]["order-id"];
+		} else if (!orders.some((o) => o["order-id"] === id)) throw new Error(`set-default-sort-order: sort-order-id ${id} not found`);
+		next = {
+			...next,
+			"default-sort-order-id": id
+		};
+	} else if (up.action === "add-spec") {
+		const specs = next["partition-specs"] ?? [];
+		let specId = up.spec["spec-id"];
+		if (specId === -1) specId = specs.reduce((m, s) => Math.max(m, s["spec-id"]), -1) + 1;
+		else if (specs.some((s) => s["spec-id"] === specId)) throw new Error(`add-spec: spec-id ${specId} already exists`);
+		const newSpec = {
+			...up.spec,
+			"spec-id": specId
+		};
+		validatePartitionSpecEvolution(specs, newSpec, currentSchemaForMetadata(next));
+		let nextLastPartitionId = next["last-partition-id"] ?? 0;
+		for (const f of newSpec.fields) if (f["field-id"] > nextLastPartitionId) nextLastPartitionId = f["field-id"];
+		next = {
+			...next,
+			"partition-specs": [...specs, newSpec],
+			"last-partition-id": nextLastPartitionId
+		};
+	} else if (up.action === "set-default-spec") {
+		let id = up["spec-id"];
+		const specs = next["partition-specs"] ?? [];
+		if (id === -1) {
+			if (specs.length === 0) throw new Error("set-default-spec: table has no partition specs");
+			id = specs[specs.length - 1]["spec-id"];
+		} else if (!specs.some((s) => s["spec-id"] === id)) throw new Error(`set-default-spec: spec-id ${id} not found`);
+		next = {
+			...next,
+			"default-spec-id": id
+		};
+	} else if (up.action === "remove-snapshots") {
+		const removeIds = new Set(up["snapshot-ids"]);
+		const snapshots = (next.snapshots ?? []).filter((s) => !removeIds.has(s["snapshot-id"]));
+		const log = (next["snapshot-log"] ?? []).filter((e) => !removeIds.has(e["snapshot-id"]));
+		next = {
+			...next,
+			snapshots,
+			"snapshot-log": log
+		};
+	} else if (up.action === "set-snapshot-ref") {
+		const ref = {
+			"snapshot-id": up["snapshot-id"],
+			type: up.type
+		};
+		if (up["min-snapshots-to-keep"] !== void 0) ref["min-snapshots-to-keep"] = up["min-snapshots-to-keep"];
+		if (up["max-snapshot-age-ms"] !== void 0) ref["max-snapshot-age-ms"] = up["max-snapshot-age-ms"];
+		if (up["max-ref-age-ms"] !== void 0) ref["max-ref-age-ms"] = up["max-ref-age-ms"];
+		next = {
+			...next,
+			refs: {
+				...next.refs,
+				[up["ref-name"]]: ref
+			}
+		};
+		if (up["ref-name"] === "main" && up.type === "branch") {
+			next["current-snapshot-id"] = up["snapshot-id"];
+			next["snapshot-log"] = [...next["snapshot-log"] ?? [], {
+				"timestamp-ms": next["last-updated-ms"],
+				"snapshot-id": up["snapshot-id"]
+			}];
+		}
+	} else throw new Error(`unknown update: ${JSON.stringify(up)}`);
+	return next;
+}
+function currentAssignedIdIndex(schemas, currentSchemaId) {
+	const currentSchema = schemas.find((s) => s["schema-id"] === currentSchemaId) ?? schemas[schemas.length - 1];
+	const assignedIds = /* @__PURE__ */ new Map();
+	if (currentSchema) indexAssignedFieldIds(currentSchema.fields, "", assignedIds);
+	return assignedIds;
+}
+function indexAssignedFieldIds(fields, prefix, assignedIds) {
+	for (const field of fields) {
+		const path = prefix ? `${prefix}.${field.name}` : field.name;
+		assignedIds.set(field.id, {
+			kind: "field",
+			path
+		});
+		indexAssignedTypeIds(field.type, path, assignedIds);
+	}
+}
+function indexAssignedTypeIds(type, path, assignedIds) {
+	if (typeof type === "string") return;
+	if (type.type === "struct") indexAssignedFieldIds(type.fields, path, assignedIds);
+	else if (type.type === "list") {
+		assignedIds.set(type["element-id"], {
+			kind: "list element",
+			path: `${path}.element`
+		});
+		indexAssignedTypeIds(type.element, `${path}.element`, assignedIds);
+	} else if (type.type === "map") {
+		assignedIds.set(type["key-id"], {
+			kind: "map key",
+			path: `${path}.key`
+		});
+		assignedIds.set(type["value-id"], {
+			kind: "map value",
+			path: `${path}.value`
+		});
+		indexAssignedTypeIds(type.key, `${path}.key`, assignedIds);
+		indexAssignedTypeIds(type.value, `${path}.value`, assignedIds);
+	}
+}
+function validateAssignedFieldIds(schema, priorAssignedIds, priorLastColumnId) {
+	validateAssignedFields(schema.fields, "", priorAssignedIds, priorLastColumnId);
+}
+function validateAssignedFields(fields, prefix, priorAssignedIds, priorLastColumnId) {
+	for (const field of fields) {
+		const path = prefix ? `${prefix}.${field.name}` : field.name;
+		validateAssignedId(field.id, "field", path, priorAssignedIds, priorLastColumnId);
+		validateAssignedTypeIds(field.type, path, priorAssignedIds, priorLastColumnId);
+	}
+}
+function validateAssignedTypeIds(type, path, priorAssignedIds, priorLastColumnId) {
+	if (typeof type === "string") return;
+	if (type.type === "struct") validateAssignedFields(type.fields, path, priorAssignedIds, priorLastColumnId);
+	else if (type.type === "list") {
+		validateAssignedId(type["element-id"], "list element", `${path}.element`, priorAssignedIds, priorLastColumnId);
+		validateAssignedTypeIds(type.element, `${path}.element`, priorAssignedIds, priorLastColumnId);
+	} else if (type.type === "map") {
+		validateAssignedId(type["key-id"], "map key", `${path}.key`, priorAssignedIds, priorLastColumnId);
+		validateAssignedId(type["value-id"], "map value", `${path}.value`, priorAssignedIds, priorLastColumnId);
+		validateAssignedTypeIds(type.key, `${path}.key`, priorAssignedIds, priorLastColumnId);
+		validateAssignedTypeIds(type.value, `${path}.value`, priorAssignedIds, priorLastColumnId);
+	}
+}
+function validateAssignedId(id, kind, path, priorAssignedIds, priorLastColumnId) {
+	if (id > priorLastColumnId) return;
+	const prior = priorAssignedIds.get(id);
+	if (!prior) throw new Error(`add-schema: ${kind} ${path} uses unassigned id ${id} (last-column-id ${priorLastColumnId})`);
+	if (prior.kind !== kind) throw new Error(`add-schema: ${kind} ${path} uses id ${id} previously assigned to ${prior.kind} ${prior.path}`);
+}
+function validateNewRequiredFields(schema, priorLastColumnId) {
+	for (const field of schema.fields) if (field.id > priorLastColumnId && field.required) {
+		if (field["initial-default"] == null) throw new Error(`add-schema: required field ${field.name} (id ${field.id}) needs a non-null initial-default`);
+		if (field["write-default"] == null) throw new Error(`add-schema: required field ${field.name} (id ${field.id}) needs a non-null write-default`);
+	}
+}
+function validateSchemaEvolution(schemas, newSchema, priorLastColumnId, formatVersion) {
+	for (const field of newSchema.fields) {
+		if (field.id > priorLastColumnId) continue;
+		const prior = latestFieldById(schemas, field.id);
+		if (!prior) continue;
+		if (!canPromoteType(prior.type, field.type, formatVersion)) throw new Error(`add-schema: cannot promote field ${field.name} from ${typeToString(prior.type)} to ${typeToString(field.type)}`);
+		if (!defaultsEqual(prior["initial-default"], field["initial-default"])) throw new Error(`add-schema: initial-default for field ${field.name} cannot change`);
+	}
+}
+function latestFieldById(schemas, id) {
+	for (let i = schemas.length - 1; i >= 0; i--) {
+		const field = schemas[i].fields.find((f) => f.id === id);
+		if (field) return field;
+	}
+}
+function canPromoteType(from, to, formatVersion) {
+	if (typesEqual(from, to)) return true;
+	if (typeof from !== "string" || typeof to !== "string") return false;
+	if (formatVersion >= 3 && from === "unknown") return true;
+	if (from === "int" && to === "long") return true;
+	if (from === "float" && to === "double") return true;
+	if (formatVersion >= 3 && from === "date" && (to === "timestamp" || to === "timestamp_ns")) return true;
+	return decimalPromotionAllowed(from, to);
+}
+function typesEqual(a, b) {
+	if (typeof a === "string" || typeof b === "string") return a === b;
+	return JSON.stringify(a) === JSON.stringify(b);
+}
+function decimalPromotionAllowed(from, to) {
+	const a = parseDecimalType(from);
+	const b = parseDecimalType(to);
+	return Boolean(a && b && b.precision > a.precision && b.scale === a.scale);
+}
+function typeToString(type) {
+	return typeof type === "string" ? type : JSON.stringify(type);
+}
+function defaultsEqual(a, b) {
+	if (Object.is(a, b)) return true;
+	if (!a || !b || typeof a !== "object" || typeof b !== "object") return false;
+	if (Array.isArray(a) || Array.isArray(b)) {
+		if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+		for (let i = 0; i < a.length; i++) if (!defaultsEqual(a[i], b[i])) return false;
+		return true;
+	}
+	const aKeys = Object.keys(a);
+	const bKeys = Object.keys(b);
+	if (aKeys.length !== bKeys.length) return false;
+	for (const key of aKeys) {
+		if (!Object.hasOwn(b, key)) return false;
+		if (!defaultsEqual(a[key], b[key])) return false;
+	}
+	return true;
+}
+function validatePartitionSpecEvolution(specs, newSpec, schema) {
+	validateWritablePartitionSpec(newSpec, schema);
+	if (specs.some((spec) => partitionSpecsEquivalent(spec, newSpec))) throw new Error("add-spec: equivalent partition spec already exists");
+	for (const field of newSpec.fields) {
+		const equivalent = equivalentPartitionField(specs, field);
+		if (equivalent && equivalent["field-id"] !== field["field-id"]) throw new Error(`add-spec: partition field ${field.name} must reuse field-id ${equivalent["field-id"]}`);
+	}
+}
+function validateWritablePartitionSpec(spec, schema) {
+	try {
+		validatePartitionSpecForWrite(schema, spec, "add-spec");
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		if (message.startsWith("unsupported partition transform: ")) throw new Error(`add-spec: ${message}`);
+		throw err;
+	}
+}
+function currentSchemaForMetadata(metadata) {
+	const schema = metadata.schemas?.find((s) => s["schema-id"] === metadata["current-schema-id"]);
+	if (!schema) throw new Error("add-spec: current schema not found in metadata");
+	return schema;
+}
+function equivalentPartitionField(specs, field) {
+	for (const spec of specs) {
+		const found = spec.fields.find((existing) => partitionFieldsEquivalent(existing, field));
+		if (found) return found;
+	}
+}
+function partitionSpecsEquivalent(a, b) {
+	if (a.fields.length !== b.fields.length) return false;
+	for (let i = 0; i < a.fields.length; i++) if (!partitionFieldsEquivalent(a.fields[i], b.fields[i])) return false;
+	return true;
+}
+function partitionFieldsEquivalent(a, b) {
+	return a["source-id"] === b["source-id"] && idsListEquivalent(a["source-ids"], b["source-ids"]) && a.transform === b.transform && a.name === b.name;
+}
+function idsListEquivalent(a, b) {
+	if (a === void 0 || b === void 0) return a === b;
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
+function avroWrite({ writer, schema, records, blockSize = 512, metadata }) {
+	writer.appendUint32(23749199);
+	const meta = {
+		...metadata,
+		"avro.schema": typeof schema === "string" ? schema : JSON.stringify(schema),
+		"avro.codec": "null"
+	};
+	appendZigZag(writer, Object.keys(meta).length);
+	for (const [key, value] of Object.entries(meta)) {
+		const kb = new TextEncoder().encode(key);
+		appendZigZag(writer, kb.length);
+		writer.appendBytes(kb);
+		const vb = new TextEncoder().encode(value);
+		appendZigZag(writer, vb.length);
+		writer.appendBytes(vb);
+	}
+	writer.appendVarInt(0);
+	const sync = new Uint8Array(16);
+	for (let i = 0; i < 16; i++) sync[i] = Math.random() * 256 | 0;
+	writer.appendBytes(sync);
+	for (let i = 0; i < records.length; i += blockSize) {
+		const block = records.slice(i, i + blockSize);
+		appendZigZag(writer, block.length);
+		const blockWriter = new ByteWriter();
+		for (const record of block) for (const { name, type } of schema.fields) writeType(blockWriter, type, record[name]);
+		appendZigZag(writer, blockWriter.offset);
+		writer.appendBytes(blockWriter.getBytes());
+		writer.appendBytes(sync);
+	}
+	return writer.finish();
+}
+function writeType(writer, schema, value) {
+	if (Array.isArray(schema)) {
+		const unionIndex = schema.findIndex((s) => {
+			if (Array.isArray(s)) throw new Error("nested unions not supported");
+			const tag = typeof s === "string" ? s : s.type === "record" || s.type === "array" || s.type === "fixed" ? s.type : s.logicalType;
+			if (value == null) return tag === "null";
+			if (tag === "boolean") return typeof value === "boolean";
+			if (tag === "int") return typeof value === "number" && Number.isInteger(value);
+			if (tag === "long") return typeof value === "bigint" || typeof value === "number";
+			if (tag === "float" || tag === "double") return typeof value === "number";
+			if (tag === "string") return typeof value === "string";
+			if (tag === "bytes") return value instanceof Uint8Array;
+			if (tag === "date") return value instanceof Date || typeof value === "number";
+			if (tag === "time-millis") return typeof value === "number";
+			if (tag === "time-micros") return typeof value === "bigint" || typeof value === "number";
+			if (tag === "timestamp-millis" || tag === "timestamp-micros" || tag === "timestamp-nanos") return value instanceof Date || typeof value === "bigint" || typeof value === "number";
+			if (tag === "decimal") return typeof value === "number" || typeof value === "bigint";
+			if (tag === "record") return typeof value === "object" && value !== null;
+			if (tag === "array") return Array.isArray(value);
+			if (tag === "fixed") {
+				if (value instanceof Uint8Array) return true;
+				return typeof s === "object" && "logicalType" in s && s.logicalType === "uuid" && typeof value === "string";
+			}
+			return false;
+		});
+		if (unionIndex === -1) throw new Error("union branch not found");
+		appendZigZag(writer, unionIndex);
+		writeType(writer, schema[unionIndex], value);
+	} else if (typeof schema === "string") {
+		if (schema === "null") {} else if (schema === "boolean") writer.appendUint8(value ? 1 : 0);
+		else if (schema === "int") {
+			if (typeof value !== "number" || !Number.isInteger(value)) throw new Error("expected integer value");
+			appendZigZag(writer, value);
+		} else if (schema === "long") {
+			if (typeof value !== "bigint") throw new Error("expected bigint value");
+			appendZigZag64(writer, value);
+		} else if (schema === "float") {
+			if (typeof value !== "number") throw new Error("expected number value");
+			writer.appendFloat32(value);
+		} else if (schema === "double") {
+			if (typeof value !== "number") throw new Error("expected number value");
+			writer.appendFloat64(value);
+		} else if (schema === "bytes") {
+			if (!(value instanceof Uint8Array)) throw new Error("expected Uint8Array value");
+			appendZigZag(writer, value.length);
+			writer.appendBytes(value);
+		} else if (schema === "string") {
+			if (typeof value !== "string") throw new Error("expected string value");
+			const b = new TextEncoder().encode(value);
+			appendZigZag(writer, b.length);
+			writer.appendBytes(b);
+		}
+	} else if (schema.type === "record") for (const f of schema.fields) writeType(writer, f.type, value[f.name]);
+	else if (schema.type === "array") {
+		if (value.length) {
+			appendZigZag(writer, value.length);
+			for (const it of value) writeType(writer, schema.items, it);
+		}
+		writer.appendVarInt(0);
+	} else if (schema.type === "fixed") {
+		const bytes = schema.logicalType === "uuid" && typeof value === "string" ? uuidStringToBytes$1(value) : value;
+		if (!(bytes instanceof Uint8Array)) throw new Error("expected Uint8Array value");
+		if (bytes.length !== schema.size) throw new Error(`expected fixed[${schema.size}] value`);
+		writer.appendBytes(bytes);
+	} else if ("logicalType" in schema) if (schema.logicalType === "date") appendZigZag(writer, value instanceof Date ? Math.floor(value.getTime() / 864e5) : value);
+	else if (schema.logicalType === "time-millis") appendZigZag(writer, value);
+	else if (schema.logicalType === "time-micros") appendZigZag64(writer, BigInt(value));
+	else if (schema.logicalType === "timestamp-millis") appendZigZag64(writer, value instanceof Date ? BigInt(value.getTime()) : BigInt(value));
+	else if (schema.logicalType === "timestamp-micros") appendZigZag64(writer, value instanceof Date ? BigInt(value.getTime()) * 1000n : BigInt(value));
+	else if (schema.logicalType === "timestamp-nanos") appendZigZag64(writer, value instanceof Date ? BigInt(value.getTime()) * 1000000n : BigInt(value));
+	else if (schema.logicalType === "decimal") {
+		const scale = "scale" in schema ? schema.scale ?? 0 : 0;
+		let u;
+		if (typeof value === "bigint") u = value;
+		else if (typeof value === "number") u = BigInt(Math.round(value * 10 ** scale));
+		else throw new Error("decimal value must be bigint or number");
+		const b = bigIntToBytes(u);
+		appendZigZag(writer, b.length);
+		writer.appendBytes(b);
+	} else throw new Error(`unknown logical type ${schema.logicalType}`);
+	else throw new Error(`unknown schema type ${JSON.stringify(schema)}`);
+}
+function appendZigZag(writer, v) {
+	writer.appendVarInt(v << 1 ^ v >> 31);
+}
+function appendZigZag64(writer, v) {
+	writer.appendVarBigInt(v << 1n ^ v >> 63n);
+}
+function uuidStringToBytes$1(value) {
+	const hex = value.toLowerCase().replace(/-/g, "");
+	if (!/^[0-9a-f]{32}$/.test(hex)) throw new Error("expected uuid string");
+	const bytes = new Uint8Array(16);
+	for (let i = 0; i < 16; i++) bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+	return bytes;
+}
+function bigIntToBytes(value) {
+	const neg = value < 0n;
+	let abs = neg ? -value : value;
+	const out = [];
+	while (abs > 0n) {
+		out.unshift(Number(abs & 255n));
+		abs >>= 8n;
+	}
+	if (out.length === 0) out.push(0);
+	if (neg) {
+		for (let i = 0; i < out.length; i++) out[i] ^= 255;
+		for (let i = out.length - 1; i >= 0; i--) {
+			out[i] = out[i] + 1 & 255;
+			if (out[i]) break;
+		}
+		if ((out[0] & 128) === 0) out.unshift(255);
+	} else if ((out[0] & 128) !== 0) out.unshift(0);
+	return Uint8Array.from(out);
+}
+function manifestEntrySchema(schema, partitionSpec, formatVersion, manifestContent = 0) {
+	const dataFileFields = [
+		{
+			name: "content",
+			type: "int",
+			"field-id": 134
+		},
+		{
+			name: "file_path",
+			type: "string",
+			"field-id": 100
+		},
+		{
+			name: "file_format",
+			type: "string",
+			"field-id": 101
+		},
+		{
+			name: "partition",
+			"field-id": 102,
+			type: partitionAvroSchema(schema, partitionSpec)
+		},
+		{
+			name: "record_count",
+			type: "long",
+			"field-id": 103
+		},
+		{
+			name: "file_size_in_bytes",
+			type: "long",
+			"field-id": 104
+		},
+		mapField("column_sizes", 108, "k117_v118", 117, 118, "long"),
+		mapField("value_counts", 109, "k119_v120", 119, 120, "long"),
+		mapField("null_value_counts", 110, "k121_v122", 121, 122, "long"),
+		mapField("nan_value_counts", 137, "k138_v139", 138, 139, "long"),
+		mapField("lower_bounds", 125, "k126_v127", 126, 127, "bytes"),
+		mapField("upper_bounds", 128, "k129_v130", 129, 130, "bytes"),
+		{
+			name: "sort_order_id",
+			type: ["null", "int"],
+			default: null,
+			"field-id": 140
+		}
+	];
+	if (manifestContent === 1) {
+		dataFileFields.push({
+			name: "equality_ids",
+			"field-id": 135,
+			default: null,
+			type: ["null", {
+				type: "array",
+				items: "int",
+				"element-id": 136
+			}]
+		});
+		dataFileFields.push({
+			name: "referenced_data_file",
+			type: ["null", "string"],
+			default: null,
+			"field-id": 143
+		});
+		if (formatVersion >= 3) {
+			dataFileFields.push({
+				name: "content_offset",
+				type: ["null", "long"],
+				default: null,
+				"field-id": 144
+			});
+			dataFileFields.push({
+				name: "content_size_in_bytes",
+				type: ["null", "long"],
+				default: null,
+				"field-id": 145
+			});
+		}
+	}
+	if (formatVersion >= 3) dataFileFields.push({
+		name: "first_row_id",
+		type: ["null", "long"],
+		default: null,
+		"field-id": 142
+	});
+	return {
+		type: "record",
+		name: "manifest_entry",
+		fields: [
+			{
+				name: "status",
+				type: "int",
+				"field-id": 0
+			},
+			{
+				name: "snapshot_id",
+				type: ["null", "long"],
+				default: null,
+				"field-id": 1
+			},
+			{
+				name: "sequence_number",
+				type: ["null", "long"],
+				default: null,
+				"field-id": 3
+			},
+			{
+				name: "file_sequence_number",
+				type: ["null", "long"],
+				default: null,
+				"field-id": 4
+			},
+			{
+				name: "data_file",
+				"field-id": 2,
+				type: {
+					type: "record",
+					name: "r2",
+					fields: dataFileFields
+				}
+			}
+		]
+	};
+}
+function mapField(name, fieldId, recName, keyId, valueId, valueType) {
+	return {
+		name,
+		"field-id": fieldId,
+		default: null,
+		type: ["null", {
+			type: "array",
+			logicalType: "map",
+			items: {
+				type: "record",
+				name: recName,
+				fields: [{
+					name: "key",
+					type: "int",
+					"field-id": keyId
+				}, {
+					name: "value",
+					type: valueType,
+					"field-id": valueId
+				}]
+			}
+		}]
+	};
+}
+function icebergSchemaJson(schema) {
+	return JSON.stringify(schema);
+}
+function encodeMap(m) {
+	if (!m) return null;
+	const entries = Object.entries(m);
+	if (!entries.length) return null;
+	return entries.map(([k, value]) => ({
+		key: Number(k),
+		value
+	}));
+}
+function writeDataManifest({ writer, schema, partitionSpec, snapshotId, dataFiles, formatVersion = 2 }) {
+	const records = dataFiles.map((dataFile) => {
+		if (dataFile.content !== 0) throw new Error(`writeDataManifest expects data files (content=0), got content=${dataFile.content}`);
+		return manifestEntryRecord(dataFile, schema, partitionSpec, snapshotId, formatVersion, 0);
+	});
+	return avroWrite({
+		writer,
+		schema: manifestEntrySchema(schema, partitionSpec, formatVersion, 0),
+		records,
+		metadata: {
+			"format-version": String(formatVersion),
+			content: "data",
+			schema: icebergSchemaJson(schema),
+			"partition-spec": partitionSpecJson(partitionSpec),
+			"partition-spec-id": String(partitionSpec["spec-id"])
+		}
+	});
+}
+function manifestEntryRecord(dataFile, schema, partitionSpec, snapshotId, formatVersion, manifestContent) {
+	const dataFileRecord = {
+		content: dataFile.content,
+		file_path: dataFile.file_path,
+		file_format: dataFile.file_format.toUpperCase(),
+		partition: partitionToAvroRecord(dataFile.partition ?? {}, schema, partitionSpec),
+		record_count: dataFile.record_count,
+		file_size_in_bytes: dataFile.file_size_in_bytes,
+		column_sizes: encodeMap(dataFile.column_sizes),
+		value_counts: encodeMap(dataFile.value_counts),
+		null_value_counts: encodeMap(dataFile.null_value_counts),
+		nan_value_counts: encodeMap(dataFile.nan_value_counts),
+		lower_bounds: encodeMap(dataFile.lower_bounds),
+		upper_bounds: encodeMap(dataFile.upper_bounds),
+		sort_order_id: dataFile.content === 1 ? null : dataFile.sort_order_id ?? 0
+	};
+	if (manifestContent === 1) {
+		dataFileRecord.equality_ids = dataFile.equality_ids?.length ? dataFile.equality_ids : null;
+		dataFileRecord.referenced_data_file = dataFile.referenced_data_file ?? null;
+		if (formatVersion >= 3) {
+			dataFileRecord.content_offset = dataFile.content_offset ?? null;
+			dataFileRecord.content_size_in_bytes = dataFile.content_size_in_bytes ?? null;
+		}
+	}
+	if (formatVersion >= 3) dataFileRecord.first_row_id = dataFile.first_row_id ?? null;
+	return {
+		status: 1,
+		snapshot_id: snapshotId,
+		sequence_number: null,
+		file_sequence_number: null,
+		data_file: dataFileRecord
+	};
+}
+function manifestFileSchema(formatVersion) {
+	const fields = [
+		{
+			name: "manifest_path",
+			type: "string",
+			"field-id": 500
+		},
+		{
+			name: "manifest_length",
+			type: "long",
+			"field-id": 501
+		},
+		{
+			name: "partition_spec_id",
+			type: "int",
+			"field-id": 502
+		},
+		{
+			name: "content",
+			type: "int",
+			"field-id": 517
+		},
+		{
+			name: "sequence_number",
+			type: "long",
+			"field-id": 515
+		},
+		{
+			name: "min_sequence_number",
+			type: "long",
+			"field-id": 516
+		},
+		{
+			name: "added_snapshot_id",
+			type: "long",
+			"field-id": 503
+		},
+		{
+			name: "added_files_count",
+			type: "int",
+			"field-id": 504
+		},
+		{
+			name: "existing_files_count",
+			type: "int",
+			"field-id": 505
+		},
+		{
+			name: "deleted_files_count",
+			type: "int",
+			"field-id": 506
+		},
+		{
+			name: "added_rows_count",
+			type: "long",
+			"field-id": 512
+		},
+		{
+			name: "existing_rows_count",
+			type: "long",
+			"field-id": 513
+		},
+		{
+			name: "deleted_rows_count",
+			type: "long",
+			"field-id": 514
+		},
+		{
+			name: "partitions",
+			type: ["null", {
+				type: "array",
+				"element-id": 508,
+				items: {
+					type: "record",
+					name: "r508",
+					fields: [
+						{
+							name: "contains_null",
+							type: "boolean",
+							"field-id": 509
+						},
+						{
+							name: "contains_nan",
+							type: ["null", "boolean"],
+							default: null,
+							"field-id": 518
+						},
+						{
+							name: "lower_bound",
+							type: ["null", "bytes"],
+							default: null,
+							"field-id": 510
+						},
+						{
+							name: "upper_bound",
+							type: ["null", "bytes"],
+							default: null,
+							"field-id": 511
+						}
+					]
+				}
+			}],
+			default: null,
+			"field-id": 507
+		}
+	];
+	if (formatVersion >= 3) fields.push({
+		name: "first_row_id",
+		type: ["null", "long"],
+		default: null,
+		"field-id": 520
+	});
+	return {
+		type: "record",
+		name: "manifest_file",
+		fields
+	};
+}
+function writeManifestList({ writer, snapshotId, sequenceNumber, manifests, formatVersion = 2 }) {
+	const records = manifests.map((m) => {
+		const record = {
+			manifest_path: m.manifest_path,
+			manifest_length: m.manifest_length,
+			partition_spec_id: m.partition_spec_id,
+			content: m.content,
+			sequence_number: m.sequence_number ?? sequenceNumber,
+			min_sequence_number: m.min_sequence_number ?? sequenceNumber,
+			added_snapshot_id: m.added_snapshot_id,
+			added_files_count: m.added_files_count,
+			existing_files_count: m.existing_files_count,
+			deleted_files_count: m.deleted_files_count,
+			added_rows_count: m.added_rows_count,
+			existing_rows_count: m.existing_rows_count,
+			deleted_rows_count: m.deleted_rows_count,
+			partitions: m.partitions ?? null
+		};
+		if (formatVersion >= 3) record.first_row_id = m.content === 0 ? m.first_row_id ?? null : null;
+		return record;
+	});
+	return avroWrite({
+		writer,
+		schema: manifestFileSchema(formatVersion),
+		records,
+		metadata: {
+			"format-version": String(formatVersion),
+			"snapshot-id": String(snapshotId),
+			"sequence-number": String(sequenceNumber)
+		}
+	});
+}
+function isGeoType(name) {
+	return name.startsWith("geometry") || name.startsWith("geography");
+}
+function computeGeoBounds(records, field) {
+	let partial;
+	let nulls = 0n;
+	const writeDefault = field["write-default"];
+	for (const record of records) {
+		let v = record[field.name];
+		if (v === void 0 && writeDefault !== void 0) v = writeDefault;
+		if (v === null || v === void 0) {
+			nulls++;
+			continue;
+		}
+		if (typeof v !== "object") throw new Error("geospatial column expects GeoJSON geometries");
+		partial = extendBoundsFromGeometry(partial, v);
+	}
+	const result = {
+		value_count: BigInt(records.length),
+		null_count: nulls
+	};
+	const { xmin, ymin, xmax, ymax, zmin, zmax, mmin, mmax } = partial ?? {};
+	if (xmin === void 0 || ymin === void 0 || xmax === void 0 || ymax === void 0) return result;
+	const hasZ = zmin !== void 0;
+	const hasM = mmin !== void 0;
+	return {
+		...result,
+		lower: encodeGeoPoint(xmin, ymin, zmin, mmin, hasZ, hasM),
+		upper: encodeGeoPoint(xmax, ymax, zmax, mmax, hasZ, hasM)
+	};
+}
+function extendBoundsFromGeometry(bbox, geometry) {
+	if (geometry.type === "GeometryCollection") {
+		for (const child of geometry.geometries || []) bbox = extendBoundsFromGeometry(bbox, child);
+		return bbox;
+	}
+	return extendBoundsFromCoordinates(bbox, geometry.coordinates);
+}
+function extendBoundsFromCoordinates(bbox, coordinates) {
+	if (typeof coordinates[0] === "number") {
+		bbox = updateAxis(bbox, "xmin", "xmax", coordinates[0]);
+		bbox = updateAxis(bbox, "ymin", "ymax", coordinates[1]);
+		if (coordinates.length > 2) bbox = updateAxis(bbox, "zmin", "zmax", coordinates[2]);
+		if (coordinates.length > 3) bbox = updateAxis(bbox, "mmin", "mmax", coordinates[3]);
+		return bbox;
+	}
+	for (const child of coordinates) bbox = extendBoundsFromCoordinates(bbox, child);
+	return bbox;
+}
+function updateAxis(bbox, minKey, maxKey, value) {
+	if (value === void 0 || !Number.isFinite(value)) return bbox;
+	if (!bbox) bbox = {};
+	const min = bbox[minKey];
+	const max = bbox[maxKey];
+	if (min === void 0 || value < min) bbox[minKey] = value;
+	if (max === void 0 || value > max) bbox[maxKey] = value;
+	return bbox;
+}
+function encodeGeoPoint(x, y, z, m, hasZ, hasM) {
+	const len = !hasZ && !hasM ? 16 : hasZ && !hasM ? 24 : 32;
+	const buf = new ArrayBuffer(len);
+	const view = new DataView(buf);
+	view.setFloat64(0, x, true);
+	view.setFloat64(8, y, true);
+	if (len === 24) view.setFloat64(16, z, true);
+	else if (len === 32) {
+		view.setFloat64(16, hasZ ? z : NaN, true);
+		view.setFloat64(24, m, true);
+	}
+	return new Uint8Array(buf);
+}
+function serializeValue(value, type) {
+	const name = typeName(type);
+	if (name.startsWith("decimal(")) {
+		const m = /^decimal\((\d+),\s*(\d+)\)$/.exec(name);
+		if (!m) return void 0;
+		const scale = parseInt(m[2], 10);
+		if (typeof value !== "number" && typeof value !== "bigint") return void 0;
+		const factor = 10n ** BigInt(scale);
+		return twosComplementMinBigEndian(typeof value === "bigint" ? value * factor : BigInt(Math.round(value * Number(factor))));
+	}
+	if (name.startsWith("fixed[")) return value instanceof Uint8Array ? value : void 0;
+	switch (name) {
+		case "boolean": return new Uint8Array([value ? 1 : 0]);
+		case "int": {
+			const buf = /* @__PURE__ */ new ArrayBuffer(4);
+			new DataView(buf).setInt32(0, value, true);
+			return new Uint8Array(buf);
+		}
+		case "long": {
+			const buf = /* @__PURE__ */ new ArrayBuffer(8);
+			new DataView(buf).setBigInt64(0, typeof value === "bigint" ? value : BigInt(value), true);
+			return new Uint8Array(buf);
+		}
+		case "float": {
+			const buf = /* @__PURE__ */ new ArrayBuffer(4);
+			new DataView(buf).setFloat32(0, value, true);
+			return new Uint8Array(buf);
+		}
+		case "double": {
+			const buf = /* @__PURE__ */ new ArrayBuffer(8);
+			new DataView(buf).setFloat64(0, value, true);
+			return new Uint8Array(buf);
+		}
+		case "date": {
+			const days = value instanceof Date ? Math.floor(value.getTime() / 864e5) : Number(value);
+			const buf = /* @__PURE__ */ new ArrayBuffer(4);
+			new DataView(buf).setInt32(0, days, true);
+			return new Uint8Array(buf);
+		}
+		case "time": {
+			const buf = /* @__PURE__ */ new ArrayBuffer(8);
+			new DataView(buf).setBigInt64(0, typeof value === "bigint" ? value : BigInt(value), true);
+			return new Uint8Array(buf);
+		}
+		case "timestamp":
+		case "timestamptz": {
+			const buf = /* @__PURE__ */ new ArrayBuffer(8);
+			new DataView(buf).setBigInt64(0, timestampToMicros(value), true);
+			return new Uint8Array(buf);
+		}
+		case "timestamp_ns":
+		case "timestamptz_ns": {
+			const buf = /* @__PURE__ */ new ArrayBuffer(8);
+			new DataView(buf).setBigInt64(0, timestampToNanos(value), true);
+			return new Uint8Array(buf);
+		}
+		case "string": return new TextEncoder().encode(value);
+		case "binary": return value instanceof Uint8Array ? value : void 0;
+		case "uuid":
+			if (value instanceof Uint8Array && value.length === 16) return value;
+			if (typeof value === "string") return uuidStringToBytes(value);
+			return;
+		default: return;
+	}
+}
+function compare(a, b, type) {
+	switch (typeName(type)) {
+		case "boolean": return (a ? 1 : 0) - (b ? 1 : 0);
+		case "int": return a < b ? -1 : a > b ? 1 : 0;
+		case "float":
+		case "double": return compareFloating(a, b);
+		case "long": {
+			const ai = typeof a === "bigint" ? a : BigInt(a);
+			const bi = typeof b === "bigint" ? b : BigInt(b);
+			return ai < bi ? -1 : ai > bi ? 1 : 0;
+		}
+		case "date": {
+			const ad = dateToDays(a);
+			const bd = dateToDays(b);
+			if (Number.isNaN(ad) || Number.isNaN(bd)) return NaN;
+			return ad < bd ? -1 : ad > bd ? 1 : 0;
+		}
+		case "timestamp":
+		case "timestamptz": return compareBigInt(timestampToMicros(a), timestampToMicros(b));
+		case "timestamp_ns":
+		case "timestamptz_ns": return compareBigInt(timestampToNanos(a), timestampToNanos(b));
+		case "string": return a < b ? -1 : a > b ? 1 : 0;
+		case "binary":
+		case "uuid": return compareBytes(a, b);
+		default:
+			if (typeName(type).startsWith("fixed[")) return compareBytes(a, b);
+			return a < b ? -1 : a > b ? 1 : 0;
+	}
+}
+function compareFloating(a, b) {
+	if (Object.is(a, b)) return 0;
+	if (a === 0 && b === 0) return Object.is(a, -0) ? -1 : 1;
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+function compareBigInt(a, b) {
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+function dateToDays(value) {
+	if (value instanceof Date) return Math.floor(value.getTime() / 864e5);
+	if (typeof value === "bigint") return Number(value);
+	if (typeof value === "number") return value;
+	if (typeof value === "string") {
+		const ms = Date.parse(value);
+		return Number.isNaN(ms) ? NaN : Math.floor(ms / 864e5);
+	}
+	return NaN;
+}
+function timestampToMicros(value) {
+	return typeof value === "bigint" ? value : value instanceof Date ? BigInt(value.getTime()) * 1000n : BigInt(value);
+}
+function timestampToNanos(value) {
+	return typeof value === "bigint" ? value : value instanceof Date ? BigInt(value.getTime()) * 1000000n : BigInt(value);
+}
+function compareBytes(a, b) {
+	const len = Math.min(a.length, b.length);
+	for (let i = 0; i < len; i++) if (a[i] !== b[i]) return a[i] - b[i];
+	return a.length - b.length;
+}
+function twosComplementMinBigEndian(value) {
+	const bytes = [];
+	let v = value;
+	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 uuidStringToBytes(s) {
+	const hex = s.replace(/-/g, "");
+	if (hex.length !== 32) return void 0;
+	const out = new Uint8Array(16);
+	for (let i = 0; i < 16; i++) {
+		const byte = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+		if (Number.isNaN(byte)) return void 0;
+		out[i] = byte;
+	}
+	return out;
+}
+const TRUNCATE_LIMIT = 16;
+function computeColumnStats(records, schema) {
+	const value_counts = {};
+	const null_value_counts = {};
+	const nan_value_counts = {};
+	const lower_bounds = {};
+	const upper_bounds = {};
+	for (const field of schema.fields) {
+		const type = typeName(field.type);
+		if (type === "unknown") continue;
+		if (type === "list" || type === "map" || type === "struct") continue;
+		if (isGeoType(type)) {
+			const { value_count, null_count, lower, upper } = computeGeoBounds(records, field);
+			value_counts[field.id] = value_count;
+			null_value_counts[field.id] = null_count;
+			if (lower) lower_bounds[field.id] = lower;
+			if (upper) upper_bounds[field.id] = upper;
+			continue;
+		}
+		let nulls = 0n;
+		let nans = 0n;
+		let min;
+		let max;
+		const isFloat = type === "float" || type === "double";
+		const trackBounds = hasComparableBounds(field.type);
+		const writeDefault = field["write-default"];
+		for (const record of records) {
+			let v = record[field.name];
+			if (v === void 0 && writeDefault !== void 0) v = writeDefault;
+			if (v === null || v === void 0) {
+				nulls++;
+				continue;
+			}
+			if (isFloat && Number.isNaN(v)) {
+				nans++;
+				continue;
+			}
+			if (trackBounds) {
+				if (min === void 0 || compare(v, min, field.type) < 0) min = v;
+				if (max === void 0 || compare(v, max, field.type) > 0) max = v;
+			}
+		}
+		value_counts[field.id] = BigInt(records.length);
+		null_value_counts[field.id] = nulls;
+		if (isFloat) nan_value_counts[field.id] = nans;
+		if (min !== void 0) {
+			const lo = serializeValue(truncateLower(min, field.type), field.type);
+			if (lo) lower_bounds[field.id] = lo;
+		}
+		if (max !== void 0) {
+			const truncated = truncateUpper(max, field.type);
+			if (truncated !== void 0) {
+				const hi = serializeValue(truncated, field.type);
+				if (hi) upper_bounds[field.id] = hi;
+			}
+		}
+	}
+	return {
+		value_counts,
+		null_value_counts,
+		nan_value_counts,
+		lower_bounds,
+		upper_bounds
+	};
+}
+function hasComparableBounds(type) {
+	const name = typeName(type);
+	if (isGeoType(name)) return false;
+	return name !== "unknown" && name !== "variant";
+}
+function computeFieldSummary(values, type) {
+	const name = typeName(type);
+	const isFloat = name === "float" || name === "double";
+	const trackBounds = hasComparableBounds(type);
+	let containsNull = false;
+	let containsNan = false;
+	let min;
+	let max;
+	for (const v of values) {
+		if (v === null || v === void 0) {
+			containsNull = true;
+			continue;
+		}
+		if (isFloat && Number.isNaN(v)) {
+			containsNan = true;
+			continue;
+		}
+		if (trackBounds) {
+			if (min === void 0 || compare(v, min, type) < 0) min = v;
+			if (max === void 0 || compare(v, max, type) > 0) max = v;
+		}
+	}
+	const summary = { contains_null: containsNull };
+	if (isFloat) summary.contains_nan = containsNan;
+	if (min !== void 0) {
+		const lo = serializeValue(truncateLower(min, type), type);
+		if (lo) summary.lower_bound = lo;
+	}
+	if (max !== void 0) {
+		const truncated = truncateUpper(max, type);
+		if (truncated !== void 0) {
+			const hi = serializeValue(truncated, type);
+			if (hi) summary.upper_bound = hi;
+		}
+	}
+	return summary;
+}
+function truncateLower(value, type) {
+	const name = typeName(type);
+	if (name === "string" && typeof value === "string") {
+		const cps = Array.from(value);
+		if (cps.length <= TRUNCATE_LIMIT) return value;
+		return cps.slice(0, TRUNCATE_LIMIT).join("");
+	}
+	if ((name === "binary" || name.startsWith("fixed[")) && value instanceof Uint8Array) {
+		if (value.length <= TRUNCATE_LIMIT) return value;
+		return value.slice(0, TRUNCATE_LIMIT);
+	}
+	return value;
+}
+function truncateUpper(value, type) {
+	const name = typeName(type);
+	if (name === "string" && typeof value === "string") {
+		const cps = Array.from(value);
+		if (cps.length <= TRUNCATE_LIMIT) return value;
+		const prefix = cps.slice(0, TRUNCATE_LIMIT);
+		while (prefix.length > 0) {
+			const cp = prefix[prefix.length - 1].codePointAt(0);
+			const next = cp + 1 === 55296 ? 57344 : cp + 1;
+			if (next <= 1114111) {
+				prefix[prefix.length - 1] = String.fromCodePoint(next);
+				return prefix.join("");
+			}
+			prefix.pop();
+		}
+		return;
+	}
+	if ((name === "binary" || name.startsWith("fixed[")) && value instanceof Uint8Array) {
+		if (value.length <= TRUNCATE_LIMIT) return value;
+		const prefix = value.slice(0, TRUNCATE_LIMIT);
+		for (let i = prefix.length - 1; i >= 0; i--) if (prefix[i] < 255) {
+			const out = prefix.slice(0, i + 1);
+			out[i]++;
+			return out;
+		}
+		return;
+	}
+	return value;
+}
+function currentSnapshot(metadata) {
+	const id = metadata["current-snapshot-id"];
+	if (id === void 0) return void 0;
+	return metadata.snapshots?.find((s) => s["snapshot-id"] === id);
+}
+async function loadPriorManifests(metadata, resolver) {
+	const snap = currentSnapshot(metadata);
+	if (!snap?.["manifest-list"]) return [];
+	return await fetchAvroRecords(snap["manifest-list"], resolver);
+}
+async function buildSnapshotUpdate({ tableUrl, metadata, resolver, snapshotId, sequenceNumber, manifestUuid, timestampMs, formatVersion, newManifests, summary, writtenFiles, priorManifests, skipPriorManifestPaths }) {
+	const writerFn = resolver.writer;
+	if (!writerFn) throw new Error("resolver.writer is required");
+	const rowLineage = formatVersion >= 3;
+	const firstRowId = rowLineage ? BigInt(metadata["next-row-id"] ?? 0) : 0n;
+	priorManifests ??= await loadPriorManifests(metadata, resolver);
+	if (skipPriorManifestPaths?.size) priorManifests = priorManifests.filter((manifest) => !skipPriorManifestPaths.has(manifest.manifest_path));
+	const allManifests = [...priorManifests, ...newManifests];
+	const addedRows = rowLineage ? assignFirstRowIds$1(allManifests, firstRowId) : 0n;
+	const manifestListPath = `${tableUrl}/metadata/snap-${snapshotId}-1-${manifestUuid}.avro`;
+	await writeManifestList({
+		writer: writerFn(manifestListPath),
+		snapshotId,
+		sequenceNumber,
+		manifests: allManifests,
+		formatVersion
+	});
+	const snapshot = {
+		"snapshot-id": Number(snapshotId),
+		"sequence-number": Number(sequenceNumber),
+		"timestamp-ms": timestampMs,
+		"manifest-list": manifestListPath,
+		summary,
+		"schema-id": metadata["current-schema-id"]
+	};
+	if (rowLineage) {
+		snapshot["first-row-id"] = toMetadataLong(firstRowId);
+		snapshot["added-rows"] = toMetadataLong(addedRows);
+	}
+	const rawCurrentSnapshotId = metadata["current-snapshot-id"];
+	const currentSnapshotId = rawCurrentSnapshotId === void 0 || rawCurrentSnapshotId === null || rawCurrentSnapshotId === -1 ? null : rawCurrentSnapshotId;
+	if (currentSnapshotId !== null) snapshot["parent-snapshot-id"] = currentSnapshotId;
+	const requirements = [{
+		type: "assert-table-uuid",
+		uuid: metadata["table-uuid"]
+	}, {
+		type: "assert-ref-snapshot-id",
+		ref: "main",
+		"snapshot-id": currentSnapshotId
+	}];
+	if (rowLineage) requirements.push({
+		type: "assert-next-row-id",
+		"next-row-id": toMetadataLong(metadata["next-row-id"] ?? 0)
+	});
+	return {
+		snapshot,
+		requirements,
+		updates: [{
+			action: "add-snapshot",
+			snapshot
+		}, {
+			action: "set-snapshot-ref",
+			"ref-name": "main",
+			type: "branch",
+			"snapshot-id": snapshot["snapshot-id"]
+		}],
+		writtenFiles: [...writtenFiles, manifestListPath]
+	};
+}
+function buildPartitionSummaries(partitions, schema, partitionSpec) {
+	return partitionSpec.fields.map((pf) => {
+		const sourceField = schema.fields.find((f) => f.id === pf["source-id"]);
+		if (!sourceField) throw new Error(`partition source field id ${pf["source-id"]} not found`);
+		const resultType = transformResultType(pf.transform, sourceField.type);
+		return computeFieldSummary(partitions.map((p) => p[pf.name]), resultType);
+	});
+}
+function assignFirstRowIds$1(manifests, firstRowId) {
+	let nextFirstRowId = firstRowId;
+	let assignedRows = 0n;
+	for (const manifest of manifests) {
+		if (manifest.content !== 0) {
+			manifest.first_row_id = void 0;
+			continue;
+		}
+		const rowIdRange = BigInt(manifest.added_rows_count ?? 0) + BigInt(manifest.existing_rows_count ?? 0);
+		if (manifest.first_row_id == null) {
+			manifest.first_row_id = nextFirstRowId;
+			nextFirstRowId += rowIdRange;
+			assignedRows += rowIdRange;
+		} else {
+			const manifestEnd = BigInt(manifest.first_row_id) + rowIdRange;
+			if (manifestEnd > nextFirstRowId) nextFirstRowId = manifestEnd;
+		}
+	}
+	return assignedRows;
+}
+function toMetadataLong(value) {
+	const out = Number(value);
+	if (!Number.isSafeInteger(out)) throw new Error(`metadata long exceeds JavaScript safe integer range: ${value}`);
+	return out;
+}
+function writeParquet({ writer, schema, records, codec }) {
+	const columnData = [];
+	const parquetFields = [];
+	let rootChildren = 0;
+	for (const field of schema.fields) {
+		const name = sanitize(field.name);
+		const fieldElements = icebergTypeToParquetFields(name, field.type, field.required, field.id);
+		if (!fieldElements.length) continue;
+		columnData.push({
+			name,
+			data: extractColumn(records, field)
+		});
+		parquetFields.push(...fieldElements);
+		rootChildren++;
+	}
+	return parquetWrite({
+		writer,
+		columnData,
+		schema: [{
+			name: "root",
+			num_children: rootChildren
+		}, ...parquetFields],
+		kvMetadata: [{
+			key: "iceberg.schema",
+			value: JSON.stringify(schema)
+		}],
+		codec
+	});
+}
+function extractColumn(records, field) {
+	const out = new Array(records.length);
+	for (let i = 0; i < records.length; i++) out[i] = materializeFieldValue(records[i][field.name], field);
+	return out;
+}
+function materializeFieldValue(value, field) {
+	const writeDefault = field["write-default"];
+	return materializeNestedDefaults(value !== void 0 ? value : writeDefault !== void 0 ? writeDefault : null, field.type);
+}
+function materializeNestedDefaults(value, type) {
+	if (value === null || value === void 0 || typeof type !== "object") return value;
+	if (type.type === "struct") {
+		if (typeof value !== "object" || Array.isArray(value)) return value;
+		const out = { ...value };
+		for (const child of type.fields) out[child.name] = materializeFieldValue(value[child.name], child);
+		return out;
+	}
+	if (type.type === "list") {
+		if (!Array.isArray(value)) return value;
+		return value.map((v) => materializeNestedDefaults(v, type.element));
+	}
+	if (type.type === "map") return materializeMapDefaults(value, type);
+	return value;
+}
+function materializeMapDefaults(value, type) {
+	if (typeof type.key !== "object" && typeof type.value !== "object") return value;
+	if (value instanceof Map) return Array.from(value.entries(), ([key, entryValue]) => ({
+		key: materializeNestedDefaults(key, type.key),
+		value: materializeNestedDefaults(entryValue, type.value)
+	}));
+	if (Array.isArray(value)) return value.map((entry) => {
+		if (entry && typeof entry === "object" && "key" in entry && "value" in entry) return {
+			key: materializeNestedDefaults(entry.key, type.key),
+			value: materializeNestedDefaults(entry.value, type.value)
+		};
+		if (Array.isArray(entry) && entry.length === 2) return {
+			key: materializeNestedDefaults(entry[0], type.key),
+			value: materializeNestedDefaults(entry[1], type.value)
+		};
+		return entry;
+	});
+	if (typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key, entryValue]) => [key, materializeNestedDefaults(entryValue, type.value)]));
+	return value;
+}
+function icebergTypeToParquetFields(name, type, required, fieldId) {
+	const repetition_type = required ? "REQUIRED" : "OPTIONAL";
+	if (typeof type === "object") {
+		if (type.type === "list") {
+			const elementFields = icebergTypeToParquetFields("element", type.element, type["element-required"], type["element-id"]);
+			if (!elementFields.length) throw new Error(`unsupported iceberg list element type: ${typeName(type.element)}`);
+			return [
+				{
+					name,
+					converted_type: "LIST",
+					logical_type: { type: "LIST" },
+					repetition_type,
+					num_children: 1,
+					field_id: fieldId
+				},
+				{
+					name: "list",
+					repetition_type: "REPEATED",
+					num_children: 1
+				},
+				...elementFields
+			];
+		}
+		if (type.type === "struct") {
+			const allChildren = [];
+			let directChildren = 0;
+			for (const child of type.fields) {
+				const sub = icebergTypeToParquetFields(child.name, child.type, child.required, child.id);
+				if (!sub.length) continue;
+				allChildren.push(...sub);
+				directChildren++;
+			}
+			if (!directChildren) throw new Error(`struct ${name} has no writable children`);
+			return [{
+				name,
+				repetition_type,
+				num_children: directChildren,
+				field_id: fieldId
+			}, ...allChildren];
+		}
+		if (type.type === "map") {
+			if (type.key !== "string" && type.key !== "int") throw new Error(`unsupported iceberg map key type: ${typeName(type.key)}`);
+			const keyFields = icebergTypeToParquetFields("key", type.key, true, type["key-id"]);
+			const valueFields = icebergTypeToParquetFields("value", type.value, type["value-required"], type["value-id"]);
+			if (!keyFields.length) throw new Error(`unsupported iceberg map key type: ${typeName(type.key)}`);
+			if (!valueFields.length) throw new Error(`unsupported iceberg map value type: ${typeName(type.value)}`);
+			return [
+				{
+					name,
+					converted_type: "MAP",
+					logical_type: { type: "MAP" },
+					repetition_type,
+					num_children: 1,
+					field_id: fieldId
+				},
+				{
+					name: "key_value",
+					repetition_type: "REPEATED",
+					num_children: 2
+				},
+				...keyFields,
+				...valueFields
+			];
+		}
+		throw new Error(`unsupported iceberg nested type: ${JSON.stringify(type)}`);
+	}
+	if (type.startsWith("geometry")) return [{
+		name,
+		type: "BYTE_ARRAY",
+		logical_type: { type: "GEOMETRY" },
+		repetition_type,
+		field_id: fieldId
+	}];
+	if (type.startsWith("geography")) return [{
+		name,
+		type: "BYTE_ARRAY",
+		logical_type: { type: "GEOGRAPHY" },
+		repetition_type,
+		field_id: fieldId
+	}];
+	const decimal = parseDecimalType(type);
+	if (decimal) {
+		const { precision, scale } = decimal;
+		return [{
+			name,
+			type: "FIXED_LEN_BYTE_ARRAY",
+			type_length: decimalRequiredBytes(precision),
+			converted_type: "DECIMAL",
+			logical_type: {
+				type: "DECIMAL",
+				precision,
+				scale
+			},
+			precision,
+			scale,
+			repetition_type,
+			field_id: fieldId
+		}];
+	}
+	const fixedLen = parseFixedType(type);
+	if (fixedLen !== void 0) return [{
+		name,
+		type: "FIXED_LEN_BYTE_ARRAY",
+		type_length: fixedLen,
+		repetition_type,
+		field_id: fieldId
+	}];
+	switch (type) {
+		case "unknown":
+			if (required) throw new Error("unsupported required iceberg type: unknown");
+			return [];
+		case "variant": return [
+			{
+				name,
+				repetition_type,
+				num_children: 2,
+				logical_type: { type: "VARIANT" },
+				field_id: fieldId
+			},
+			{
+				name: "metadata",
+				type: "BYTE_ARRAY",
+				repetition_type: "REQUIRED"
+			},
+			{
+				name: "value",
+				type: "BYTE_ARRAY",
+				repetition_type: "OPTIONAL"
+			}
+		];
+		case "boolean": return [{
+			name,
+			type: "BOOLEAN",
+			repetition_type,
+			field_id: fieldId
+		}];
+		case "int": return [{
+			name,
+			type: "INT32",
+			repetition_type,
+			field_id: fieldId
+		}];
+		case "long": return [{
+			name,
+			type: "INT64",
+			repetition_type,
+			field_id: fieldId
+		}];
+		case "float": return [{
+			name,
+			type: "FLOAT",
+			repetition_type,
+			field_id: fieldId
+		}];
+		case "double": return [{
+			name,
+			type: "DOUBLE",
+			repetition_type,
+			field_id: fieldId
+		}];
+		case "string": return [{
+			name,
+			type: "BYTE_ARRAY",
+			converted_type: "UTF8",
+			repetition_type,
+			field_id: fieldId
+		}];
+		case "binary": return [{
+			name,
+			type: "BYTE_ARRAY",
+			repetition_type,
+			field_id: fieldId
+		}];
+		case "uuid": return [{
+			name,
+			type: "FIXED_LEN_BYTE_ARRAY",
+			type_length: 16,
+			logical_type: { type: "UUID" },
+			repetition_type,
+			field_id: fieldId
+		}];
+		case "date": return [{
+			name,
+			type: "INT32",
+			converted_type: "DATE",
+			logical_type: { type: "DATE" },
+			repetition_type,
+			field_id: fieldId
+		}];
+		case "time": return [{
+			name,
+			type: "INT64",
+			converted_type: "TIME_MICROS",
+			logical_type: {
+				type: "TIME",
+				isAdjustedToUTC: false,
+				unit: "MICROS"
+			},
+			repetition_type,
+			field_id: fieldId
+		}];
+		case "timestamp": return [timestampField(name, repetition_type, false, "MICROS", fieldId)];
+		case "timestamptz": return [timestampField(name, repetition_type, true, "MICROS", fieldId)];
+		case "timestamp_ns": return [timestampField(name, repetition_type, false, "NANOS", fieldId)];
+		case "timestamptz_ns": return [timestampField(name, repetition_type, true, "NANOS", fieldId)];
+		default: throw new Error(`unsupported iceberg type: ${type}`);
+	}
+}
+function parseFixedType(type) {
+	const m = /^fixed\[(\d+)\]$/.exec(type);
+	if (!m) return void 0;
+	return parseInt(m[1], 10);
+}
+function timestampField(name, repetition_type, isAdjustedToUTC, unit, field_id) {
+	return {
+		name,
+		type: "INT64",
+		logical_type: {
+			type: "TIMESTAMP",
+			isAdjustedToUTC,
+			unit
+		},
+		repetition_type,
+		field_id
+	};
+}
+function buildSortComparator(sortOrder, schema) {
+	if (!sortOrder?.fields?.length) return void 0;
+	const fields = sortOrder.fields.map((sf) => {
+		const sourceId = sf["source-id"] ?? sf["source-ids"]?.[0];
+		const sourceField = schema.fields.find((f) => f.id === sourceId);
+		if (!sourceField) throw new Error(`sort source field id ${sourceId} not found in schema`);
+		return {
+			name: sourceField.name,
+			transform: sf.transform,
+			sourceType: sourceField.type,
+			resultType: transformResultType(sf.transform, sourceField.type),
+			desc: sf.direction === "desc",
+			nullsFirst: sf["null-order"] === "nulls-first"
+		};
+	});
+	return (a, b) => {
+		for (const f of fields) {
+			const c = compareKeys(sortKey(a[f.name], f.transform, f.sourceType), sortKey(b[f.name], f.transform, f.sourceType), f.resultType, f.desc, f.nullsFirst);
+			if (c !== 0) return c;
+		}
+		return 0;
+	};
+}
+function sortKey(value, transform, sourceType) {
+	if (value === null || value === void 0) return null;
+	if (transform === "identity") return value;
+	return applyTransform(transform, value, sourceType);
+}
+function compareKeys(ka, kb, resultType, desc, nullsFirst) {
+	const aNull = ka === null || ka === void 0;
+	const bNull = kb === null || kb === void 0;
+	if (aNull && bNull) return 0;
+	if (aNull) return nullsFirst ? -1 : 1;
+	if (bNull) return nullsFirst ? 1 : -1;
+	const aNaN = typeof ka === "number" && Number.isNaN(ka);
+	const bNaN = typeof kb === "number" && Number.isNaN(kb);
+	if (aNaN || bNaN) {
+		if (aNaN && bNaN) return 0;
+		const c = aNaN ? 1 : -1;
+		return desc ? -c : c;
+	}
+	const c = compare(ka, kb, resultType);
+	return desc ? -c : c;
+}
+async function prepareAppend({ tableUrl, metadata, records, resolver, sortOrderId }) {
+	if (!tableUrl) throw new Error("tableUrl is required");
+	if (!resolver?.writer) throw new Error("resolver.writer is required");
+	const writerFn = resolver.writer;
+	if (metadata["format-version"] !== 2 && metadata["format-version"] !== 3) throw new Error(`unsupported format-version: ${metadata["format-version"]}`);
+	const formatVersion = metadata["format-version"];
+	const partitionSpec = metadata["partition-specs"].find((s) => s["spec-id"] === metadata["default-spec-id"]);
+	if (!partitionSpec) throw new Error("default partition spec not found in metadata");
+	const schema = metadata.schemas.find((s) => s["schema-id"] === metadata["current-schema-id"]);
+	if (!schema) throw new Error("current schema not found in metadata");
+	validateSchemaForVersion(schema, formatVersion);
+	const snapshotId = newSnapshotId(metadata);
+	const manifestUuid = uuid4();
+	checkWriteFormat(metadata.properties?.["write.format.default"]);
+	const codec = resolveParquetCodec(metadata.properties?.["write.parquet.compression-codec"]);
+	const orderId = sortOrderId ?? metadata["default-sort-order-id"] ?? 0;
+	const sortOrder = (metadata["sort-orders"] ?? []).find((o) => o["order-id"] === orderId);
+	if (sortOrderId !== void 0 && !sortOrder) throw new Error(`sort order ${sortOrderId} not found in metadata`);
+	const comparator = buildSortComparator(sortOrder, schema);
+	const appliedSortOrderId = comparator ? orderId : 0;
+	const groups = partitionSpec.fields.length ? groupByPartition(records, schema, partitionSpec) : [{
+		partition: {},
+		records
+	}];
+	const writtenDataFiles = await Promise.all(groups.map(async (group) => {
+		const sortedRecords = comparator ? [...group.records].sort(comparator) : group.records;
+		const dataPath = `${tableUrl}/data/${uuid4()}.parquet`;
+		const dataWriter = writerFn(dataPath);
+		await writeParquet({
+			writer: dataWriter,
+			schema,
+			records: sortedRecords,
+			codec
+		});
+		const stats = computeColumnStats(sortedRecords, schema);
+		return {
+			partition: group.partition,
+			records: sortedRecords,
+			dataFile: {
+				content: 0,
+				file_path: dataPath,
+				file_format: "parquet",
+				partition: group.partition,
+				record_count: BigInt(sortedRecords.length),
+				file_size_in_bytes: BigInt(dataWriter.offset),
+				value_counts: stats.value_counts,
+				null_value_counts: stats.null_value_counts,
+				nan_value_counts: stats.nan_value_counts,
+				lower_bounds: stats.lower_bounds,
+				upper_bounds: stats.upper_bounds,
+				sort_order_id: appliedSortOrderId
+			},
+			path: dataPath
+		};
+	}));
+	const manifestPath = `${tableUrl}/metadata/${manifestUuid}-m0.avro`;
+	const manifestWriter = writerFn(manifestPath);
+	await writeDataManifest({
+		writer: manifestWriter,
+		schema,
+		partitionSpec,
+		snapshotId,
+		dataFiles: writtenDataFiles.map((f) => f.dataFile),
+		formatVersion
+	});
+	const manifestLength = BigInt(manifestWriter.offset);
+	const addedRowCount = writtenDataFiles.reduce((sum, f) => sum + BigInt(f.records.length), 0n);
+	const addedFilesSize = writtenDataFiles.reduce((sum, f) => sum + f.dataFile.file_size_in_bytes, 0n);
+	const partitions = buildPartitionSummaries(writtenDataFiles.map((f) => f.dataFile.partition), schema, partitionSpec);
+	return {
+		snapshotId,
+		manifestUuid,
+		formatVersion,
+		manifestPath,
+		manifestLength,
+		partitionSpecId: partitionSpec["spec-id"],
+		partitions,
+		addedDataFilesCount: writtenDataFiles.length,
+		addedRowCount,
+		addedFilesSize,
+		recordsCount: records.length,
+		writtenFiles: [...writtenDataFiles.map((f) => f.path), manifestPath]
+	};
+}
+async function stageSnapshotForAppend({ tableUrl, metadata, prepared, resolver }) {
+	if (!tableUrl) throw new Error("tableUrl is required");
+	if (!resolver?.writer) throw new Error("resolver.writer is required");
+	const sequenceNumber = BigInt(metadata["last-sequence-number"] ?? 0) + 1n;
+	const timestampMs = Date.now();
+	const newManifest = {
+		manifest_path: prepared.manifestPath,
+		manifest_length: prepared.manifestLength,
+		partition_spec_id: prepared.partitionSpecId,
+		content: 0,
+		sequence_number: sequenceNumber,
+		min_sequence_number: sequenceNumber,
+		added_snapshot_id: prepared.snapshotId,
+		added_files_count: prepared.addedDataFilesCount,
+		existing_files_count: 0,
+		deleted_files_count: 0,
+		added_rows_count: prepared.addedRowCount,
+		existing_rows_count: 0n,
+		deleted_rows_count: 0n,
+		partitions: prepared.partitions
+	};
+	const prevSummary = currentSnapshot(metadata)?.summary;
+	const prevTotals = {
+		records: BigInt(prevSummary?.["total-records"] ?? "0"),
+		size: BigInt(prevSummary?.["total-files-size"] ?? "0"),
+		files: BigInt(prevSummary?.["total-data-files"] ?? "0")
+	};
+	const summary = {
+		operation: "append",
+		"added-data-files": String(prepared.addedDataFilesCount),
+		"added-records": String(prepared.recordsCount),
+		"added-files-size": String(prepared.addedFilesSize),
+		"changed-partition-count": String(prepared.addedDataFilesCount),
+		"total-records": String(prevTotals.records + BigInt(prepared.recordsCount)),
+		"total-files-size": String(prevTotals.size + prepared.addedFilesSize),
+		"total-data-files": String(prevTotals.files + BigInt(prepared.addedDataFilesCount)),
+		"total-delete-files": "0",
+		"total-position-deletes": "0",
+		"total-equality-deletes": "0"
+	};
+	return await buildSnapshotUpdate({
+		tableUrl,
+		metadata,
+		resolver,
+		snapshotId: prepared.snapshotId,
+		sequenceNumber,
+		manifestUuid: prepared.manifestUuid,
+		timestampMs,
+		formatVersion: prepared.formatVersion,
+		newManifests: [newManifest],
+		summary,
+		writtenFiles: []
+	});
+}
+function checkWriteFormat(value) {
+	if (value === void 0) return;
+	if (value.toLowerCase() !== "parquet") throw new Error(`unsupported write.format.default: ${value}`);
+}
+function resolveParquetCodec(value) {
+	if (value === void 0) return void 0;
+	switch (value.toLowerCase()) {
+		case "snappy": return "SNAPPY";
+		case "none":
+		case "uncompressed": return "UNCOMPRESSED";
+		default: throw new Error(`unsupported write.parquet.compression-codec: ${value}`);
+	}
+}
+function newSnapshotId(metadata) {
+	const used = new Set((metadata?.snapshots ?? []).map((s) => BigInt(s["snapshot-id"])));
+	const arr = new BigInt64Array(1);
+	for (let attempt = 0; attempt < 32; attempt++) {
+		globalThis.crypto.getRandomValues(arr);
+		const masked = arr[0] & 9007199254740991n;
+		const id = masked === 0n ? 1n : masked;
+		if (!used.has(id)) return id;
+	}
+	throw new Error("newSnapshotId: failed to find an unused id after 32 attempts");
+}
+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);
+}
+async function fetchManifests(manifests, resolver) {
+	return await Promise.all(manifests.map(async (manifest) => {
+		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
+		};
+	}));
+}
+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);
+		}
+	}
+}
+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 }) {
+	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")
+		})
+	});
+}
+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;
+}
+const enc = new TextEncoder();
+function s3SignedResolver({ accessKeyId, secretAccessKey, sessionToken, region, endpoint, pathStyle = false }) {
+	const ep = endpoint ? new URL(endpoint.replace(/\/$/, "") + "/") : void 0;
+	function toHttps(url) {
+		if (!url.startsWith("s3://") && !url.startsWith("s3a://")) return url;
+		const rest = url.slice(url.indexOf("://") + 3);
+		const slash = rest.indexOf("/");
+		if (slash === -1) throw new Error(`invalid S3 URL: ${url}`);
+		const bucket = rest.slice(0, slash);
+		const key = rest.slice(slash + 1);
+		if (ep) {
+			if (pathStyle) return `${ep.origin}${ep.pathname}${bucket}/${key}`;
+			return `${ep.protocol}//${bucket}.${ep.host}/${key}`;
+		}
+		return `https://${bucket}.s3.amazonaws.com/${key}`;
+	}
+	async function signRequest(method, url, body, extra = {}) {
+		const u = new URL(url);
+		const xAmzDate = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]|\.\d{3}/g, "");
+		const dStamp = xAmzDate.slice(0, 8);
+		const payloadHash = body !== void 0 ? await sha256hex(body) : await sha256hex("");
+		const lc = {};
+		for (const [k, v] of Object.entries(extra)) lc[k.toLowerCase()] = String(v);
+		lc["host"] = u.host;
+		lc["x-amz-date"] = xAmzDate;
+		lc["x-amz-content-sha256"] = payloadHash;
+		if (sessionToken) lc["x-amz-security-token"] = sessionToken;
+		const sortedKeys = Object.keys(lc).sort();
+		const canonicalHeaders = sortedKeys.map((k) => `${k}:${lc[k].trim().replace(/\s+/g, " ")}\n`).join("");
+		const signedHeaders = sortedKeys.join(";");
+		const canonicalRequest = [
+			method,
+			u.pathname.split("/").map((seg) => encodeRfc3986(decodeURIComponent(seg))).join("/"),
+			[...u.searchParams.entries()].sort((a, b) => {
+				if (a[0] !== b[0]) return a[0] < b[0] ? -1 : 1;
+				return a[1] < b[1] ? -1 : a[1] > b[1] ? 1 : 0;
+			}).map(([k, v]) => `${encodeRfc3986(k)}=${encodeRfc3986(v)}`).join("&"),
+			canonicalHeaders,
+			signedHeaders,
+			payloadHash
+		].join("\n");
+		const credentialScope = `${dStamp}/${region}/s3/aws4_request`;
+		const stringToSign = [
+			"AWS4-HMAC-SHA256",
+			xAmzDate,
+			credentialScope,
+			await sha256hex(canonicalRequest)
+		].join("\n");
+		const signature = bytesToHex(await hmac(await deriveSigningKey(secretAccessKey, dStamp, region, "s3"), stringToSign));
+		const out = {};
+		for (const [k, v] of Object.entries(lc)) {
+			if (k === "host") continue;
+			out[k] = v;
+		}
+		out["Authorization"] = `AWS4-HMAC-SHA256 Credential=${accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
+		return out;
+	}
+	return {
+		async reader(path, byteLength) {
+			const url = toHttps(path);
+			let len = byteLength;
+			if (len === void 0) {
+				const headers = await signRequest("HEAD", url);
+				const res = await fetch(url, {
+					method: "HEAD",
+					headers
+				});
+				if (!res.ok) throw new Error(`HEAD ${path}: ${res.status} ${res.statusText}`);
+				len = Number(res.headers.get("content-length"));
+				if (!Number.isFinite(len)) throw new Error(`HEAD ${path}: missing Content-Length`);
+			}
+			const fileLength = len;
+			return {
+				byteLength: fileLength,
+				async slice(start, end) {
+					const range = `bytes=${start}-${(end ?? fileLength) - 1}`;
+					const headers = await signRequest("GET", url, void 0, { range });
+					const res = await fetch(url, {
+						method: "GET",
+						headers
+					});
+					if (!res.ok) throw new Error(`GET ${path} ${range}: ${res.status} ${res.statusText}`);
+					return await res.arrayBuffer();
+				}
+			};
+		},
+		writer(path, options) {
+			const w = new ByteWriter();
+			w.finish = async function() {
+				const url = toHttps(path);
+				const body = w.getBytes().slice();
+				const extra = {};
+				if (options?.ifNoneMatch) extra["if-none-match"] = options.ifNoneMatch;
+				const headers = await signRequest("PUT", url, body, extra);
+				const res = await fetch(url, {
+					method: "PUT",
+					headers,
+					body
+				});
+				if (!res.ok) {
+					const err = /* @__PURE__ */ new Error(`PUT ${path}: ${res.status} ${res.statusText}`);
+					err.status = res.status;
+					throw err;
+				}
+			};
+			return w;
+		},
+		async deleter(path) {
+			const url = toHttps(path);
+			const headers = await signRequest("DELETE", url);
+			const res = await fetch(url, {
+				method: "DELETE",
+				headers
+			});
+			if (!res.ok && res.status !== 404) throw new Error(`DELETE ${path}: ${res.status} ${res.statusText}`);
+		}
+	};
+}
+async function sha256hex(data) {
+	const bytes = typeof data === "string" ? enc.encode(data) : data;
+	const hash = await crypto.subtle.digest("SHA-256", bytes);
+	return bytesToHex(new Uint8Array(hash));
+}
+async function hmac(key, data) {
+	const keyBytes = typeof key === "string" ? enc.encode(key) : key;
+	const dataBytes = typeof data === "string" ? enc.encode(data) : data;
+	const cryptoKey = await crypto.subtle.importKey("raw", keyBytes, {
+		name: "HMAC",
+		hash: "SHA-256"
+	}, false, ["sign"]);
+	const sig = await crypto.subtle.sign("HMAC", cryptoKey, dataBytes);
+	return new Uint8Array(sig);
+}
+async function deriveSigningKey(secret, dateStamp, region, service) {
+	return await hmac(await hmac(await hmac(await hmac(`AWS4${secret}`, dateStamp), region), service), "aws4_request");
+}
+function encodeRfc3986(str) {
+	return encodeURIComponent(str).replace(/[!*'()]/g, (c) => "%" + c.charCodeAt(0).toString(16).toUpperCase());
+}
+function bytesToHex(bytes) {
+	let s = "";
+	for (const b of bytes) s += b.toString(16).padStart(2, "0");
+	return s;
+}
+(() => {
+	if (typeof setImmediate === "function") return () => new Promise((resolve) => setImmediate(resolve));
+	if (typeof MessageChannel !== "undefined") {
+		const channel = new MessageChannel();
+		const queue = [];
+		channel.port1.onmessage = () => {
+			const resolve = queue.shift();
+			if (resolve) resolve();
+		};
+		return () => new Promise((resolve) => {
+			queue.push(resolve);
+			channel.port2.postMessage(0);
+		});
+	}
+	return () => new Promise((resolve) => setTimeout(resolve, 0));
+})();
+export { cachingResolver, icebergAppend, icebergCreateTable, icebergDropTable, icebergManifests, restCatalogConnect, restCatalogCreateNamespace, restCatalogListTables, restCatalogLoadTable, s3SignedResolver };