@gscdump/lakehouse 1.4.0 → 1.4.2

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

@@ -0,0 +1,53 @@
+function readZigZag(reader) {
+	let result = 0;
+	let shift = 0;
+	while (true) {
+		const byte = reader.view.getUint8(reader.offset++);
+		result |= (byte & 127) << shift;
+		if (!(byte & 128)) return result >>> 1 ^ -(result & 1);
+		shift += 7;
+	}
+}
+function readZigZagBigInt(reader) {
+	let result = 0n;
+	let shift = 0n;
+	while (true) {
+		const byte = reader.view.getUint8(reader.offset++);
+		result |= BigInt(byte & 127) << shift;
+		if (!(byte & 128)) return result >> 1n ^ -(result & 1n);
+		shift += 7n;
+	}
+}
+function readAvroString(reader) {
+	const length = readZigZag(reader);
+	const bytes = new Uint8Array(reader.view.buffer, reader.view.byteOffset + reader.offset, length);
+	reader.offset += length;
+	return new TextDecoder().decode(bytes);
+}
+function avroMetadata(reader) {
+	if (reader.view.getUint32(reader.offset) !== 1331849729) throw new Error("avro invalid magic bytes");
+	reader.offset += 4;
+	const metadata = {};
+	let mapCount = readZigZag(reader);
+	while (mapCount !== 0) {
+		if (mapCount < 0) {
+			mapCount = -mapCount;
+			readZigZag(reader);
+		}
+		for (let i = 0; i < mapCount; i++) {
+			const key = readAvroString(reader);
+			metadata[key] = readAvroString(reader);
+		}
+		mapCount = readZigZag(reader);
+	}
+	metadata["avro.schema"] = JSON.parse(metadata["avro.schema"]);
+	if (metadata["schema"]) metadata["schema"] = JSON.parse(metadata["schema"]);
+	if (metadata["iceberg.schema"]) metadata["iceberg.schema"] = JSON.parse(metadata["iceberg.schema"]);
+	const syncMarker = new Uint8Array(reader.view.buffer, reader.view.byteOffset + reader.offset, 16);
+	reader.offset += 16;
+	return {
+		metadata,
+		syncMarker
+	};
+}
+export { avroMetadata, readZigZag, readZigZagBigInt };

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

