@gscdump/lakehouse 3.2.0 → 3.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Harlan Wilton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/THIRD-PARTY-LICENSES.md

@@ -304,11 +304,11 @@ Repository: https://github.com/101arrowz/fzstd
 
 ---------------------------------------
 
-## hyparquet, hyparquet, hyparquet-compressors, hyparquet-writer, icebird, squirreling
+## hyparquet, hyparquet, hyparquet, hyparquet-compressors, hyparquet-writer, icebird, squirreling
 
 License: MIT
 By: Hyperparam
-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
+Repositories: https://github.com/hyparam/hyparquet, 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/_virtual/node_modules/.pnpm/{hyparquet@1.28.2 → hyparquet@1.29.1}/node_modules/hyparquet/src/index.mjs

@@ -2,6 +2,7 @@ import { parquetMetadataAsync } from "./metadata.mjs";
 import "./indexes.mjs";
 import { asyncBufferFromUrl, cachedAsyncBuffer } from "./utils.mjs";
 import "./snappy.mjs";
+import { parquetScan } from "./scan.mjs";
 import { parquetReadObjects } from "./read.mjs";
 import "./query.mjs";
-export { asyncBufferFromUrl, cachedAsyncBuffer, parquetMetadataAsync, parquetReadObjects };
+export { asyncBufferFromUrl, cachedAsyncBuffer, parquetMetadataAsync, parquetReadObjects, parquetScan };

package/dist/_virtual/node_modules/.pnpm/{hyparquet@1.28.2 → hyparquet@1.29.1}/node_modules/hyparquet/src/node.mjs

@@ -2,6 +2,7 @@ import { parquetMetadataAsync } from "./metadata.mjs";
 import "./indexes.mjs";
 import { asyncBufferFromUrl, cachedAsyncBuffer } from "./utils.mjs";
 import "./snappy.mjs";
+import { parquetScan } from "./scan.mjs";
 import { parquetReadObjects } from "./read.mjs";
 import "./index.mjs";
-export { asyncBufferFromUrl, cachedAsyncBuffer, parquetMetadataAsync, parquetReadObjects };
+export { asyncBufferFromUrl, cachedAsyncBuffer, parquetMetadataAsync, parquetReadObjects, parquetScan };

package/dist/_virtual/node_modules/.pnpm/{hyparquet@1.28.2 → hyparquet@1.29.1}/node_modules/hyparquet/src/plan.mjs

@@ -4,123 +4,151 @@ import { readColumnIndex, readOffsetIndex } from "./indexes.mjs";
 import { bloomEligibleColumns, readBloomFilter } from "./bloom.mjs";
 import { canSkipRowGroup, filterPageRanges, pathsNeededForFilter } from "./filter.mjs";
 const runLimit = 1 << 21;
