@gscdump/lakehouse 0.35.3 → 0.35.4

package/dist/THIRD-PARTY-LICENSES.md

@@ -304,11 +304,11 @@ Repository: https://github.com/101arrowz/fzstd
 
 ---------------------------------------
 
-## hyparquet, hyparquet-compressors, hyparquet-writer, icebird, squirreling
+## hyparquet, hyparquet, hyparquet-compressors, hyparquet-writer, icebird, squirreling
 
 License: MIT
 By: Hyperparam
-Repositories: https://github.com/hyparam/hyparquet, https://github.com/hyparam/hyparquet-compressors, https://github.com/hyparam/hyparquet-writer, https://github.com/hyparam/icebird, https://github.com/hyparam/squirreling
+Repositories: https://github.com/hyparam/hyparquet, https://github.com/hyparam/hyparquet, https://github.com/hyparam/hyparquet-compressors, https://github.com/hyparam/hyparquet-writer, https://github.com/hyparam/icebird, https://github.com/hyparam/squirreling
 
 > The MIT License (MIT)
 > 

package/dist/_chunks/libs/hyparquet.mjs

@@ -1,82 +1,3 @@
-const ParquetTypes = [
-	"BOOLEAN",
-	"INT32",
-	"INT64",
-	"INT96",
-	"FLOAT",
-	"DOUBLE",
-	"BYTE_ARRAY",
-	"FIXED_LEN_BYTE_ARRAY"
-];
-const Encodings = [
-	"PLAIN",
-	"GROUP_VAR_INT",
-	"PLAIN_DICTIONARY",
-	"RLE",
-	"BIT_PACKED",
-	"DELTA_BINARY_PACKED",
-	"DELTA_LENGTH_BYTE_ARRAY",
-	"DELTA_BYTE_ARRAY",
-	"RLE_DICTIONARY",
-	"BYTE_STREAM_SPLIT"
-];
-const FieldRepetitionTypes = [
-	"REQUIRED",
-	"OPTIONAL",
-	"REPEATED"
-];
-const ConvertedTypes = [
-	"UTF8",
-	"MAP",
-	"MAP_KEY_VALUE",
-	"LIST",
-	"ENUM",
-	"DECIMAL",
-	"DATE",
-	"TIME_MILLIS",
-	"TIME_MICROS",
-	"TIMESTAMP_MILLIS",
-	"TIMESTAMP_MICROS",
-	"UINT_8",
-	"UINT_16",
-	"UINT_32",
-	"UINT_64",
-	"INT_8",
-	"INT_16",
-	"INT_32",
-	"INT_64",
-	"JSON",
-	"BSON",
-	"INTERVAL"
-];
-const CompressionCodecs = [
-	"UNCOMPRESSED",
-	"SNAPPY",
-	"GZIP",
-	"LZO",
-	"BROTLI",
-	"LZ4",
-	"ZSTD",
-	"LZ4_RAW"
-];
-const PageTypes = [
-	"DATA_PAGE",
-	"INDEX_PAGE",
-	"DICTIONARY_PAGE",
-	"DATA_PAGE_V2"
-];
-const BoundaryOrders = [
-	"UNORDERED",
-	"ASCENDING",
-	"DESCENDING"
-];
-const EdgeInterpolationAlgorithms = [
-	"SPHERICAL",
-	"VINCENTY",
-	"THOMAS",
-	"ANDOYER",
-	"KARNEY"
-];
 new TextDecoder();
 function parseDecimal(bytes) {
 	if (!bytes.length) return 0;
@@ -86,6 +7,185 @@ function parseDecimal(bytes) {
 	if (value >= 2n ** BigInt(bits - 1)) value -= 2n ** BigInt(bits);
 	return Number(value);
 }
+const defaultInitialFetchSize = 1 << 19;
+new TextDecoder();
+new TextEncoder();
+new Uint32Array([
+	1203114875,
+	1150766481,
+	2284105051,
+	2729912477,
+	1884591559,
+	770785867,
+	2667333959,
+	1550580529
+]);
+async function byteLengthFromUrlUsingGet(url, requestInit = {}, fetchFn = globalThis.fetch) {
+	const controller = new AbortController();
+	const headers = new Headers(requestInit.headers);
+	headers.set("Range", "bytes=0-0");
+	const res = await fetchFn(url, {
+		...requestInit,
+		headers,
+		signal: controller.signal
+	});
+	if (!res.ok) throw new Error(`fetch with range failed ${res.status}`);
+	if (res.status === 206) {
+		const contentRange = res.headers.get("Content-Range");
+		if (!contentRange) throw new Error("missing content-range header");
+		const match = contentRange.match(/bytes \d+-\d+\/(\d+)/);
+		if (!match) throw new Error(`invalid content-range header: ${contentRange}`);
+		return parseInt(match[1]);
+	}
+	if (res.status === 200) {
+		const contentLength = res.headers.get("Content-Length");
+		controller.abort();
+		if (contentLength) return parseInt(contentLength);
+	}
+	throw new Error("server does not support range requests and missing content-length");
+}
+async function byteLengthFromUrl(url, requestInit, customFetch) {
+	const fetch = customFetch ?? globalThis.fetch;
+	const res = await fetch(url, {
+		...requestInit,
+		method: "HEAD"
+	});
+	if (res.status === 403) return byteLengthFromUrlUsingGet(url, requestInit, fetch);
+	if (!res.ok) throw new Error(`fetch head failed ${res.status}`);
+	const length = res.headers.get("Content-Length");
+	if (!length) return byteLengthFromUrlUsingGet(url, requestInit, fetch);
+	return parseInt(length);
+}
+async function asyncBufferFromUrl({ url, byteLength, requestInit, fetch: customFetch }) {
+	if (!url) throw new Error("missing url");
+	const fetch = customFetch ?? globalThis.fetch;
+	byteLength ??= await byteLengthFromUrl(url, requestInit, fetch);
+	let buffer = void 0;
+	const init = requestInit || {};
+	return {
+		byteLength,
+		async slice(start, end) {
+			if (buffer) return buffer.then((buffer) => buffer.slice(start, end));
+			const headers = new Headers(init.headers);
+			const endStr = end === void 0 ? "" : end - 1;
+			headers.set("Range", `bytes=${start}-${endStr}`);
+			const res = await fetch(url, {
+				...init,
+				headers
+			});
+			if (!res.ok || !res.body) throw new Error(`fetch failed ${res.status}`);
+			if (res.status === 200) {
+				buffer = res.arrayBuffer();
+				return buffer.then((buffer) => buffer.slice(start, end));
+			} else if (res.status === 206) return res.arrayBuffer();
+			else throw new Error(`fetch received unexpected status code ${res.status}`);
+		}
+	};
+}
+function cachedAsyncBuffer({ byteLength, slice }, { minSize = defaultInitialFetchSize } = {}) {
+	if (byteLength < minSize) {
+		const buffer = slice(0, byteLength);
+		return {
+			byteLength,
+			async slice(start, end) {
+				return (await buffer).slice(start, end);
+			}
+		};
+	}
+	const cache = /* @__PURE__ */ new Map();
+	return {
+		byteLength,
+		slice(start, end) {
+			const key = cacheKey(start, end, byteLength);
+			const cached = cache.get(key);
+			if (cached) return cached;
+			const promise = slice(start, end);
+			cache.set(key, promise);
+			return promise;
+		}
+	};
+}
+function cacheKey(start, end, size) {
+	if (start < 0) {
+		if (end !== void 0) throw new Error(`invalid suffix range [${start}, ${end}]`);
+		if (size === void 0) return `${start},`;
+		return `${size + start},${size}`;
+	} else if (end !== void 0) {
+		if (start > end) throw new Error(`invalid empty range [${start}, ${end}]`);
+		return `${start},${end}`;
+	} else if (size === void 0) return `${start},`;
+	else return `${start},${size}`;
+}
+new TextDecoder();
+const WORD_MASK = [
+	0,
+	255,
+	65535,
+	16777215,
+	4294967295
+];
+function copyBytes(fromArray, fromPos, toArray, toPos, length) {
+	for (let i = 0; i < length; i++) toArray[toPos + i] = fromArray[fromPos + i];
+}
+function snappyUncompress(input, output) {
+	const inputLength = input.byteLength;
+	const outputLength = output.byteLength;
+	let pos = 0;
+	let outPos = 0;
+	while (pos < inputLength) {
+		const c = input[pos];
+		pos++;
+		if (c < 128) break;
+	}
+	if (outputLength && pos >= inputLength) throw new Error("invalid snappy length header");
+	while (pos < inputLength) {
+		const c = input[pos];
+		let len = 0;
+		pos++;
+		if (pos >= inputLength) throw new Error("missing eof marker");
+		if ((c & 3) === 0) {
+			let len = (c >>> 2) + 1;
+			if (len > 60) {
+				if (pos + 3 >= inputLength) throw new Error("snappy error literal pos + 3 >= inputLength");
+				const lengthSize = len - 60;
+				len = input[pos] + (input[pos + 1] << 8) + (input[pos + 2] << 16) + (input[pos + 3] << 24);
+				len = (len & WORD_MASK[lengthSize]) + 1;
+				pos += lengthSize;
+			}
+			if (pos + len > inputLength) throw new Error("snappy error literal exceeds input length");
+			copyBytes(input, pos, output, outPos, len);
+			pos += len;
+			outPos += len;
+		} else {
+			let offset = 0;
+			switch (c & 3) {
+				case 1:
+					len = (c >>> 2 & 7) + 4;
+					offset = input[pos] + (c >>> 5 << 8);
+					pos++;
+					break;
+				case 2:
+					if (inputLength <= pos + 1) throw new Error("snappy error end of input");
+					len = (c >>> 2) + 1;
+					offset = input[pos] + (input[pos + 1] << 8);
+					pos += 2;
+					break;
+				case 3:
+					if (inputLength <= pos + 3) throw new Error("snappy error end of input");
+					len = (c >>> 2) + 1;
+					offset = input[pos] + (input[pos + 1] << 8) + (input[pos + 2] << 16) + (input[pos + 3] << 24);
+					pos += 4;
+					break;
+				default: break;
+			}
+			if (offset === 0 || isNaN(offset)) throw new Error(`invalid offset ${offset} pos ${pos} inputLength ${inputLength}`);
+			if (offset > outPos) throw new Error("cannot copy from before start of buffer");
+			copyBytes(output, outPos - offset, output, outPos, len);
+			outPos += len;
+		}
+	}
+	if (outPos !== outputLength) throw new Error("premature end of input");
+}
 function schemaTree(schema, rootIndex, path) {
 	const element = schema[rootIndex];
 	const children = [];
@@ -139,8 +239,6 @@ function isMapLike(schema) {
 	if (firstChild.children.find((child) => child.element.name === "value")?.element.repetition_type === "REPEATED") return false;
 	return true;
 }
-const defaultInitialFetchSize = 1 << 19;
-new TextDecoder();
 const MASK = 18446744073709551615n;
 const PRIME1 = 11400714785074694791n;
 const PRIME2 = 14029467366897019727n;
@@ -274,6 +372,87 @@ function hashParquetValue(value, element) {
 		return;
 	}
 }
+const ParquetTypes = [
+	"BOOLEAN",
+	"INT32",
+	"INT64",
+	"INT96",
+	"FLOAT",
+	"DOUBLE",
+	"BYTE_ARRAY",
+	"FIXED_LEN_BYTE_ARRAY"
+];
+const Encodings = [
+	"PLAIN",
+	"GROUP_VAR_INT",
+	"PLAIN_DICTIONARY",
+	"RLE",
+	"BIT_PACKED",
+	"DELTA_BINARY_PACKED",
+	"DELTA_LENGTH_BYTE_ARRAY",
+	"DELTA_BYTE_ARRAY",
+	"RLE_DICTIONARY",
+	"BYTE_STREAM_SPLIT"
+];
+const FieldRepetitionTypes = [
+	"REQUIRED",
+	"OPTIONAL",
+	"REPEATED"
+];
+const ConvertedTypes = [
+	"UTF8",
+	"MAP",
+	"MAP_KEY_VALUE",
+	"LIST",
+	"ENUM",
+	"DECIMAL",
+	"DATE",
+	"TIME_MILLIS",
+	"TIME_MICROS",
+	"TIMESTAMP_MILLIS",
+	"TIMESTAMP_MICROS",
+	"UINT_8",
+	"UINT_16",
+	"UINT_32",
+	"UINT_64",
+	"INT_8",
+	"INT_16",
+	"INT_32",
+	"INT_64",
+	"JSON",
+	"BSON",
+	"INTERVAL"
+];
+const CompressionCodecs = [
+	"UNCOMPRESSED",
+	"SNAPPY",
+	"GZIP",
+	"LZO",
+	"BROTLI",
+	"LZ4",
+	"ZSTD",
+	"LZ4_RAW"
+];
+const PageTypes = [
+	"DATA_PAGE",
+	"INDEX_PAGE",
+	"DICTIONARY_PAGE",
+	"DATA_PAGE_V2"
+];
+const BoundaryOrders = [
+	"UNORDERED",
+	"ASCENDING",
+	"DESCENDING"
+];
+const EdgeInterpolationAlgorithms = [
+	"SPHERICAL",
+	"VINCENTY",
+	"THOMAS",
+	"ANDOYER",
+	"KARNEY"
+];
+new TextDecoder();
+new TextDecoder();
 function toJson(obj) {
 	if (obj === void 0) return null;
 	if (typeof obj === "bigint") return Number(obj);
@@ -291,170 +470,5 @@ function toJson(obj) {
 	}
 	return obj;
 }
-async function byteLengthFromUrlUsingGet(url, requestInit = {}, fetchFn = globalThis.fetch) {
-	const controller = new AbortController();
-	const headers = new Headers(requestInit.headers);
-	headers.set("Range", "bytes=0-0");
-	const res = await fetchFn(url, {
-		...requestInit,
-		headers,
-		signal: controller.signal
-	});
-	if (!res.ok) throw new Error(`fetch with range failed ${res.status}`);
-	if (res.status === 206) {
-		const contentRange = res.headers.get("Content-Range");
-		if (!contentRange) throw new Error("missing content-range header");
-		const match = contentRange.match(/bytes \d+-\d+\/(\d+)/);
-		if (!match) throw new Error(`invalid content-range header: ${contentRange}`);
-		return parseInt(match[1]);
-	}
-	if (res.status === 200) {
-		const contentLength = res.headers.get("Content-Length");
-		controller.abort();
-		if (contentLength) return parseInt(contentLength);
-	}
-	throw new Error("server does not support range requests and missing content-length");
-}
-async function byteLengthFromUrl(url, requestInit, customFetch) {
-	const fetch = customFetch ?? globalThis.fetch;
-	const res = await fetch(url, {
-		...requestInit,
-		method: "HEAD"
-	});
-	if (res.status === 403) return byteLengthFromUrlUsingGet(url, requestInit, fetch);
-	if (!res.ok) throw new Error(`fetch head failed ${res.status}`);
-	const length = res.headers.get("Content-Length");
-	if (!length) return byteLengthFromUrlUsingGet(url, requestInit, fetch);
-	return parseInt(length);
-}
-async function asyncBufferFromUrl({ url, byteLength, requestInit, fetch: customFetch }) {
-	if (!url) throw new Error("missing url");
-	const fetch = customFetch ?? globalThis.fetch;
-	byteLength ??= await byteLengthFromUrl(url, requestInit, fetch);
-	let buffer = void 0;
-	const init = requestInit || {};
-	return {
-		byteLength,
-		async slice(start, end) {
-			if (buffer) return buffer.then((buffer) => buffer.slice(start, end));
-			const headers = new Headers(init.headers);
-			const endStr = end === void 0 ? "" : end - 1;
-			headers.set("Range", `bytes=${start}-${endStr}`);
-			const res = await fetch(url, {
-				...init,
-				headers
-			});
-			if (!res.ok || !res.body) throw new Error(`fetch failed ${res.status}`);
-			if (res.status === 200) {
-				buffer = res.arrayBuffer();
-				return buffer.then((buffer) => buffer.slice(start, end));
-			} else if (res.status === 206) return res.arrayBuffer();
-			else throw new Error(`fetch received unexpected status code ${res.status}`);
-		}
-	};
-}
-function cachedAsyncBuffer({ byteLength, slice }, { minSize = defaultInitialFetchSize } = {}) {
-	if (byteLength < minSize) {
-		const buffer = slice(0, byteLength);
-		return {
-			byteLength,
-			async slice(start, end) {
-				return (await buffer).slice(start, end);
-			}
-		};
-	}
-	const cache = /* @__PURE__ */ new Map();
-	return {
-		byteLength,
-		slice(start, end) {
-			const key = cacheKey(start, end, byteLength);
-			const cached = cache.get(key);
-			if (cached) return cached;
-			const promise = slice(start, end);
-			cache.set(key, promise);
-			return promise;
-		}
-	};
-}
-function cacheKey(start, end, size) {
-	if (start < 0) {
-		if (end !== void 0) throw new Error(`invalid suffix range [${start}, ${end}]`);
-		if (size === void 0) return `${start},`;
-		return `${size + start},${size}`;
-	} else if (end !== void 0) {
-		if (start > end) throw new Error(`invalid empty range [${start}, ${end}]`);
-		return `${start},${end}`;
-	} else if (size === void 0) return `${start},`;
-	else return `${start},${size}`;
-}
 new TextDecoder();
-const WORD_MASK = [
-	0,
-	255,
-	65535,
-	16777215,
-	4294967295
-];
-function copyBytes(fromArray, fromPos, toArray, toPos, length) {
-	for (let i = 0; i < length; i++) toArray[toPos + i] = fromArray[fromPos + i];
-}
-function snappyUncompress(input, output) {
-	const inputLength = input.byteLength;
-	const outputLength = output.byteLength;
-	let pos = 0;
-	let outPos = 0;
-	while (pos < inputLength) {
-		const c = input[pos];
-		pos++;
-		if (c < 128) break;
-	}
-	if (outputLength && pos >= inputLength) throw new Error("invalid snappy length header");
-	while (pos < inputLength) {
-		const c = input[pos];
-		let len = 0;
-		pos++;
-		if (pos >= inputLength) throw new Error("missing eof marker");
-		if ((c & 3) === 0) {
-			let len = (c >>> 2) + 1;
-			if (len > 60) {
-				if (pos + 3 >= inputLength) throw new Error("snappy error literal pos + 3 >= inputLength");
-				const lengthSize = len - 60;
-				len = input[pos] + (input[pos + 1] << 8) + (input[pos + 2] << 16) + (input[pos + 3] << 24);
-				len = (len & WORD_MASK[lengthSize]) + 1;
-				pos += lengthSize;
-			}
-			if (pos + len > inputLength) throw new Error("snappy error literal exceeds input length");
-			copyBytes(input, pos, output, outPos, len);
-			pos += len;
-			outPos += len;
-		} else {
-			let offset = 0;
-			switch (c & 3) {
-				case 1:
-					len = (c >>> 2 & 7) + 4;
-					offset = input[pos] + (c >>> 5 << 8);
-					pos++;
-					break;
-				case 2:
-					if (inputLength <= pos + 1) throw new Error("snappy error end of input");
-					len = (c >>> 2) + 1;
-					offset = input[pos] + (input[pos + 1] << 8);
-					pos += 2;
-					break;
-				case 3:
-					if (inputLength <= pos + 3) throw new Error("snappy error end of input");
-					len = (c >>> 2) + 1;
-					offset = input[pos] + (input[pos + 1] << 8) + (input[pos + 2] << 16) + (input[pos + 3] << 24);
-					pos += 4;
-					break;
-				default: break;
-			}
-			if (offset === 0 || isNaN(offset)) throw new Error(`invalid offset ${offset} pos ${pos} inputLength ${inputLength}`);
-			if (offset > outPos) throw new Error("cannot copy from before start of buffer");
-			copyBytes(output, outPos - offset, output, outPos, len);
-			outPos += len;
-		}
-	}
-	if (outPos !== outputLength) throw new Error("premature end of input");
-}
 export { BoundaryOrders, CompressionCodecs, ConvertedTypes, EdgeInterpolationAlgorithms, Encodings, FieldRepetitionTypes, PageTypes, ParquetTypes, asyncBufferFromUrl, cachedAsyncBuffer, getMaxDefinitionLevel, getSchemaPath, hashParquetValue, isListLike, isMapLike, parseDecimal, snappyUncompress, toJson };

package/dist/_chunks/libs/icebird.mjs

@@ -345,32 +345,6 @@ async function fetchAvroRecords(url, resolver, byteLength) {
 	});
 }
 const MAX_SAFE = BigInt(Number.MAX_SAFE_INTEGER);
