@gscdump/engine 0.33.10 → 0.35.2

package/dist/_chunks/libs/icebird.mjs

@@ -1,5 +1,5 @@
-import { asyncBufferFromUrl, cachedAsyncBuffer, parseDecimal } from "./hyparquet.mjs";
-import { ByteWriter, parquetWrite } from "./hyparquet-writer.mjs";
+import { asyncBufferFromUrl, parseDecimal } from "./hyparquet.mjs";
+import { ByteWriter } from "./hyparquet-writer.mjs";
 import { gunzip } from "./hyparquet-compressors.mjs";
 function readZigZag(reader) {
 	let result = 0;
@@ -167,24 +167,6 @@ function bytesToUuid(bytes) {
 	}
 	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) => {
@@ -243,92 +225,6 @@ function urlResolver({ requestInit } = {}) {
 		}
 	};
 }
-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);
@@ -499,182 +395,6 @@ function parseIcebergJson(text) {
 	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 {
@@ -705,39 +425,6 @@ async function restCatalogCreateTable(ctx, { namespace, table, schema, location,
 		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");
 }
@@ -786,64 +473,6 @@ async function throwRestError(res) {
 	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);
 }
@@ -937,46 +566,6 @@ function decimalRequiredBytes(precision) {
 	}
 	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 = /* @__PURE__ */ 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);
@@ -1011,130 +600,6 @@ function transformResultType(transform, sourceType) {
 		case "bucket": return "int";
 	}
 }