@@ -0,0 +1,136 @@
+import { parseDecimal } from "../../../../../hyparquet@1.26.2/node_modules/hyparquet/src/convert.mjs";
+import { gunzip } from "../../../../../hyparquet-compressors@1.1.1/node_modules/hyparquet-compressors/src/gzip.mjs";
+import "../../../../../hyparquet-compressors@1.1.1/node_modules/hyparquet-compressors/src/index.mjs";
+import { readZigZag, readZigZagBigInt } from "./avro.metadata.mjs";
+function avroRead({ reader, metadata, syncMarker }) {
+	const blocks = [];
+	while (reader.offset < reader.view.byteLength) {
+		let recordCount = readZigZag(reader);
+		if (recordCount === 0) break;
+		if (recordCount < 0) recordCount = -recordCount;
+		const blockSize = readZigZag(reader);
+		let data = new Uint8Array(reader.view.buffer, reader.view.byteOffset + reader.offset, blockSize);
+		reader.offset += blockSize;
+		const blockSync = new Uint8Array(reader.view.buffer, reader.view.byteOffset + reader.offset, 16);
+		reader.offset += 16;
+		for (let i = 0; i < 16; i++) if (blockSync[i] !== syncMarker[i]) throw new Error("sync marker does not match");
+		const codec = metadata["avro.codec"];
+		if (codec === "deflate") data = gunzip(data);
+		else if (codec !== "null") throw new Error(`unsupported codec: ${codec}`);
+		const { fields } = metadata["avro.schema"];
+		const dataReader = {
+			view: new DataView(data.buffer, data.byteOffset, data.byteLength),
+			offset: 0
+		};
+		for (let i = 0; i < recordCount; i++) {
+			const obj = {};
+			for (const field of fields) {
+				const value = readType(dataReader, field.type);
+				obj[field.name] = value;
+			}
+			blocks.push(obj);
+		}
+	}
+	return blocks;
+}
+function readType(reader, type) {
+	if (type === "null") return;
+	else if (Array.isArray(type)) return readType(reader, type[readZigZag(reader)]);
+	else if (typeof type === "object" && type.type === "record") {
+		const obj = {};
+		for (const subField of type.fields) obj[subField.name] = readType(reader, subField.type);
+		return obj;
+	} else if (typeof type === "object" && type.type === "array") {
+		const arr = [];
+		while (true) {
+			let count = readZigZag(reader);
+			if (count === 0) break;
+			if (count < 0) {
+				count = -count;
+				readZigZag(reader);
+			}
+			for (let i = 0; i < count; i++) arr.push(readType(reader, type.items));
+		}
+		return arr;
+	} else if (typeof type === "object" && type.type === "map") {
+		const map = {};
+		while (true) {
+			let count = readZigZag(reader);
+			if (count === 0) break;
+			if (count < 0) {
+				count = -count;
+				readZigZag(reader);
+			}
+			for (let i = 0; i < count; i++) {
+				const key = readType(reader, "string");
+				map[key] = readType(reader, type.values);
+			}
+		}
+		return map;
+	} else if (typeof type === "object" && type.type === "enum") return type.symbols[readZigZag(reader)];
+	else if (typeof type === "object" && "logicalType" in type && type.logicalType) if (type.logicalType === "date" && type.type === "int") {
+		const value = readZigZag(reader);
+		return /* @__PURE__ */ new Date(value * 864e5);
+	} else if (type.logicalType === "time-millis" && type.type === "int") return readZigZag(reader);
+	else if (type.logicalType === "time-micros" && type.type === "long") return readZigZagBigInt(reader);
+	else if (type.logicalType === "timestamp-millis" && type.type === "long") {
+		const value = readZigZagBigInt(reader);
+		return new Date(Number(value));
+	} else if (type.logicalType === "timestamp-micros" && type.type === "long") {
+		const value = readZigZagBigInt(reader);
+		return new Date(Number(value / 1000n));
+	} else if (type.logicalType === "timestamp-nanos" && type.type === "long") {
+		const value = readZigZagBigInt(reader);
+		return new Date(Number(value / 1000000n));
+	} else if (type.logicalType === "decimal" && "precision" in type) {
+		const bytes = type.type === "fixed" ? readFixed(reader, type.size) : readType(reader, type.type);
+		const factor = 10 ** -(type.scale || 0);
+		return parseDecimal(bytes) * factor;
+	} else if (type.logicalType === "uuid" && type.type === "fixed" && type.size === 16) return bytesToUuid(readFixed(reader, 16));
+	else {
+		console.warn(`unknown logical type: ${type.logicalType}`);
+		return type.type === "fixed" ? readFixed(reader, type.size) : readType(reader, type.type);
+	}
+	else if (typeof type === "object" && type.type === "fixed") return readFixed(reader, type.size);
+	else if (type === "boolean") {
+		const value = reader.view.getUint8(reader.offset) === 1;
+		reader.offset++;
+		return value;
+	} else if (type === "int") return readZigZag(reader);
+	else if (type === "long") return readZigZagBigInt(reader);
+	else if (type === "float") {
+		const value = reader.view.getFloat32(reader.offset, true);
+		reader.offset += 4;
+		return value;
+	} else if (type === "double") {
+		const value = reader.view.getFloat64(reader.offset, true);
+		reader.offset += 8;
+		return value;
+	} else if (type === "bytes") {
+		const length = readZigZag(reader);
+		const bytes = new Uint8Array(reader.view.buffer, reader.view.byteOffset + reader.offset, length);
+		reader.offset += length;
+		return bytes;
+	} else if (type === "string") {
+		const length = readZigZag(reader);
+		const bytes = new Uint8Array(reader.view.buffer, reader.view.byteOffset + reader.offset, length);
+		const text = new TextDecoder().decode(bytes);
+		reader.offset += length;
+		return text;
+	} else if (typeof type === "object" && typeof type.type === "string") return readType(reader, type.type);
+	else throw new Error(`unsupported type: ${JSON.stringify(type)}`);
+}
+function readFixed(reader, size) {
+	const bytes = new Uint8Array(reader.view.buffer, reader.view.byteOffset + reader.offset, size);
+	reader.offset += size;
+	return bytes;
+}
+function bytesToUuid(bytes) {
+	let hex = "";
+	for (let i = 0; i < 16; i++) {
+		hex += bytes[i].toString(16).padStart(2, "0");
+		if (i === 3 || i === 5 || i === 7 || i === 9) hex += "-";
+	}
+	return hex;
+}
+export { avroRead };

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