-function stringifyIcebergJson(value, indent) {
-	const sp = indent ? " ".repeat(indent) : "";
-	function emit(v, depth) {
-		if (typeof v === "bigint") return v.toString();
-		if (v === null) return "null";
-		if (typeof v === "string") return JSON.stringify(v);
-		if (typeof v === "number" || typeof v === "boolean") return JSON.stringify(v);
-		if (Array.isArray(v)) {
-			if (v.length === 0) return "[]";
-			const inner = v.map((x) => emit(x, depth + 1));
-			if (!sp) return "[" + inner.join(",") + "]";
-			const pad = sp.repeat(depth + 1), close = sp.repeat(depth);
-			return "[\n" + pad + inner.join(",\n" + pad) + "\n" + close + "]";
-		}
-		if (typeof v === "object") {
-			const keys = Object.keys(v).filter((k) => v[k] !== void 0);
-			if (keys.length === 0) return "{}";
-			const inner = keys.map((k) => JSON.stringify(k) + (sp ? ": " : ":") + emit(v[k], depth + 1));
-			if (!sp) return "{" + inner.join(",") + "}";
-			const pad = sp.repeat(depth + 1), close = sp.repeat(depth);
-			return "{\n" + pad + inner.join(",\n" + pad) + "\n" + close + "}";
-		}
-		return JSON.stringify(v);
-	}
-	return emit(value, 0);
-}
 function parseIcebergJson(text) {
 	let i = 0;
 	function skipWs() {
@@ -499,6 +473,23 @@ function parseIcebergJson(text) {
 	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);
+}
 function metadataFileVersionNumber(file) {
 	const match = file.match(/^(?:v(\d+)|(\d+)-.+)(?:\.metadata\.json|\.gz\.metadata\.json|\.metadata\.json\.gz)$/);
 	if (!match) return void 0;
@@ -1411,7 +1402,7 @@ async function icebergCreate({ tableUrl, resolver, schema, formatVersion, partit
 	if (formatVersion >= 3) metadata["next-row-id"] = 0;
 	if (!resolver.writer) throw new Error("resolver.writer is required");
 	const metadataWriter = conditionalCommits ? resolver.writer(metadataUrl, { ifNoneMatch: "*" }) : resolver.writer(metadataUrl);
-	const metadataBytes = new TextEncoder().encode(stringifyIcebergJson(metadata, 2));
+	const metadataBytes = new TextEncoder().encode(stringifyIcebergJson(metadata));
 	metadataWriter.appendBytes(metadataBytes);
 	await metadataWriter.finish();
 	const versionHintUrl = `${tableUrl}/metadata/version-hint.text`;
@@ -1455,7 +1446,7 @@ async function fileCatalogCommit({ tableUrl, metadata, metadataFileName, current
 		"metadata-log": trimmedLog
 	};
 	const metaWriter = conditionalCommits ? resolver.writer(newMetadataPath, { ifNoneMatch: "*" }) : resolver.writer(newMetadataPath);
-	metaWriter.appendBytes(new TextEncoder().encode(stringifyIcebergJson(newMetadata, 2)));
+	metaWriter.appendBytes(new TextEncoder().encode(stringifyIcebergJson(newMetadata)));
 	await metaWriter.finish();
 	try {
 		const hintWriter = resolver.writer(`${tableUrl}/metadata/version-hint.text`);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gscdump/lakehouse",
   "type": "module",
-  "version": "0.35.3",
+  "version": "0.35.4",
   "description": "Dataset-agnostic Iceberg lakehouse layer + dataset registry for R2 Data Catalog producers (ADR-0021).",
   "author": {
     "name": "Harlan Wilton",
@@ -46,9 +46,9 @@
     "node": ">=18"
   },
   "devDependencies": {
-    "@types/node": "^26.0.1",
-    "hyparquet": "^1.26.1",
-    "icebird": "^0.8.11",
+    "@types/node": "^26.1.0",
+    "hyparquet": "^1.26.2",
+    "icebird": "^0.8.12",
     "unstorage": "^1.17.5",
     "vitest": "^4.1.9"
   },