@gscdump/lakehouse 1.4.0 → 1.4.1

package/dist/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/node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/catalog/file.mjs

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

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

@@ -0,0 +1,48 @@
+import { loadLatestFileCatalogMetadata, resolveMetadata } from "../metadata.mjs";
+import { restCatalogLoadTable } from "./rest.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/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/node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/create.mjs

@@ -0,0 +1,67 @@
+import { uuid4 } from "./utils.mjs";
+import { stringifyIcebergJson } from "./json.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/node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/delete.mjs

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

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

@@ -0,0 +1,162 @@
+import { asyncBufferFromUrl, cachedAsyncBuffer } from "../../../../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 { ByteWriter } from "../../../../hyparquet-writer@0.16.1_patch_hash_7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/src/bytewriter.mjs";
+import "../../../../hyparquet-writer@0.16.1_patch_hash_7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/src/node.mjs";
+import { avroMetadata } from "./avro/avro.metadata.mjs";
+import { avroRead } from "./avro/avro.read.mjs";
+import "./puffin/puffin.mjs";
+import "./utils.mjs";
+function translateS3Url(url) {
+	if (url.startsWith("s3a://") || url.startsWith("s3://")) {
+		const rest = url.slice(url.indexOf("://") + 3);
+		const slashIndex = rest.indexOf("/");
+		if (slashIndex === -1) throw new Error("Invalid S3 URL, missing \"/\" after bucket");
+		return `https://${rest.slice(0, slashIndex)}.s3.amazonaws.com${rest.slice(slashIndex)}`;
+	}
+	return url;
+}
+function urlResolver({ requestInit } = {}) {
+	return {
+		reader(url, byteLength) {
+			return asyncBufferFromUrl({
+				url: translateS3Url(url),
+				byteLength,
+				requestInit
+			});
+		},
+		writer(url, options) {
+			const w = new ByteWriter();
+			w.finish = async function() {
+				const target = translateS3Url(url);
+				const body = w.getBytes().slice();
+				const headers = {};
+				if (requestInit?.headers) new Headers(requestInit.headers).forEach((v, k) => {
+					headers[k] = v;
+				});
+				if (options?.ifNoneMatch) headers["If-None-Match"] = options.ifNoneMatch;
+				const res = await fetch(target, {
+					...requestInit,
+					method: "PUT",
+					headers,
+					body
+				});
+				if (!res.ok) {
+					const err = /* @__PURE__ */ new Error(`PUT ${url}: ${res.status} ${res.statusText}`);
+					err.status = res.status;
+					throw err;
+				}
+			};
+			return w;
+		},
+		async deleter(url) {
+			const res = await fetch(translateS3Url(url), {
+				...requestInit,
+				method: "DELETE"
+			});
+			if (!res.ok && res.status !== 404) throw new Error(`DELETE ${url}: ${res.status} ${res.statusText}`);
+		}
+	};
+}
+function cachingResolver(base) {
+	const cache = /* @__PURE__ */ new Map();
+	const out = { reader(path, byteLength) {
+		let buf = cache.get(path);
+		if (!buf) {
+			buf = (async () => cachedAsyncBuffer(await base.reader(path, byteLength)))();
+			cache.set(path, buf);
+			buf.catch(() => {
+				if (cache.get(path) === buf) cache.delete(path);
+			});
+		}
+		return buf;
+	} };
+	if (base.writer) {
+		const baseWriter = base.writer;
+		out.writer = (path, options) => {
+			const w = baseWriter(path, options);
+			const origFinish = w.finish.bind(w);
+			w.finish = async function() {
+				await origFinish();
+				cache.delete(path);
+			};
+			return w;
+		};
+	}
+	if (base.deleter) {
+		const baseDeleter = base.deleter;
+		out.deleter = async (path) => {
+			await baseDeleter(path);
+			cache.delete(path);
+		};
+	}
+	return out;
+}
+function s3Lister({ requestInit } = {}) {
+	return async function list(url) {
+		const s3parts = s3ParseUrl(url);
+		if (!s3parts) throw new Error(`not an S3 URL: ${url}`);
+		const { bucket, prefix } = s3parts;
+		const listUrl = `https://${bucket}.s3.amazonaws.com/?list-type=2&prefix=${prefix.replace(/\/$/, "")}/&delimiter=/`;
+		const res = await fetch(listUrl, requestInit);
+		if (!res.ok) throw new Error(`${res.status} ${res.statusText}`);
+		return ((await res.text()).match(/<Contents>(.*?)<\/Contents>/gs) || []).map((match) => {
+			const keyMatch = match.match(/<Key>(.*?)<\/Key>/);
+			if (!keyMatch) throw new Error("failed to parse S3 list response");
+			return keyMatch[1].split("/").pop() ?? "";
+		}).filter(Boolean);
+	};
+}
+function s3ParseUrl(url) {
+	if (url.startsWith("s3://") || url.startsWith("s3a://")) {
+		const parts = url.split("/");
+		return {
+			bucket: parts[2],
+			prefix: parts.slice(3).join("/")
+		};
+	}
+	if (url.startsWith("https://s3.amazonaws.com/")) {
+		const parts = url.split("/");
+		return {
+			bucket: parts[3],
+			prefix: parts.slice(4).join("/")
+		};
+	}
+	const m = url.match(/^https:\/\/([a-z0-9][a-z0-9-]*)\.s3(?:[.-][a-z0-9-]+)?\.amazonaws\.com\/(.*)$/);
+	if (m) return {
+		bucket: m[1],
+		prefix: m[2]
+	};
+}
+async function resolveText(resolver, path) {
+	const ab = await resolver.reader(path);
+	let buf = await ab.slice(0, ab.byteLength);
+	if (isGzip(buf)) buf = await decompressGzip(buf);
+	return new TextDecoder().decode(buf);
+}
+function isGzip(buf) {
+	if (buf.byteLength < 2) return false;
+	const view = new Uint8Array(buf, 0, 2);
+	return view[0] === 31 && view[1] === 139;
+}
+async function decompressGzip(buf) {
+	if (!globalThis.DecompressionStream) throw new Error("gzip decompression is not supported in this environment");
+	const stream = new Blob([buf]).stream().pipeThrough(new DecompressionStream("gzip"));
+	return await new Response(stream).arrayBuffer();
+}
+async function fetchAvroRecords(url, resolver, byteLength) {
+	const lengthHint = byteLength !== void 0 && Number.isFinite(byteLength) ? byteLength : void 0;
+	const ab = await resolver.reader(url, lengthHint);
+	const buffer = await ab.slice(0, ab.byteLength);
+	const reader = {
+		view: new DataView(buffer),
+		offset: 0
+	};
+	const { metadata, syncMarker } = await avroMetadata(reader);
+	return await avroRead({
+		reader,
+		metadata,
+		syncMarker
+	});
+}
+export { cachingResolver, fetchAvroRecords, resolveText, s3Lister, s3ParseUrl, translateS3Url, urlResolver };

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

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