-function applyTransform(transform, value, sourceType) {
-	const parsed = parseTransform(transform);
-	validateTransformSource(parsed, sourceType);
-	if (value == null) return null;
-	switch (parsed.kind) {
-		case "identity": return value;
-		case "void": return null;
-		case "year": return yearTransform(value, sourceType);
-		case "month": return monthTransform(value, sourceType);
-		case "day": return dayTransform(value, sourceType);
-		case "hour": return hourTransform(value, sourceType);
-		case "bucket": return bucketTransform(value, sourceType, parsed.n);
-		case "truncate": return truncateTransform(value, sourceType, parsed.w);
-	}
-}
-function dateAsMillis(value, sourceType, transform) {
-	const t = typeName(sourceType);
-	validateTransformSource({ kind: transform }, sourceType);
-	if (value instanceof Date) return value.getTime();
-	const n = typeof value === "bigint" ? value : BigInt(value);
-	switch (t) {
-		case "date": return Number(n) * 864e5;
-		case "timestamp":
-		case "timestamptz": return Number(n / 1000n);
-		default: return Number(n / 1000000n);
-	}
-}
-function yearTransform(v, t) {
-	return new Date(dateAsMillis(v, t, "year")).getUTCFullYear() - 1970;
-}
-function monthTransform(v, t) {
-	const d = new Date(dateAsMillis(v, t, "month"));
-	return (d.getUTCFullYear() - 1970) * 12 + d.getUTCMonth();
-}
-function dayTransform(v, t) {
-	return Math.floor(dateAsMillis(v, t, "day") / 864e5);
-}
-function hourTransform(v, t) {
-	return Math.floor(dateAsMillis(v, t, "hour") / 36e5);
-}
-function bucketTransform(value, sourceType, n) {
-	return (murmur3_32(bucketBytes(value, sourceType), 0) & 2147483647) % n;
-}
-function bucketBytes(value, sourceType) {
-	const t = typeName(sourceType);
-	if (t.startsWith("decimal(")) return decimalToUnscaledBytes(value, t);
-	if (t === "uuid") return uuidToBytes(value, "uuid partition value");
-	if (t.startsWith("fixed[") || t === "binary" || t === "fixed") return value instanceof Uint8Array ? value : new Uint8Array(value);
-	switch (t) {
-		case "int":
-		case "long":
-		case "date":
-		case "time":
-		case "timestamp":
-		case "timestamptz":
-		case "timestamp_ns":
-		case "timestamptz_ns": {
-			let v;
-			if (t === "date") v = value instanceof Date ? BigInt(Math.floor(value.getTime() / 864e5)) : BigInt(value);
-			else if (t === "timestamp" || t === "timestamptz") v = value instanceof Date ? BigInt(value.getTime()) * 1000n : BigInt(value);
-			else if (t === "timestamp_ns" || t === "timestamptz_ns") v = value instanceof Date ? BigInt(value.getTime()) * 1000n : BigInt(value) / 1000n;
-			else v = typeof value === "bigint" ? value : BigInt(value);
-			const out = /* @__PURE__ */ new Uint8Array(8);
-			new DataView(out.buffer).setBigInt64(0, v, true);
-			return out;
-		}
-		case "string": return new TextEncoder().encode(String(value));
-		default: throw new Error(`bucket transform: unsupported source type ${t}`);
-	}
-}
-function decimalToUnscaledBytes(value, decimalType) {
-	const m = /^decimal\((\d+),\s*(\d+)\)$/.exec(decimalType);
-	if (!m) throw new Error(`bucket transform: invalid decimal type ${decimalType}`);
-	const scale = parseInt(m[2], 10);
-	const factor = 10n ** BigInt(scale);
-	const unscaled = typeof value === "bigint" ? value * factor : BigInt(Math.round(Number(value) * Number(factor)));
-	const bytes = [];
-	let v = unscaled;
-	while (true) {
-		const byte = Number(v & 255n);
-		bytes.unshift(byte);
-		v >>= 8n;
-		const sign = byte & 128;
-		if (!sign && v === 0n || sign && v === -1n) break;
-	}
-	return new Uint8Array(bytes);
-}
-function truncateTransform(value, sourceType, w) {
-	const t = typeName(sourceType);
-	if (t.startsWith("decimal(")) {
-		const m = /^decimal\((\d+),\s*(\d+)\)$/.exec(t);
-		if (!m) throw new Error(`truncate transform: invalid decimal type ${t}`);
-		const scale = parseInt(m[2], 10);
-		const factor = 10n ** BigInt(scale);
-		const unscaled = typeof value === "bigint" ? value * factor : BigInt(Math.round(Number(value) * Number(factor)));
-		const W = BigInt(w);
-		const truncated = unscaled - (unscaled % W + W) % W;
-		return Number(truncated) / Number(factor);
-	}
-	if (t === "binary") return (value instanceof Uint8Array ? value : new Uint8Array(value)).slice(0, w);
-	switch (t) {
-		case "int": {
-			const v = Number(value);
-			return v - (v % w + w) % w;
-		}
-		case "long": {
-			const W = BigInt(w);
-			const v = typeof value === "bigint" ? value : BigInt(value);
-			return v - (v % W + W) % W;
-		}
-		case "string": {
-			const s = String(value);
-			let count = 0;
-			let i = 0;
-			while (i < s.length && count < w) {
-				const code = s.codePointAt(i);
-				i += code > 65535 ? 2 : 1;
-				count++;
-			}
-			return s.slice(0, i);
-		}
-		default: throw new Error(`truncate transform: unsupported source type ${t}`);
-	}
-}
 function validateTransformSource(parsed, sourceType) {
 	const t = typeName(sourceType);
 	switch (parsed.kind) {
@@ -1158,80 +623,6 @@ function validateTransformSource(parsed, sourceType) {
 			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"];
@@ -1241,56 +632,6 @@ function validatePartitionSpecForWrite(schema, partitionSpec, label = "partition
 		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);
@@ -1353,21 +694,6 @@ function icebergTypeToAvro(type, fieldId) {
 		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) {
@@ -1430,1921 +756,56 @@ function maxPartitionFieldId(partitionFields = []) {
 	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"]
-			}];
+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;
 		}
-	} 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;
+		return keep;
+	});
+	return await fetchManifests(manifests, resolver);
 }
-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);
+const MANIFEST_FETCH_CONCURRENCY = 8;
+async function fetchOneManifest(manifest, resolver) {
+	const url = manifest.manifest_path;
+	const entries = await fetchAvroRecords(url, resolver, Number(manifest.manifest_length));
+	for (const entry of entries) {
+		entry.partition_spec_id = manifest.partition_spec_id ?? 0;
+		if (entry.sequence_number === void 0) entry.sequence_number = manifest.sequence_number ?? 0n;
+		if (entry.status === 1) {
+			if (entry.sequence_number === void 0) entry.sequence_number = manifest.sequence_number;
+			if (entry.file_sequence_number === void 0) entry.file_sequence_number = manifest.sequence_number;
+		} else if (entry.sequence_number === void 0 || entry.file_sequence_number === void 0) throw new Error("iceberg manifest entry missing sequence number");
 	}
+	assignFirstRowIds(manifest, entries);
+	return {
+		url,
+		entries
+	};
 }