@@ -0,0 +1,148 @@
+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";
+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 : "logicalType" in s && s.logicalType ? s.logicalType : s.type;
+			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(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(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);
+}
+export { avroWrite };

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

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

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

@@ -0,0 +1,48 @@
+import { restCatalogLoadTable } from "./rest.mjs";
+import { loadLatestFileCatalogMetadata, resolveMetadata } from "../metadata.mjs";
+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}`);
+}
+export { loadTable };

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

@@ -0,0 +1,159 @@
+import { parseIcebergJson, stringifyIcebergJson } from "../json.mjs";
+async function restCatalogConnect({ url, warehouse, requestInit, signRequest }) {
+	const base = url.replace(/\/$/, "");
+	const configUrl = warehouse ? `${base}/v1/config?warehouse=${encodeURIComponent(warehouse)}` : `${base}/v1/config`;
+	let init = requestInit;
+	if (signRequest) init = await signRequest(configUrl, init);
+	const res = await fetch(configUrl, init);
+	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 ?? "";
+	const ctx = {
+		type: "rest",
+		url: base,
+		prefix: typeof prefix === "string" ? prefix : "",
+		defaults,
+		overrides,
+		requestInit
+	};
+	if (signRequest) ctx.signRequest = signRequest;
+	return Object.freeze(ctx);
+}
+function restCatalogListTables(ctx, { namespace }) {
+	const ns = encodeNamespace(namespace);
+	return paginate({}, async (query) => {
+		const body = parseIcebergJson(await (await restFetch(ctx, `namespaces/${ns}/tables${query}`)).text());
+		return {
+			items: body.identifiers ?? [],
+			nextPageToken: body["next-page-token"]
+		};
+	});
+}
+async function restCatalogLoadTable(ctx, { namespace, table }) {
+	const body = parseIcebergJson(await (await restFetch(ctx, `namespaces/${encodeNamespace(namespace)}/tables/${encodeURIComponent(table)}`)).text());
+	return {
+		metadataLocation: body["metadata-location"],
+		metadata: body.metadata,
+		config: body.config ?? {}
+	};
+}
+async function restCatalogCreateTable(ctx, { namespace, table, schema, location, partitionSpec, writeOrder, stageCreate, properties }) {
+	const ns = encodeNamespace(namespace);
+	const body = {
+		name: table,
+		schema
+	};
+	if (location !== void 0) body.location = location;
+	if (partitionSpec !== void 0) body["partition-spec"] = partitionSpec;
+	if (writeOrder !== void 0) body["write-order"] = writeOrder;
+	if (stageCreate !== void 0) body["stage-create"] = stageCreate;
+	if (properties !== void 0) body.properties = properties;
+	const responseBody = parseIcebergJson(await (await restFetch(ctx, `namespaces/${ns}/tables`, {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: stringifyIcebergJson(body)
+	})).text());
+	return {
+		metadataLocation: responseBody["metadata-location"],
+		metadata: responseBody.metadata,
+		config: responseBody.config ?? {}
+	};
+}
+async function restCatalogUpdateTable(ctx, { namespace, table, requirements, updates }) {
+	const responseBody = parseIcebergJson(await (await restFetch(ctx, `namespaces/${encodeNamespace(namespace)}/tables/${encodeURIComponent(table)}`, {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: stringifyIcebergJson({
+			requirements,
+			updates
+		})
+	})).text());
+	return {
+		metadataLocation: responseBody["metadata-location"],
+		metadata: responseBody.metadata,
+		config: responseBody.config ?? {}
+	};
+}
+async function restCatalogDropTable(ctx, { namespace, table, purgeRequested }) {
+	await restFetch(ctx, `namespaces/${encodeNamespace(namespace)}/tables/${encodeURIComponent(table)}${purgeRequested ? "?purgeRequested=true" : ""}`, { method: "DELETE" });
+}
+async function restCatalogCreateNamespace(ctx, { namespace, properties }) {
+	const ns = Array.isArray(namespace) ? namespace : namespace.split(".");
+	const body = parseIcebergJson(await (await restFetch(ctx, "namespaces", {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: stringifyIcebergJson({
+			namespace: ns,
+			properties: properties ?? {}
+		})
+	})).text());
+	return {
+		namespace: body.namespace ?? ns,
+		properties: body.properties ?? {}
+	};
+}
+function encodeNamespace(namespace) {
+	return (Array.isArray(namespace) ? namespace : namespace.split(".")).map((p) => encodeURIComponent(p)).join("%1F");
+}
+async function restFetch(ctx, path, init) {
+	const prefixSegment = ctx.prefix ? `${ctx.prefix.replace(/^\/|\/$/g, "")}/` : "";
+	const fullUrl = `${ctx.url}/v1/${prefixSegment}${path}`;
+	let merged = mergeRequestInit(ctx.requestInit, init);
+	if (ctx.signRequest) merged = await ctx.signRequest(fullUrl, merged);
+	const res = await fetch(fullUrl, merged);
+	if (!res.ok) await throwRestError(res);
+	return res;
+}
+function mergeRequestInit(a, b) {
+	if (!a) return b;
+	if (!b) return a;
+	return {
+		...a,
+		...b,
+		headers: {
+			...headersToObject(a.headers),
+			...headersToObject(b.headers)
+		}
+	};
+}
+function headersToObject(h) {
+	if (!h) return {};
+	if (h instanceof Headers) {
+		const out = {};
+		h.forEach((v, k) => {
+			out[k] = v;
+		});
+		return out;
+	}
+	if (Array.isArray(h)) return Object.fromEntries(h);
+	return h;
+}
+async function throwRestError(res) {
+	let detail = "";
+	try {
+		const body = parseIcebergJson(await res.text());
+		if (body?.error) {
+			const { code, type, message } = body.error;
+			detail = `${code ?? res.status} ${type ?? ""}: ${message ?? ""}`.trim();
+		}
+	} catch {}
+	const err = new Error(detail || `${res.status} ${res.statusText}`);
+	err.status = res.status;
+	throw err;
+}
+async function paginate(baseParams, fetchPage) {
+	const out = [];
+	let pageToken;
+	while (true) {
+		const params = { ...baseParams };
+		if (pageToken) params.pageToken = pageToken;
+		const keys = Object.keys(params);
+		const { items, nextPageToken } = await fetchPage(keys.length ? "?" + keys.map((k) => `${k}=${params[k]}`).join("&") : "");
+		out.push(...items);
+		if (!nextPageToken) return out;
+		pageToken = encodeURIComponent(nextPageToken);
+	}
+}
+export { restCatalogConnect, restCatalogCreateNamespace, restCatalogCreateTable, restCatalogDropTable, restCatalogListTables, restCatalogLoadTable, restCatalogUpdateTable };

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

@@ -0,0 +1,67 @@
+import { stringifyIcebergJson } from "./json.mjs";
+import { uuid4 } from "./utils.mjs";
+import { maxFieldId, validateSchemaForVersion } from "./schema.mjs";
+import { validatePartitionSpecForWrite } from "./write/partition.mjs";
+async function icebergCreate({ tableUrl, resolver, schema, formatVersion, partitionSpec, sortOrder, properties, conditionalCommits }) {
+	if (!tableUrl) throw new Error("tableUrl is required");
+	if (formatVersion === void 0) {
+		const propVersion = properties?.["format-version"];
+		formatVersion = propVersion !== void 0 ? Number(propVersion) : 2;
+	}
+	if (formatVersion !== 2 && formatVersion !== 3) throw new Error(`unsupported format-version: ${formatVersion}`);
+	const metadataVersion = 1;
+	const metadataUrl = `${tableUrl}/metadata/v${metadataVersion}.metadata.json`;
+	const initialSchema = schema ?? {
+		type: "struct",
+		"schema-id": 0,
+		fields: []
+	};
+	validateSchemaForVersion(initialSchema, formatVersion);
+	const initialPartitionSpec = partitionSpec ?? {
+		"spec-id": 0,
+		fields: []
+	};
+	validatePartitionSpecForWrite(initialSchema, initialPartitionSpec);
+	const initialSortOrder = sortOrder ?? {
+		"order-id": 0,
+		fields: []
+	};
+	const metadata = {
+		"format-version": formatVersion,
+		"table-uuid": uuid4(),
+		location: tableUrl,
+		"last-sequence-number": 0,
+		"last-updated-ms": Date.now(),
+		"last-column-id": maxFieldId(initialSchema.fields),
+		"current-schema-id": initialSchema["schema-id"] ?? 0,
+		schemas: [initialSchema],
+		"default-spec-id": initialPartitionSpec["spec-id"],
+		"partition-specs": [initialPartitionSpec],
+		"last-partition-id": maxPartitionFieldId(initialPartitionSpec.fields),
+		"sort-orders": [initialSortOrder],
+		"default-sort-order-id": initialSortOrder["order-id"]
+	};
+	if (properties) metadata.properties = properties;
+	if (formatVersion >= 3) metadata["next-row-id"] = 0;
+	if (!resolver.writer) throw new Error("resolver.writer is required");
+	const metadataWriter = conditionalCommits ? resolver.writer(metadataUrl, { ifNoneMatch: "*" }) : resolver.writer(metadataUrl);
+	const metadataBytes = new TextEncoder().encode(stringifyIcebergJson(metadata));
+	metadataWriter.appendBytes(metadataBytes);
+	await metadataWriter.finish();
+	const versionHintUrl = `${tableUrl}/metadata/version-hint.text`;
+	try {
+		const versionHintWriter = resolver.writer(versionHintUrl);
+		const versionHintBytes = new TextEncoder().encode(String(metadataVersion));
+		versionHintWriter.appendBytes(versionHintBytes);
+		await versionHintWriter.finish();
+	} catch (err) {
+		if (!conditionalCommits) throw err;
+	}
+	return metadata;
+}
+function maxPartitionFieldId(partitionFields = []) {
+	let max = 0;
+	for (const pf of partitionFields) if (max < pf["field-id"]) max = pf["field-id"];
+	return max;
+}
+export { icebergCreate };

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

@@ -0,0 +1,34 @@
+import { valuesEqual } from "./utils.mjs";
+function deleteFileAppliesToDataEntry(dataEntry, deleteEntry, metadata, deleteType) {
+	const dataSequenceNumber = dataEntry.sequence_number;
+	const deleteSequenceNumber = deleteEntry.sequence_number;
+	if (dataSequenceNumber === void 0) throw new Error("data file missing sequence number");
+	if (deleteSequenceNumber === void 0) throw new Error("delete file missing sequence number");
+	if (deleteType === "equality") {
+		if (deleteSequenceNumber <= dataSequenceNumber) return false;
+		if (isUnpartitioned(metadata, deleteEntry.partition_spec_id)) return true;
+	} else if (deleteSequenceNumber < dataSequenceNumber) return false;
+	return samePartition(dataEntry, deleteEntry);
+}
+function isUnpartitioned(metadata, specId) {
+	return metadata["partition-specs"].find((s) => s["spec-id"] === specId)?.fields.length === 0;
+}
+function samePartition(dataEntry, deleteEntry) {
+	if (dataEntry.partition_spec_id !== deleteEntry.partition_spec_id) return false;
+	return partitionsEqual(dataEntry.data_file.partition, deleteEntry.data_file.partition);
+}
+function partitionsEqual(a, b) {
+	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 (!partitionValuesEqual(a[key], b[key])) return false;
+	}
+	return true;
+}
+function partitionValuesEqual(a, b) {
+	if (typeof a === "number" && typeof b === "number") return Object.is(a, b);
+	return valuesEqual(a, b);
+}
+export { deleteFileAppliesToDataEntry };