-function parquetPlan({ metadata, rowStart = 0, rowEnd = Infinity, columns, filter, filterStrict = true, useOffsetIndex = false, bloomFiltersByGroup, schemaElements, pageRangesByGroup, pageLocationsByGroup }) {
+function parquetPlan(options) {
+	const { metadata, rowStart = 0, columns, useOffsetIndex = false } = options;
 	if (!metadata) throw new Error("parquetPlan requires metadata");
 	const groups = [];
 	const fetches = [];
 	const indexes = [];
+	const scanPlan = parquetPlanGroups(options);
+	for (const group of scanPlan.groups) {
+		const groupPlan = parquetPlanGroup({
+			...group,
+			columns,
+			useOffsetIndex
+		});
+		groups.push(...groupPlan.groups);
+		fetches.push(...groupPlan.fetches);
+		indexes.push(...groupPlan.indexes);
+	}
+	fetches.push(...indexes);
+	return {
+		metadata,
+		rowStart,
+		rowEnd: scanPlan.rowEnd,
+		columns,
+		fetches,
+		groups
+	};
+}
+function parquetPlanGroups({ metadata, rowStart = 0, rowEnd = Infinity, columns, filter, filterStrict = true, bloomFiltersByGroup, schemaElements, pageRangesByGroup, pageLocationsByGroup }) {
+	if (!metadata) throw new Error("parquetPlan requires metadata");
 	const schemaTree = parquetSchema(metadata);
 	const physicalColumns = getPhysicalColumns(schemaTree);
 	const elementsByPath = filter ? {
 		...physicalSchemaElements(schemaTree),
 		...schemaElements
 	} : schemaElements;
+	const groups = [];
 	let groupStart = 0;
-	let rgIdx = 0;
-	for (const rowGroup of metadata.row_groups) {
+	for (let groupIndex = 0; groupIndex < metadata.row_groups.length; groupIndex++) {
+		const rowGroup = metadata.row_groups[groupIndex];
 		const groupRows = Number(rowGroup.num_rows);
 		const groupEnd = groupStart + groupRows;
-		const bloomFilters = bloomFiltersByGroup?.[rgIdx];
 		if (groupRows > 0 && groupEnd > rowStart && groupStart < rowEnd && !canSkipRowGroup({
 			rowGroup,
 			physicalColumns,
 			filter,
 			strict: filterStrict,
-			bloomFilters,
+			bloomFilters: bloomFiltersByGroup?.[groupIndex],
 			schemaElements: elementsByPath
 		})) {
 			const selectStart = Math.max(rowStart - groupStart, 0);
 			const selectEnd = Math.min(rowEnd - groupStart, groupRows);
-			const pageRanges = pageRangesByGroup?.[rgIdx];
-			const pageLocations = pageLocationsByGroup?.[rgIdx];
-			let subranges = pageRanges ? pageRanges.map(([start, end]) => {
+			const pageRanges = pageRangesByGroup?.[groupIndex];
+			const pageLocations = pageLocationsByGroup?.[groupIndex];
+			let ranges = pageRanges ? pageRanges.map(([start, end]) => {
 				return [Math.max(start, selectStart), Math.min(end, selectEnd)];
 			}).filter(([start, end]) => start < end) : [[selectStart, selectEnd]];
-			if (subranges.length > 1) {
-				if (!rowGroup.columns.every((chunk) => {
-					const columnName = chunk.meta_data?.path_in_schema[0];
-					const columnPath = chunk.meta_data?.path_in_schema.join(".");
-					if (columns && columnName && !columns.includes(columnName)) return true;
-					return !!(chunk.offset_index_offset && chunk.offset_index_length) || !!(columnPath && pageLocations?.[columnPath]);
-				})) subranges = [[subranges[0][0], subranges[subranges.length - 1][1]]];
-				else subranges = coalesceOverlappingPageRanges(subranges, rowGroup, columns, pageLocations);
+			if (ranges.length > 1) ranges = rowGroup.columns.every((chunk) => {
+				const columnName = chunk.meta_data?.path_in_schema[0];
+				const columnPath = chunk.meta_data?.path_in_schema.join(".");
+				if (columns && columnName && !columns.includes(columnName)) return true;
+				return !!(chunk.offset_index_offset && chunk.offset_index_length) || !!(columnPath && pageLocations?.[columnPath]);
+			}) ? coalesceOverlappingPageRanges(ranges, rowGroup, columns, pageLocations) : [[ranges[0][0], ranges[ranges.length - 1][1]]];
+			if (ranges.length) groups.push({
+				rowGroup,
+				groupIndex,
+				groupStart,
+				groupRows,
+				ranges,
+				pageRanges,
+				pageLocations
+			});
+		}
+		groupStart = groupEnd;
+	}
+	return {
+		groups,
+		rowEnd: isFinite(rowEnd) ? rowEnd : groupStart
+	};
+}
+function parquetPlanGroup({ rowGroup, groupStart, groupRows, ranges, columns, useOffsetIndex = false, pageRanges, pageLocations }) {
+	const chunks = [];
+	const fetches = [];
+	const indexes = [];
+	const narrowed = ranges.length > 1 || ranges[0][0] > 0 || ranges[0][1] < groupRows;
+	for (const chunk of rowGroup.columns) {
+		const meta = chunk.meta_data;
+		if (chunk.file_path) throw new Error("parquet file_path not supported");
+		if (!meta) throw new Error("parquet column metadata is undefined");
+		if (columns && !columns.includes(meta.path_in_schema[0])) continue;
+		const columnOffset = meta.dictionary_page_offset || meta.data_page_offset;
+		const startByte = Number(columnOffset);
+		const endByte = Number(columnOffset + meta.total_compressed_size);
+		const chunkPageLocations = pageLocations?.[meta.path_in_schema.join(".")];
+		if (chunkPageLocations && narrowed) chunks.push({
+			columnMetadata: meta,
+			pageLocations: chunkPageLocations,
+			range: {
+				startByte,
+				endByte
 			}
-			if (subranges.length) {
-				const chunks = [];
-				const narrowed = subranges.length > 1 || subranges[0][0] > 0 || subranges[0][1] < groupRows;
-				for (const chunk of rowGroup.columns) {
-					const meta = chunk.meta_data;
-					if (chunk.file_path) throw new Error("parquet file_path not supported");
-					if (!meta) throw new Error("parquet column metadata is undefined");
-					if (!columns || columns.includes(meta.path_in_schema[0])) {
-						const columnOffset = meta.dictionary_page_offset || meta.data_page_offset;
-						const startByte = Number(columnOffset);
-						const endByte = Number(columnOffset + meta.total_compressed_size);
-						const chunkPageLocations = pageLocations?.[meta.path_in_schema.join(".")];
-						if (chunkPageLocations && narrowed) chunks.push({
-							columnMetadata: meta,
-							pageLocations: chunkPageLocations,
-							range: {
-								startByte,
-								endByte
-							}
-						});
-						else if ((useOffsetIndex || pageRanges) && chunk.offset_index_offset && chunk.offset_index_length && narrowed) {
-							const offsetIndexStart = Number(chunk.offset_index_offset);
-							chunks.push({
-								columnMetadata: meta,
-								offsetIndex: {
-									startByte: offsetIndexStart,
-									endByte: offsetIndexStart + chunk.offset_index_length
-								},
-								range: {
-									startByte,
-									endByte
-								}
-							});
-						} else chunks.push({
-							columnMetadata: meta,
-							range: {
-								startByte,
-								endByte
-							}
-						});
-					}
-				}
-				for (const [subStart, subEnd] of subranges) groups.push({
-					chunks,
-					rowGroup,
-					groupStart,
-					groupRows,
-					selectStart: subStart,
-					selectEnd: subEnd
-				});
-				let run;
-				for (const chunk of chunks) if ("pageLocations" in chunk) {} else if ("offsetIndex" in chunk) indexes.push(chunk.offsetIndex);
-				else {
-					const { range } = chunk;
-					if (columns) fetches.push(range);
-					else if (run && range.endByte - run.startByte <= runLimit) run.endByte = range.endByte;
-					else {
-						if (run) fetches.push(run);
-						run = { ...range };
-					}
+		});
+		else if ((useOffsetIndex || pageRanges) && chunk.offset_index_offset && chunk.offset_index_length && narrowed) {
+			const startByte = Number(chunk.offset_index_offset);
+			chunks.push({
+				columnMetadata: meta,
+				offsetIndex: {
+					startByte,
+					endByte: startByte + chunk.offset_index_length
+				},
+				range: {
+					startByte: Number(columnOffset),
+					endByte
 				}
-				if (run) fetches.push(run);
+			});
+		} else chunks.push({
+			columnMetadata: meta,
+			range: {
+				startByte,
+				endByte
 			}
+		});
+	}
+	let run;
+	for (const chunk of chunks) {
+		if ("pageLocations" in chunk) continue;
+		if ("offsetIndex" in chunk) indexes.push(chunk.offsetIndex);
+		else if (columns) fetches.push(chunk.range);
+		else if (run && chunk.range.endByte - run.startByte <= runLimit) run.endByte = chunk.range.endByte;
+		else {
+			if (run) fetches.push(run);
+			run = { ...chunk.range };
 		}
-		groupStart = groupEnd;
-		rgIdx++;
 	}
-	if (!isFinite(rowEnd)) rowEnd = groupStart;
-	fetches.push(...indexes);
+	if (run) fetches.push(run);
 	return {
-		metadata,
-		rowStart,
-		rowEnd,
-		columns,
+		groups: ranges.map(([selectStart, selectEnd]) => ({
+			chunks,
+			rowGroup,
+			groupStart,
+			groupRows,
+			selectStart,
+			selectEnd
+		})),
 		fetches,
-		groups
+		indexes
 	};
 }
 function coalesceOverlappingPageRanges(ranges, rowGroup, columns, pageLocations) {
@@ -344,4 +372,4 @@ function prefetchAsyncBuffer(file, { fetches }) {
 		}
 	};
 }
-export { parquetPlan, prefetchAsyncBuffer, prefetchBloomFilters, prefetchPageIndexes };
+export { parquetPlan, parquetPlanGroup, parquetPlanGroups, prefetchAsyncBuffer, prefetchBloomFilters, prefetchPageIndexes };

package/dist/_virtual/node_modules/.pnpm/hyparquet@1.29.1/node_modules/hyparquet/src/read.mjs

@@ -0,0 +1,78 @@
+import { parquetMetadataAsync, parquetSchema } from "./metadata.mjs";
+import { concat } from "./utils.mjs";
+import { columnsNeededForFilter, matchFilter } from "./filter.mjs";
+import "./plan.mjs";
+import { assembleAsync, asyncGroupToRows } from "./rowgroup.mjs";
+import { prepareParquetRead, readParquetPlan } from "./scan.mjs";
+async function parquetRead(options) {
+	options.metadata ??= await parquetMetadataAsync(options.file, options);
+	const { rowStart = 0, rowEnd, columns, onChunk, onComplete, rowFormat, filter, filterStrict = true } = options;
+	if (filter && rowFormat !== "object") throw new Error("parquet filter requires rowFormat: \"object\"");
+	const filterColumns = columnsNeededForFilter(filter);
+	let readColumns = columns;
+	if (columns && filterColumns.length) {
+		const selectedColumns = new Set(columns);
+		const extraColumns = filterColumns.filter((column) => !selectedColumns.has(column));
+		if (extraColumns.length) readColumns = [...columns, ...extraColumns];
+	}
+	const readOptions = readColumns === columns ? options : {
+		...options,
+		columns: readColumns
+	};
+	const prepared = await prepareParquetRead(readOptions);
+	const preparedOptions = prepared.options;
+	const requiresProjection = readColumns !== columns;
+	const asyncGroups = readParquetPlan(preparedOptions, prepared.plan);
+	if (!onComplete && !onChunk) {
+		await awaitAllColumns(asyncGroups);
+		return;
+	}
+	if (!preparedOptions.metadata) throw new Error("parquet requires metadata");
+	const schemaTree = parquetSchema(preparedOptions.metadata);
+	const assembled = asyncGroups.map((arg) => assembleAsync(arg, schemaTree, options.parsers));
+	if (onChunk) for (const asyncGroup of assembled) for (const asyncColumn of asyncGroup.asyncColumns) asyncColumn.data.then(({ data, skipped }) => {
+		let rowStart = asyncGroup.groupStart + skipped;
+		for (const columnData of data) {
+			onChunk({
+				columnName: asyncColumn.pathInSchema[0],
+				columnData,
+				rowStart,
+				rowEnd: rowStart + columnData.length
+			});
+			rowStart += columnData.length;
+		}
+	}, () => {});
+	if (onComplete) {
+		await awaitAllColumns(assembled);
+		const rows = [];
+		for (const asyncGroup of assembled) {
+			const selectStart = asyncGroup.selectStart ?? Math.max(rowStart - asyncGroup.groupStart, 0);
+			const selectEnd = asyncGroup.selectEnd ?? Math.min((rowEnd ?? Infinity) - asyncGroup.groupStart, asyncGroup.groupRows);
+			const groupData = rowFormat === "object" ? await asyncGroupToRows(asyncGroup, selectStart, selectEnd, readColumns, "object") : await asyncGroupToRows(asyncGroup, selectStart, selectEnd, columns, "array");
+			if (filter) {
+				for (const row of groupData) if (matchFilter(row, filter, filterStrict)) {
+					if (requiresProjection && columns) {
+						for (const col of filterColumns) if (!columns.includes(col)) delete row[col];
+					}
+					rows.push(row);
+				}
+			} else concat(rows, groupData);
+		}
+		onComplete(rows);
+	} else await awaitAllColumns(assembled);
+}
+async function awaitAllColumns(asyncGroups) {
+	const all = asyncGroups.flatMap((g) => g.asyncColumns.map((c) => c.data));
+	const failed = (await Promise.allSettled(all)).find((r) => r.status === "rejected");
+	if (failed) throw failed.reason;
+}
+function parquetReadObjects(options) {
+	return new Promise((onComplete, reject) => {
+		parquetRead({
+			...options,
+			rowFormat: "object",
+			onComplete
+		}).catch(reject);
+	});
+}
+export { parquetRead, parquetReadObjects };

package/dist/_virtual/node_modules/.pnpm/hyparquet@1.29.1/node_modules/hyparquet/src/scan.mjs

@@ -0,0 +1,203 @@
+import { parquetMetadataAsync, parquetSchema } from "./metadata.mjs";
+import { flatten } from "./utils.mjs";
+import { columnsNeededForFilter } from "./filter.mjs";
+import { parquetPlan, parquetPlanGroup, parquetPlanGroups, prefetchAsyncBuffer, prefetchBloomFilters, prefetchPageIndexes } from "./plan.mjs";
+import { assembleAsync, readRowGroup } from "./rowgroup.mjs";
+async function parquetScan(options) {
+	options.metadata ??= await parquetMetadataAsync(options.file, options);
+	const { pruningFilter, ...readOptions } = options;
+	let { columns } = readOptions;
+	if (columns && pruningFilter) {
+		const selectedColumns = new Set(columns);
+		const extraColumns = columnsNeededForFilter(pruningFilter).filter((column) => !selectedColumns.has(column));
+		if (extraColumns.length) columns = [...columns, ...extraColumns];
+	}
+	const preparedOptions = await prepareParquetOptions({
+		...readOptions,
+		columns,
+		filter: pruningFilter,
+		useOffsetIndex: readOptions.useOffsetIndex ?? true
+	});
+	const { metadata } = preparedOptions;
+	if (!metadata) throw new Error("parquet requires metadata");
+	const schemaTree = parquetSchema(metadata);
+	const availableColumns = new Set(columns ?? schemaTree.children.map((child) => child.element.name));
+	const candidates = parquetPlanGroups(preparedOptions).groups.flatMap((group) => group.ranges.map(([selectStart, selectEnd]) => ({
+		rowStart: group.groupStart + selectStart,
+		rowEnd: group.groupStart + selectEnd,
+		group
+	})));
+	const ranges = candidates.map(({ rowStart, rowEnd }) => ({
+		rowStart,
+		rowEnd
+	}));
+	const cache = /* @__PURE__ */ new Map();
+	function readColumn({ column, rowStart, rowEnd }) {
+		if (!availableColumns.has(column)) throw new Error(`parquet column not found in scan: ${column}`);
+		validateRange(rowStart, rowEnd);
+		if (rowStart === rowEnd) return Promise.resolve([]);
+		const candidateIndex = findCandidate(candidates, rowStart, rowEnd);
+		if (candidateIndex < 0) throw new RangeError(`parquet row range [${rowStart}, ${rowEnd}) is outside scan ranges`);
+		const { group } = candidates[candidateIndex];
+		const cached = cache.get(column);
+		if (cached && rowStart >= cached.rowStart && rowEnd <= cached.rowEnd) return cached.data.then((data) => sliceDecodedArray(data, rowStart - cached.rowStart, rowEnd - cached.rowStart));
+		const data = readColumnRange({
+			options: preparedOptions,
+			schemaTree,
+			group,
+			column,
+			rowStart,
+			rowEnd
+		});
+		cache.set(column, {
+			rowStart,
+			rowEnd,
+			data
+		});
+		return data;
+	}
+	return {
+		metadata,
+		ranges,
+		readColumn
+	};
+}
+async function prepareParquetRead(options) {
+	const prepared = await prepareParquetOptions(options);
+	return {
+		options: prepared,
+		plan: parquetPlan(prepared)
+	};
+}
+async function prepareParquetOptions(options) {
+	const metadata = options.metadata ?? await parquetMetadataAsync(options.file, options);
+	const schemaColumns = parquetSchema(metadata).children.map((child) => child.element.name);
+	const missingFilterColumns = columnsNeededForFilter(options.filter).filter((column) => !schemaColumns.includes(column));
+	if (missingFilterColumns.length) throw new Error(`parquet filter columns not found: ${missingFilterColumns.join(", ")}`);
+	if (options.columns) {
+		const missingColumns = options.columns.filter((column) => !schemaColumns.includes(column));
+		if (missingColumns.length) throw new Error(`parquet column not found: ${missingColumns[0]}`);
+	}
+	let prepared = {
+		...options,
+		metadata
+	};
+	prepared = await withBloomFilters(prepared);
+	prepared = await withPageIndexes(prepared);
+	return prepared;
+}
+function readParquetPlan(options, plan) {
+	const readOptions = {
+		...options,
+		file: prefetchAsyncBuffer(options.file, plan)
+	};
+	return plan.groups.map((group) => readRowGroup(readOptions, plan, group));
+}
+async function readColumnRange({ options, schemaTree, group, column, rowStart, rowEnd }) {
+	const [asyncGroup] = readParquetPlan({
+		...options,
+		columns: [column],
+		filter: void 0,
+		rowStart,
+		rowEnd,
+		useBloomFilters: false,
+		useOffsetIndex: options.useOffsetIndex ?? true,
+		usePageIndex: false,
+		pageRangesByGroup: void 0
+	}, planCandidateColumn({
+		options,
+		group,
+		column,
+		rowStart,
+		rowEnd
+	}));
+	if (!asyncGroup) throw new Error("parquet scan range not planned");
+	const assembled = assembleAsync(asyncGroup, schemaTree, options.parsers);
+	const asyncColumn = assembled.asyncColumns.find((child) => child.pathInSchema[0] === column);
+	if (!asyncColumn) throw new Error(`parquet column not found: ${column}`);
+	const result = await asyncColumn.data;
+	const data = flatten(result.data);
+	const selectStart = assembled.selectStart ?? rowStart - assembled.groupStart;
+	const selectEnd = assembled.selectEnd ?? rowEnd - assembled.groupStart;
+	return sliceDecodedArray(data, selectStart - result.skipped, selectEnd - result.skipped);
+}
+function planCandidateColumn({ options, group, column, rowStart, rowEnd }) {
+	if (!options.metadata) throw new Error("parquet requires metadata");
+	const localPlan = parquetPlanGroup({
+		rowGroup: group.rowGroup,
+		groupStart: group.groupStart,
+		groupRows: group.groupRows,
+		ranges: [[rowStart - group.groupStart, rowEnd - group.groupStart]],
+		columns: [column],
+		useOffsetIndex: options.useOffsetIndex ?? true,
+		pageLocations: group.pageLocations
+	});
+	const [localGroupPlan] = localPlan.groups;
+	if (!localGroupPlan) throw new Error(`parquet column not found: ${column}`);
+	return {
+		metadata: options.metadata,
+		rowStart,
+		rowEnd,
+		columns: [column],
+		fetches: [...localPlan.fetches, ...localPlan.indexes],
+		groups: [localGroupPlan]
+	};
+}
+function findCandidate(candidates, rowStart, rowEnd) {
+	let low = 0;
+	let high = candidates.length - 1;
+	while (low <= high) {
+		const middle = Math.floor((low + high) / 2);
+		const candidate = candidates[middle];
+		if (rowStart < candidate.rowStart) high = middle - 1;
+		else if (rowStart >= candidate.rowEnd) low = middle + 1;
+		else return rowEnd <= candidate.rowEnd ? middle : -1;
+	}
+	return -1;
+}
+function validateRange(rowStart, rowEnd) {
+	if (!Number.isSafeInteger(rowStart) || rowStart < 0) throw new RangeError("parquet rowStart must be a non-negative safe integer");
+	if (!Number.isSafeInteger(rowEnd) || rowEnd < rowStart) throw new RangeError("parquet rowEnd must be a safe integer greater than or equal to rowStart");
+}
+function sliceDecodedArray(data, start, end) {
+	if (start === 0 && end === data.length) return data;
+	return Array.isArray(data) ? data.slice(start, end) : data.subarray(start, end);
+}
+async function withBloomFilters(options) {
+	if (!options.useBloomFilters || !options.filter || !options.metadata) return options;
+	const schemaTree = parquetSchema(options.metadata);
+	const schemaElements = {};
+	for (const child of schemaTree.children) schemaElements[child.element.name] = child.element;
+	const bloomFiltersByGroup = await prefetchBloomFilters({
+		file: options.file,
+		metadata: options.metadata,
+		filter: options.filter,
+		filterStrict: options.filterStrict
+	});
+	return {
+		...options,
+		bloomFiltersByGroup,
+		schemaElements
+	};
+}
+async function withPageIndexes(options) {
+	if (!options.usePageIndex || !options.filter || !options.metadata) return options;
+	const { pageRangesByGroup, pageLocationsByGroup } = await prefetchPageIndexes({
+		file: options.file,
+		metadata: options.metadata,
+		filter: options.filter,
+		filterStrict: options.filterStrict,
+		rowStart: options.rowStart,
+		rowEnd: options.rowEnd,
+		columns: options.columns,
+		bloomFiltersByGroup: options.bloomFiltersByGroup,
+		schemaElements: options.schemaElements,
+		parsers: options.parsers
+	});
+	return {
+		...options,
+		pageRangesByGroup,
+		pageLocationsByGroup
+	};
+}
+export { parquetScan, prepareParquetRead, readParquetPlan };

package/dist/_virtual/node_modules/.pnpm/{hyparquet@1.28.2 → hyparquet@1.29.1}/node_modules/hyparquet/types/index.d.mts

@@ -2,6 +2,7 @@ import { AsyncBuffer as AsyncBuffer$1 } from "../src/types.mjs";
 import "./indexes.mjs";
 import "./metadata.mjs";
 import "./read.mjs";
+import "./scan.mjs";
 import "./query.mjs";
 import "./snappy.mjs";
 import "./utils.mjs";

package/dist/_virtual/node_modules/.pnpm/hyparquet@1.29.2/node_modules/hyparquet/src/snappy.mjs

@@ -0,0 +1,68 @@
+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;
+			}
+			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 { snappyUncompress };

package/dist/_virtual/node_modules/.pnpm/{icebird@0.8.22_patch_hash=4fa7fd5702c4ce432fb2902c6abe07cc55565e87f6375b96ece63a10999712e6 → icebird@0.8.26_patch_hash=75eacba5b0363ee2a40baa0ef77c7fb20d06389025186ca95b514a927cad0244}/node_modules/icebird/src/avro/avro.read.mjs

@@ -1,4 +1,4 @@
-import { parseDecimal } from "../../../../../hyparquet@1.28.2/node_modules/hyparquet/src/convert.mjs";
+import { parseDecimal } from "../../../../../hyparquet@1.29.1/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";