-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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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, snapshotProperties }) {
-	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",
-		...snapshotProperties ?? {}
-	};
-	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 = /* @__PURE__ */ 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);
-}
-const MANIFEST_FETCH_CONCURRENCY = 8;
-async function fetchOneManifest(manifest, resolver) {
-	const url = manifest.manifest_path;
-	const entries = await fetchAvroRecords(url, resolver, Number(manifest.manifest_length));
-	for (const entry of entries) {
-		entry.partition_spec_id = manifest.partition_spec_id ?? 0;
-		if (entry.sequence_number === void 0) entry.sequence_number = manifest.sequence_number ?? 0n;
-		if (entry.status === 1) {
-			if (entry.sequence_number === void 0) entry.sequence_number = manifest.sequence_number;
-			if (entry.file_sequence_number === void 0) entry.file_sequence_number = manifest.sequence_number;
-		} else if (entry.sequence_number === void 0 || entry.file_sequence_number === void 0) throw new Error("iceberg manifest entry missing sequence number");
-	}
-	assignFirstRowIds(manifest, entries);
-	return {
-		url,
-		entries
-	};
-}
-async function fetchManifests(manifests, resolver) {
-	const results = new Array(manifests.length);
-	let next = 0;
-	async function worker() {
-		while (next < manifests.length) {
-			const i = next++;
-			results[i] = await fetchOneManifest(manifests[i], resolver);
-		}
+async function fetchManifests(manifests, resolver) {
+	const results = new Array(manifests.length);
+	let next = 0;
+	async function worker() {
+		while (next < manifests.length) {
+			const i = next++;
+			results[i] = await fetchOneManifest(manifests[i], resolver);
+		}
 	}
 	const poolSize = Math.min(MANIFEST_FETCH_CONCURRENCY, manifests.length);
 	const workers = [];
@@ -3364,44 +825,13 @@ function assignFirstRowIds(manifest, entries) {
 		}
 	}
 }
-const DEFAULT_RETRY = Object.freeze({
+Object.freeze({
 	maxAttempts: 50,
 	initialMs: 50,
 	maxMs: 3e3,
 	factor: 2,
 	totalTimeoutMs: 1800 * 1e3
 });
-async function icebergAppend({ catalog, namespace, table, tableUrl, resolver, records, sortOrderId, snapshotProperties }) {
-	const ctx = await loadTable({
-		catalog,
-		namespace,
-		table,
-		tableUrl,
-		resolver
-	});
-	const prepared = await prepareAppend({
-		tableUrl: ctx.tableUrl,
-		metadata: ctx.metadata,
-		records,
-		resolver: requireResolver(ctx.resolver, "icebergAppend"),
-		sortOrderId
-	});
-	return await commitWithRetry({
-		catalog,
-		target: {
-			namespace,
-			table
-		},
-		ctx,
-		stage: (workingCtx) => stageSnapshotForAppend({
-			tableUrl: workingCtx.tableUrl,
-			metadata: workingCtx.metadata,
-			prepared,
-			resolver: requireResolver(workingCtx.resolver, "icebergAppend"),
-			snapshotProperties
-		})
-	});
-}
 async function 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");
@@ -3430,280 +860,7 @@ async function icebergCreateTable({ catalog, namespace, table, tableUrl, schema,
 		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;
-}
+new TextEncoder();
 (() => {
 	if (typeof setImmediate === "function") return () => new Promise((resolve) => setImmediate(resolve));
 	if (typeof MessageChannel !== "undefined") {
@@ -3720,4 +877,4 @@ function bytesToHex(bytes) {
 	}
 	return () => new Promise((resolve) => setTimeout(resolve, 0));
 })();
-export { cachingResolver, icebergAppend, icebergCreateTable, icebergDropTable, icebergManifests, restCatalogConnect, restCatalogCreateNamespace, restCatalogListTables, restCatalogLoadTable, s3SignedResolver };
+export { icebergCreateTable, icebergManifests, restCatalogLoadTable };