@gscdump/lakehouse 1.3.2 → 1.4.1

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

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

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

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

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

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

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

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

package/dist/node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/puffin/deletion-vector.mjs

@@ -0,0 +1,2 @@
+import "./roaring.mjs";
+export {};

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

@@ -0,0 +1,2 @@
+import "./deletion-vector.mjs";
+export {};

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

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

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

@@ -0,0 +1,9 @@
+import "../../../../hyparquet@1.26.2/node_modules/hyparquet/src/utils.mjs";
+import "../../../../hyparquet@1.26.2/node_modules/hyparquet/src/node.mjs";
+import "../../../../hyparquet-compressors@1.1.1/node_modules/hyparquet-compressors/src/index.mjs";
+import "./utils.mjs";
+import "./fetch.mjs";
+import "./metadata.mjs";
+import "./delete.mjs";
+import "./manifest.mjs";
+export {};

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

@@ -0,0 +1,91 @@
+import { ByteWriter } from "../../../../hyparquet-writer@0.16.1_patch_hash_7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/src/bytewriter.mjs";
+import "../../../../hyparquet-writer@0.16.1_patch_hash_7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/src/node.mjs";
+import { signRequest } from "./sigv4.mjs";
+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}`;
+		}
+		if (region && region !== "us-east-1" && region !== "auto") return `https://${bucket}.s3.${region}.amazonaws.com/${key}`;
+		return `https://${bucket}.s3.amazonaws.com/${key}`;
+	}
+	function signRequest$1(method, url, body, extra = {}) {
+		return signRequest(method, url, body, {
+			accessKeyId,
+			secretAccessKey,
+			sessionToken,
+			region,
+			service: "s3",
+			extraHeaders: extra
+		});
+	}
+	return {
+		async reader(path, byteLength) {
+			const url = toHttps(path);
+			let len = byteLength;
+			if (len === void 0) {
+				const headers = await signRequest$1("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$1("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$1("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$1("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}`);
+		}
+	};
+}
+export { s3SignedResolver };

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

@@ -0,0 +1,76 @@
+function validateSchemaForVersion(schema, formatVersion) {
+	for (const field of schema.fields) validateFieldForVersion(field, formatVersion, field.name);
+}
+function maxFieldId(fields = []) {
+	let max = 0;
+	for (const field of fields) {
+		if (max < field.id) max = field.id;
+		const nested = maxNestedFieldId(field.type);
+		if (max < nested) max = nested;
+	}
+	return max;
+}
+function maxNestedFieldId(type) {
+	if (typeof type === "string") return 0;
+	if (type.type === "list") {
+		const elementId = type["element-id"] ?? 0;
+		return Math.max(elementId, maxNestedFieldId(type.element));
+	}
+	if (type.type === "map") {
+		const keyId = type["key-id"] ?? 0;
+		const valueId = type["value-id"] ?? 0;
+		return Math.max(keyId, valueId, maxNestedFieldId(type.key), maxNestedFieldId(type.value));
+	}
+	if (type.type === "struct") return maxFieldId(type.fields);
+	return 0;
+}
+const MAX_USER_FIELD_ID = 2147483447;
+function validateFieldForVersion(field, formatVersion, path) {
+	if (typeof field.id === "number" && field.id > MAX_USER_FIELD_ID) throw new Error(`field id ${field.id} is in the reserved range (> ${MAX_USER_FIELD_ID}) (field: ${path})`);
+	if (formatVersion < 3) {
+		checkTypeForV2(field.type, path);
+		if (field["initial-default"] !== void 0) throw new Error(`initial-default requires format-version 3 (field: ${path})`);
+		if (field["write-default"] !== void 0) throw new Error(`write-default requires format-version 3 (field: ${path})`);
+	} else checkV3Default(field, path);
+	checkNestedFieldsForVersion(field.type, formatVersion, path);
+}
+function checkTypeForV2(type, path) {
+	if (typeof type === "string") {
+		if (type === "unknown" || type === "variant" || type === "timestamp_ns" || type === "timestamptz_ns" || type === "geometry" || type.startsWith("geometry(") || type === "geography" || type.startsWith("geography(")) throw new Error(`type ${type} requires format-version 3 (field: ${path})`);
+		return;
+	}
+	if (type.type === "struct") for (const f of type.fields) checkTypeForV2(f.type, `${path}.${f.name}`);
+	else if (type.type === "list") checkTypeForV2(type.element, `${path}.element`);
+	else if (type.type === "map") {
+		checkTypeForV2(type.key, `${path}.key`);
+		checkTypeForV2(type.value, `${path}.value`);
+	}
+}
+function checkV3Default(field, path) {
+	const type = typeName(field.type);
+	if (!requiresNullDefault(type)) return;
+	for (const key of ["initial-default", "write-default"]) if (field[key] != null) throw new Error(`${key} for field ${path} of type ${type} must default to null`);
+}
+function checkNestedFieldsForVersion(type, formatVersion, path) {
+	if (typeof type === "string") return;
+	if (type.type === "struct") for (const f of type.fields) validateFieldForVersion(f, formatVersion, `${path}.${f.name}`);
+	else if (type.type === "list") {
+		checkReservedFieldId(type["element-id"], `${path}.element`);
+		checkNestedFieldsForVersion(type.element, formatVersion, `${path}.element`);
+	} else if (type.type === "map") {
+		checkReservedFieldId(type["key-id"], `${path}.key`);
+		checkReservedFieldId(type["value-id"], `${path}.value`);
+		checkNestedFieldsForVersion(type.key, formatVersion, `${path}.key`);
+		checkNestedFieldsForVersion(type.value, formatVersion, `${path}.value`);
+	}
+}
+function checkReservedFieldId(id, path) {
+	if (typeof id === "number" && id > MAX_USER_FIELD_ID) throw new Error(`field id ${id} is in the reserved range (> ${MAX_USER_FIELD_ID}) (field: ${path})`);
+}
+function typeName(type) {
+	return typeof type === "string" ? type : type.type;
+}
+function requiresNullDefault(type) {
+	return type === "unknown" || type === "variant" || type === "geometry" || type.startsWith("geometry(") || type === "geography" || type.startsWith("geography(");
+}
+export { maxFieldId, typeName, validateSchemaForVersion };

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

@@ -0,0 +1,70 @@
+const enc = new TextEncoder();
+async function signRequest(method, url, body, { accessKeyId, secretAccessKey, sessionToken, region, service, extraHeaders = {} }) {
+	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(extraHeaders)) 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 doubleEncodePath = service !== "s3";
+	const canonicalRequest = [
+		method,
+		u.pathname.split("/").map((seg) => doubleEncodePath ? encodeRfc3986(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}/${service}/aws4_request`;
+	const stringToSign = [
+		"AWS4-HMAC-SHA256",
+		xAmzDate,
+		credentialScope,
+		await sha256hex(canonicalRequest)
+	].join("\n");
+	const signature = bytesToHex(await hmac(await deriveSigningKey(secretAccessKey, dStamp, region, service), 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;
+}
+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;
+}
+export { signRequest };

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

@@ -0,0 +1,8 @@
+import "../fetch.mjs";
+import "../metadata.mjs";
+import "../manifest.mjs";
+import "../read.mjs";
+import "../../../../../squirreling@0.15.0/node_modules/squirreling/src/index.mjs";
+import "../prune.mjs";
+import "./whereFilter.mjs";
+export {};

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

@@ -0,0 +1,5 @@
+import "../fetch.mjs";
+import "../catalog/loadTable.mjs";
+import "../../../../../squirreling@0.15.0/node_modules/squirreling/src/index.mjs";
+import "./icebergDataSource.mjs";
+export {};

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

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