@gscdump/engine 7.3.2 → 7.5.1

package/dist/adapters/parquet-bounded-values.mjs

@@ -0,0 +1,318 @@
+import { snappyUncompress } from "../node_modules/.pnpm/hyparquet@1.31.1/node_modules/hyparquet/src/snappy.mjs";
+import "../node_modules/.pnpm/hyparquet@1.31.1/node_modules/hyparquet/src/node.mjs";
+import { parquetDecodeBudget } from "./parquet-decode-budget.mjs";
+import { BoundedHeaderTruncatedError, boundedPageHeader } from "./parquet-page-header.mjs";
+import { hybridCursor, plainCursor } from "./parquet-value-cursor.mjs";
+function boundedValuesPolicy(options) {
+	if (options === void 0) return void 0;
+	const policy = {
+		targetRows: 1e3,
+		maxBatchBytes: 1048576,
+		maxValueBytes: 262144,
+		maxActiveBytes: 25165824,
+		maxPages: 16384,
+		maxHeaderBytes: 65536,
+		maxDictionaryEntries: 1e5,
+		...options
+	};
+	for (const [key, value] of Object.entries(policy)) if (!Number.isSafeInteger(value) || value < 1) throw new RangeError(`invalid boundedValues.${key}`);
+	return policy;
+}
+const supportedEncodings = /* @__PURE__ */ new Set([
+	0,
+	2,
+	8
+]);
+function natural(value, label) {
+	if (!Number.isSafeInteger(value) || value < 0) throw new Error(`bounded Parquet invalid ${label}`);
+	return value;
+}
+function scalar(element) {
+	if (element.num_children || !["REQUIRED", "OPTIONAL"].includes(element.repetition_type ?? "")) return false;
+	const converted = element.converted_type;
+	const logical = element.logical_type?.type;
+	if (element.type === "BYTE_ARRAY") return (converted === "UTF8" || logical === "STRING") && (!converted || converted === "UTF8") && (!logical || logical === "STRING");
+	return [
+		"BOOLEAN",
+		"INT32",
+		"INT64",
+		"INT96",
+		"FLOAT",
+		"DOUBLE"
+	].includes(element.type ?? "") && (!converted || [
+		"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"
+	].includes(converted)) && (!logical || [
+		"DATE",
+		"TIME",
+		"TIMESTAMP",
+		"INTEGER"
+	].includes(logical));
+}
+async function readHeader(file, start, end, maxBytes) {
+	const limit = Math.min(end - start, maxBytes);
+	for (let length = Math.min(512, limit);;) try {
+		return boundedPageHeader(await file.slice(start, start + length));
+	} catch (error) {
+		if (!(error instanceof BoundedHeaderTruncatedError) || length === limit) throw error;
+		length = Math.min(limit, length * 2);
+	}
+}
+async function planInput(file, metadata, policy, maxReadBytes, columns, rowStart = 0, rowEnd = Infinity, maxReadAndDecompressBytes) {
+	const schema = metadata.schema.slice(1);
+	if (metadata.schema[0]?.num_children !== schema.length || schema.some((element) => !scalar(element)) || new Set(schema.map((element) => element.name)).size !== schema.length) throw new Error("bounded Parquet requires a flat scalar REQUIRED/OPTIONAL schema");
+	const selected = columns ? schema.filter((element) => columns.includes(element.name)) : schema;
+	const output = [];
+	let start = 0;
+	let pageCount = 0;
+	try {
+		for (const group of metadata.row_groups) {
+			const rows = Number(group.num_rows);
+			const plan = {
+				start,
+				rows,
+				columns: []
+			};
+			start += rows;
+			if (start <= rowStart || plan.start >= rowEnd) continue;
+			plan.budget = maxReadAndDecompressBytes === void 0 ? void 0 : parquetDecodeBudget(file, maxReadAndDecompressBytes);
+			output.push(plan);
+			const groupFile = plan.budget?.file ?? file;
+			let active = Math.min(policy.maxHeaderBytes, maxReadBytes);
+			for (const element of selected) {
+				const matches = group.columns.filter((col) => col.meta_data?.path_in_schema.length === 1 && col.meta_data.path_in_schema[0] === element.name);
+				if (matches.length !== 1) throw new Error("bounded Parquet missing or duplicate column");
+				const chunk = matches[0];
+				const meta = chunk.meta_data;
+				if (chunk.file_path || meta.type !== element.type || Number(meta.num_values) !== rows || !["SNAPPY", "UNCOMPRESSED"].includes(meta.codec)) throw new Error("bounded Parquet unsupported column or codec");
+				const first = Number(meta.dictionary_page_offset ?? meta.data_page_offset);
+				const end = first + Number(meta.total_compressed_size);
+				if (!Number.isSafeInteger(first) || first < 4 || !Number.isSafeInteger(end) || end > file.byteLength || end < first) throw new Error("bounded Parquet invalid column range");
+				const column = {
+					element,
+					meta,
+					pages: []
+				};
+				let pageRows = 0;
+				let maxData = 0;
+				for (let offset = first; offset < end;) {
+					if (++pageCount > policy.maxPages) throw new RangeError("bounded Parquet exceeds maxPages");
+					const header = await readHeader(groupFile, offset, end, Math.min(policy.maxHeaderBytes, maxReadBytes));
+					natural(header.compressed, "compressed page bytes");
+					natural(header.uncompressed, "uncompressed page bytes");
+					natural(header.count, "page values");
+					const page = {
+						...header,
+						offset: offset + header.bytes
+					};
+					offset = page.offset + page.compressed;
+					if (offset > end || page.compressed > maxReadBytes) throw new RangeError("bounded Parquet page exceeds range bounds");
+					if (page.kind === 2) {
+						if (column.dictionary || column.pages.length || page.encoding !== 0 || page.count > policy.maxDictionaryEntries) throw new Error("bounded Parquet unsupported dictionary");
+						column.dictionary = page;
+						active += page.compressed + page.uncompressed + (page.count + 1) * 4;
+					} else {
+						if (!page.count || !supportedEncodings.has(page.encoding) || page.encoding !== 0 && !column.dictionary) throw new Error("bounded Parquet unsupported data encoding");
+						if (page.kind === 0 && (page.definitionEncoding !== 3 || page.repetitionEncoding !== 3)) throw new Error("bounded Parquet unsupported level encoding");
+						if (page.kind === 3) {
+							natural(page.nulls, "null count");
+							natural(page.rows, "page rows");
+							natural(page.definitions, "definition bytes");
+							natural(page.repetitions, "repetition bytes");
+							if (page.rows !== page.count || page.nulls > page.count || page.repetitions !== 0 || page.definitions > page.compressed || page.definitions > page.uncompressed || element.repetition_type === "REQUIRED" && (page.definitions !== 0 || page.nulls !== 0)) throw new Error("bounded Parquet invalid flat V2 page");
+						}
+						pageRows += page.count;
+						if (pageRows > rows) throw new Error("bounded Parquet excess physical rows");
+						maxData = Math.max(maxData, page.compressed + page.uncompressed);
+						column.pages.push(page);
+					}
+				}
+				if (pageRows !== rows) throw new Error("bounded Parquet incomplete physical rows");
+				if (column.dictionary && element.type === "BOOLEAN") throw new Error("bounded Parquet BOOLEAN dictionary is unsupported");
+				active += maxData;
+				if (!Number.isSafeInteger(active) || active > policy.maxActiveBytes) throw new RangeError("bounded Parquet exceeds maxActiveBytes");
+				plan.columns.push(column);
+			}
+		}
+		return output;
+	} catch (error) {
+		for (const plan of output) plan.budget?.close();
+		throw error;
+	}
+}
+function inflate(input, size, compressed, decompress) {
+	if (!compressed) {
+		if (input.length !== size) throw new Error("bounded Parquet uncompressed page size mismatch");
+		return input;
+	}
+	if (decompress) return decompress(input, size);
+	const output = new Uint8Array(size);
+	snappyUncompress(input, output);
+	return output;
+}
+function dataCursor(page, input, plan, policy, dictionary, decompress) {
+	let definitions;
+	let levels;
+	let values;
+	if (page.kind === 0) {
+		const decoded = inflate(input, page.uncompressed, plan.meta.codec === "SNAPPY", decompress);
+		let offset = 0;
+		if (plan.element.repetition_type === "OPTIONAL") {
+			if (decoded.length < 4) throw new Error("bounded Parquet missing definition levels");
+			offset = 4 + new DataView(decoded.buffer, decoded.byteOffset, decoded.byteLength).getUint32(0, true);
+			if (offset > decoded.length) throw new Error("bounded Parquet truncated definition levels");
+			levels = decoded.subarray(4, offset);
+		}
+		values = decoded.subarray(offset);
+	} else {
+		const length = page.definitions;
+		if (plan.element.repetition_type === "OPTIONAL") levels = input.subarray(0, length);
+		values = inflate(input.subarray(length), page.uncompressed - length, page.isCompressed !== false && plan.meta.codec === "SNAPPY", decompress);
+	}
+	let present = page.count;
+	if (levels) {
+		definitions = hybridCursor(levels, 1, page.count);
+		present = 0;
+		for (let i = 0; i < page.count; i++) present += definitions.next();
+		definitions.finish();
+		definitions = hybridCursor(levels, 1, page.count);
+	}
+	if (page.kind === 3 && page.count - present !== page.nulls) throw new Error("bounded Parquet null count mismatch");
+	let plain;
+	let ids;
+	if (page.encoding === 0) plain = plainCursor(values, plan.element, present, policy.maxValueBytes);
+	else {
+		if (!dictionary || !values.length) throw new Error("bounded Parquet missing dictionary IDs");
+		ids = hybridCursor(values.subarray(1), values[0], present);
+	}
+	return {
+		next() {
+			if (definitions && definitions.next() === 0) return {
+				bytes: 64,
+				value: () => null
+			};
+			if (plain) return plain.next();
+			const id = ids.next();
+			if (id >= dictionary.offsets.length - 1) throw new Error("bounded Parquet dictionary ID out of range");
+			const start = dictionary.offsets[id];
+			const end = dictionary.offsets[id + 1];
+			return plainCursor(dictionary.bytes.subarray(start, end), plan.element, 1, policy.maxValueBytes).next();
+		},
+		finish() {
+			definitions?.finish();
+			plain?.finish();
+			ids?.finish();
+		}
+	};
+}
+var ColumnCursor = class {
+	file;
+	plan;
+	policy;
+	decompress;
+	dictionary;
+	current;
+	pageIndex = 0;
+	remaining = 0;
+	constructor(file, plan, policy, decompress) {
+		this.file = file;
+		this.plan = plan;
+		this.policy = policy;
+		this.decompress = decompress;
+	}
+	needsPage() {
+		return this.remaining === 0;
+	}
+	async load() {
+		if (this.remaining) return;
+		this.current?.finish();
+		this.current = void 0;
+		if (!this.dictionary && this.plan.dictionary) {
+			const page = this.plan.dictionary;
+			const bytes = inflate(new Uint8Array(await this.file.slice(page.offset, page.offset + page.compressed)), page.uncompressed, this.plan.meta.codec === "SNAPPY", this.decompress);
+			const offsets = new Uint32Array(page.count + 1);
+			const cursor = plainCursor(bytes, this.plan.element, page.count, this.policy.maxValueBytes);
+			for (let index = 0; index < page.count; index++) {
+				offsets[index] = cursor.position();
+				cursor.skip();
+			}
+			offsets[page.count] = cursor.position();
+			cursor.finish();
+			this.dictionary = {
+				bytes,
+				offsets
+			};
+		}
+		const page = this.plan.pages[this.pageIndex++];
+		if (!page) throw new Error("bounded Parquet exhausted column");
+		const input = new Uint8Array(await this.file.slice(page.offset, page.offset + page.compressed));
+		this.current = dataCursor(page, input, this.plan, this.policy, this.dictionary, this.decompress);
+		this.remaining = page.count;
+	}
+	next() {
+		if (!this.current || this.remaining-- < 1) throw new Error("bounded Parquet column is not ready");
+		return this.current.next();
+	}
+	close() {
+		this.current = void 0;
+		this.dictionary = void 0;
+	}
+	finish() {
+		this.current?.finish();
+		if (this.remaining || this.pageIndex !== this.plan.pages.length) throw new Error("bounded Parquet incomplete column");
+	}
+};
+async function* decodeBoundedValues(file, metadata, policy, maxReadBytes, options, maxReadAndDecompressBytes) {
+	const plans = await planInput(file, metadata, policy, maxReadBytes, options.columns, options.rowStart, options.rowEnd, maxReadAndDecompressBytes);
+	try {
+		for (const plan of plans) {
+			const budget = plan.budget;
+			const cursors = plan.columns.map((column) => new ColumnCursor(budget?.file ?? file, column, policy, budget?.compressors.SNAPPY));
+			let batch = [];
+			let batchBytes = 0;
+			try {
+				for (let index = 0; index < plan.rows; index++) {
+					for (const cursor of cursors) if (cursor.needsPage()) await cursor.load();
+					const tokens = cursors.map((cursor) => cursor.next());
+					const position = plan.start + index;
+					if (position < (options.rowStart ?? 0) || position >= (options.rowEnd ?? Infinity)) continue;
+					const bytes = 128 + tokens.reduce((sum, token) => sum + 16 + token.bytes, 0);
+					if (bytes > policy.maxBatchBytes) throw new RangeError("bounded Parquet row exceeds maxBatchBytes");
+					if (batch.length && (batch.length >= policy.targetRows || batchBytes + bytes > policy.maxBatchBytes)) {
+						yield batch;
+						batch = [];
+						batchBytes = 0;
+					}
+					const row = {};
+					for (let col = 0; col < tokens.length; col++) Object.defineProperty(row, plan.columns[col].element.name, {
+						value: tokens[col].value(),
+						enumerable: true,
+						configurable: true,
+						writable: true
+					});
+					batch.push(row);
+					batchBytes += bytes;
+				}
+				for (const cursor of cursors) cursor.finish();
+				if (batch.length) yield batch;
+			} finally {
+				for (const cursor of cursors) cursor.close();
+				budget?.close();
+			}
+		}
+	} finally {
+		for (const plan of plans) plan.budget?.close();
+	}
+}
+export { boundedValuesPolicy, decodeBoundedValues };

package/dist/adapters/parquet-decode-budget.mjs

@@ -0,0 +1,61 @@
+import { snappyUncompress } from "../node_modules/.pnpm/hyparquet@1.31.1/node_modules/hyparquet/src/snappy.mjs";
+import "../node_modules/.pnpm/hyparquet@1.31.1/node_modules/hyparquet/src/node.mjs";
+function parquetDecodeBudget(source, maxBytes) {
+	let remaining = maxBytes;
+	let closed = false;
+	let failure;
+	function fail(error) {
+		if (!closed) {
+			closed = true;
+			failure = error;
+		}
+		throw failure;
+	}
+	function assertOpen() {
+		if (closed) throw failure;
+	}
+	function charge(bytes) {
+		assertOpen();
+		if (!Number.isSafeInteger(bytes) || bytes < 0 || bytes > remaining) fail(/* @__PURE__ */ new RangeError("parquet stream exceeds maxReadAndDecompressBytes"));
+		remaining -= bytes;
+	}
+	return {
+		file: {
+			byteLength: source.byteLength,
+			async slice(start, end = source.byteLength) {
+				try {
+					if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 0 || end < start || end > source.byteLength) fail(/* @__PURE__ */ new RangeError("parquet stream invalid decode-buffer range"));
+					charge(end - start);
+					const bytes = await source.slice(start, end);
+					assertOpen();
+					if (bytes.byteLength !== end - start) fail(/* @__PURE__ */ new Error("parquet stream returned an incomplete decode-buffer range"));
+					return bytes;
+				} catch (error) {
+					fail(error);
+				}
+			}
+		},
+		compressors: {
+			SNAPPY(input, size) {
+				charge(size);
+				try {
+					const output = new Uint8Array(size);
+					snappyUncompress(input, output);
+					return output;
+				} catch (error) {
+					fail(error);
+				}
+			},
+			ZSTD() {
+				fail(/* @__PURE__ */ new Error("parquet stream maxReadAndDecompressBytes does not support ZSTD"));
+			}
+		},
+		close() {
+			if (!closed) {
+				closed = true;
+				failure = /* @__PURE__ */ new Error("parquet stream decode-buffer budget is closed");
+			}
+		}
+	};
+}
+export { parquetDecodeBudget };

package/dist/adapters/parquet-page-header.mjs

@@ -0,0 +1,136 @@
+var BoundedHeaderTruncatedError = class extends Error {
+	constructor() {
+		super("bounded Parquet truncated page header");
+	}
+};
+function boundedPageHeader(bytes) {
+	const view = new DataView(bytes);
+	let offset = 0;
+	let fields = 0;
+	const take = (length) => {
+		if (!Number.isSafeInteger(length) || length < 0) throw new Error("bounded Parquet invalid page-header size");
+		if (offset + length > view.byteLength) throw new BoundedHeaderTruncatedError();
+		const start = offset;
+		offset += length;
+		return start;
+	};
+	const byte = () => view.getUint8(take(1));
+	const varint = () => {
+		let value = 0;
+		for (let shift = 0; shift < 49; shift += 7) {
+			const b = byte();
+			value += (b & 127) * 2 ** shift;
+			if (!(b & 128) && Number.isSafeInteger(value)) return value;
+		}
+		throw new Error("bounded Parquet invalid header integer");
+	};
+	const integer = () => {
+		const value = varint();
+		return value % 2 ? -(value + 1) / 2 : value / 2;
+	};
+	const skip = (type, depth) => {
+		if (depth > 8 || ++fields > 512) throw new Error("bounded Parquet excessive page-header structure");
+		if (type === 1 || type === 2) return;
+		if (type === 3) {
+			take(1);
+			return;
+		}
+		if (type === 4 || type === 5) {
+			varint();
+			return;
+		}
+		if (type === 6) {
+			for (let i = 0; i < 10; i++) if (!(byte() & 128)) return;
+			throw new Error("bounded Parquet invalid header int64");
+		}
+		if (type === 7) {
+			take(8);
+			return;
+		}
+		if (type === 8) {
+			take(varint());
+			return;
+		}
+		if (type === 12) {
+			struct(depth + 1);
+			return;
+		}
+		throw new Error("bounded Parquet unsupported page-header field");
+	};
+	function struct(depth, select) {
+		let id = 0;
+		const seen = /* @__PURE__ */ new Set();
+		while (true) {
+			const field = byte();
+			if (field === 0) return;
+			const type = field & 15;
+			id = field >> 4 ? id + (field >> 4) : integer();
+			if (id < 1 || seen.has(id)) throw new Error("bounded Parquet invalid page-header field");
+			seen.add(id);
+			if (!select?.(id, type)) skip(type, depth);
+			if (++fields > 512) throw new Error("bounded Parquet excessive page-header fields");
+		}
+	}
+	const root = {};
+	const children = {};
+	struct(0, (id, type) => {
+		if ([
+			1,
+			2,
+			3
+		].includes(id)) {
+			if (type !== 5) throw new Error("bounded Parquet invalid page-header number");
+			root[id] = integer();
+			return true;
+		}
+		if ([
+			5,
+			7,
+			8
+		].includes(id)) {
+			if (type !== 12) throw new Error("bounded Parquet invalid page-header body");
+			const body = {};
+			children[id] = body;
+			struct(1, (field, fieldType) => {
+				if (field > (id === 5 ? 4 : id === 7 ? 2 : 7)) return false;
+				if (id === 8 && field === 7) {
+					if (fieldType !== 1 && fieldType !== 2) throw new Error("bounded Parquet invalid compression boolean");
+					body[field] = fieldType === 1;
+				} else {
+					if (fieldType !== 5) throw new Error("bounded Parquet invalid data-header number");
+					body[field] = integer();
+				}
+				return true;
+			});
+			return true;
+		}
+		return false;
+	});
+	const kind = root[1];
+	const body = children[kind === 0 ? 5 : kind === 2 ? 7 : 8];
+	if (![
+		0,
+		2,
+		3
+	].includes(kind) || !body) throw new Error("bounded Parquet unsupported page type");
+	return {
+		bytes: offset,
+		kind,
+		compressed: root[3],
+		uncompressed: root[2],
+		count: body[1],
+		encoding: body[kind === 3 ? 4 : 2],
+		...kind === 0 ? {
+			definitionEncoding: body[3],
+			repetitionEncoding: body[4]
+		} : {},
+		...kind === 3 ? {
+			nulls: body[2],
+			rows: body[3],
+			definitions: body[5],
+			repetitions: body[6],
+			isCompressed: body[7] === void 0 ? true : body[7]
+		} : {}
+	};
+}
+export { BoundedHeaderTruncatedError, boundedPageHeader };

package/dist/adapters/parquet-range-cache.mjs

@@ -0,0 +1,41 @@
+function parquetRangeCache(source, maxBytes) {
+	const entries = /* @__PURE__ */ new Map();
+	let retainedBytes = 0;
+	let closed = false;
+	return {
+		file: {
+			byteLength: source.byteLength,
+			async slice(start, end = source.byteLength) {
+				const key = `${start}:${end}`;
+				const cached = entries.get(key);
+				if (cached) {
+					entries.delete(key);
+					entries.set(key, cached);
+					return cached;
+				}
+				const bytes = await source.slice(start, end);
+				if (!closed && bytes.byteLength > 0 && bytes.byteLength <= maxBytes) {
+					const previous = entries.get(key);
+					if (previous) {
+						retainedBytes -= previous.byteLength;
+						entries.delete(key);
+					}
+					while (entries.size >= 128 || retainedBytes + bytes.byteLength > maxBytes) {
+						const oldest = entries.keys().next().value;
+						retainedBytes -= entries.get(oldest).byteLength;
+						entries.delete(oldest);
+					}
+					entries.set(key, bytes);
+					retainedBytes += bytes.byteLength;
+				}
+				return bytes;
+			}
+		},
+		close() {
+			closed = true;
+			entries.clear();
+			retainedBytes = 0;
+		}
+	};
+}
+export { parquetRangeCache };

package/dist/adapters/parquet-value-cursor.mjs

@@ -0,0 +1,108 @@
+import { DEFAULT_PARSERS, convert } from "../node_modules/.pnpm/hyparquet@1.31.1/node_modules/hyparquet/src/convert.mjs";
+const utf8 = new TextDecoder();
+function hybridCursor(bytes, width, count) {
+	if (!Number.isInteger(width) || width < 0 || width > 32) throw new Error("bounded Parquet invalid bit width");
+	let offset = 0;
+	let remaining = count;
+	let run = 0;
+	let repeat = 0;
+	let packed = false;
+	let bit = 0;
+	let packedStart = 0;
+	const readByte = () => {
+		if (offset >= bytes.length) throw new Error("bounded Parquet truncated RLE stream");
+		return bytes[offset++];
+	};
+	const next = () => {
+		if (remaining-- <= 0) throw new Error("bounded Parquet too many encoded values");
+		if (width === 0 && bytes.length === 0) return 0;
+		if (!run) {
+			let header = 0;
+			let shift = 0;
+			while (true) {
+				const b = readByte();
+				header += (b & 127) * 2 ** shift;
+				if (!(b & 128)) break;
+				shift += 7;
+				if (shift > 28) throw new Error("bounded Parquet invalid RLE run");
+			}
+			packed = !!(header & 1);
+			run = packed ? Math.floor(header / 2) * 8 : header / 2;
+			if (!Number.isSafeInteger(run) || run < 1 || run > 2147483647 || !packed && run > remaining + 1) throw new Error(`bounded Parquet invalid RLE run length: run=${run}, remaining=${remaining + 1}, packed=${packed}, width=${width}`);
+			if (packed) {
+				packedStart = offset;
+				bit = 0;
+				offset += run * width / 8;
+				if (offset > bytes.length) throw new Error("bounded Parquet truncated bit-packed stream");
+			} else {
+				repeat = 0;
+				for (let b = 0; b < Math.ceil(width / 8); b++) repeat += readByte() * 2 ** (8 * b);
+				if (repeat >= 2 ** width) throw new Error("bounded Parquet RLE value exceeds bit width");
+			}
+		}
+		run--;
+		if (!packed) return repeat;
+		let value = 0;
+		for (let b = 0; b < width; b++, bit++) value += (bytes[packedStart + Math.floor(bit / 8)] >> bit % 8 & 1) * 2 ** b;
+		return value;
+	};
+	return {
+		next,
+		finish() {
+			if (remaining !== 0 || offset !== bytes.length || run && !packed) throw new Error(`bounded Parquet trailing or incomplete RLE data: remaining=${remaining}, offset=${offset}, bytes=${bytes.length}, run=${run}, packed=${packed}, width=${width}`);
+		}
+	};
+}
+function plainCursor(bytes, element, count, maxValueBytes) {
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	let offset = 0;
+	let index = 0;
+	const width = element.type === "BOOLEAN" ? 0 : element.type === "INT32" || element.type === "FLOAT" ? 4 : element.type === "INT96" ? 12 : 8;
+	const decoder = {
+		element,
+		type: element.type,
+		parsers: DEFAULT_PARSERS,
+		schemaPath: []
+	};
+	const take = () => {
+		if (index >= count) throw new Error("bounded Parquet too many plain values");
+		let size = width;
+		if (element.type === "BYTE_ARRAY") {
+			if (offset + 4 > bytes.length) throw new Error("bounded Parquet truncated string length");
+			size = view.getUint32(offset, true);
+			offset += 4;
+			if (size > maxValueBytes) throw new RangeError("bounded Parquet exceeds maxValueBytes");
+		}
+		const start = element.type === "BOOLEAN" ? Math.floor(index / 8) : offset;
+		if (start + (element.type === "BOOLEAN" ? 1 : size) > bytes.length) throw new Error("bounded Parquet truncated plain value");
+		offset = element.type === "BOOLEAN" ? Math.ceil((index + 1) / 8) : offset + size;
+		return {
+			start,
+			size,
+			index: index++
+		};
+	};
+	return {
+		next() {
+			const { start, size, index: bitIndex } = take();
+			return {
+				bytes: 64 + (element.type === "BYTE_ARRAY" ? size * 2 : 32),
+				value() {
+					if (element.type === "BYTE_ARRAY") return utf8.decode(bytes.subarray(start, start + size));
+					let raw = element.type === "BOOLEAN" ? !!(view.getUint8(start) & 1 << bitIndex % 8) : element.type === "INT32" ? view.getInt32(start, true) : element.type === "INT64" ? view.getBigInt64(start, true) : element.type === "INT96" ? BigInt(view.getInt32(start + 8, true)) << 64n | view.getBigInt64(start, true) : element.type === "FLOAT" ? view.getFloat32(start, true) : view.getFloat64(start, true);
+					if (element.type === "INT64" && (element.converted_type === "UINT_64" || element.logical_type?.type === "INTEGER" && !element.logical_type.isSigned)) raw = BigInt.asUintN(64, raw);
+					const result = convert([raw], decoder)[0];
+					return result instanceof Date ? `${result.getUTCFullYear()}-${String(result.getUTCMonth() + 1).padStart(2, "0")}-${String(result.getUTCDate()).padStart(2, "0")}` : result;
+				}
+			};
+		},
+		skip() {
+			take();
+		},
+		position: () => offset,
+		finish() {
+			if (index !== count || offset !== bytes.length) throw new Error("bounded Parquet trailing or incomplete plain data");
+		}
+	};
+}
+export { hybridCursor, plainCursor };

package/dist/node_modules/.pnpm/hyparquet-writer@0.16.10_patch_hash_d26d002aede61ad95dd633d6557b56897cdcbc45dfc3a5d93fa0e9075ad5425f/node_modules/hyparquet-writer/src/index.mjs

@@ -1,7 +1,7 @@
 import { ByteWriter } from "./bytewriter.mjs";
 import "./schema.mjs";
 import "./wkb.mjs";
-import "./parquet-writer.mjs";
+import { ParquetWriter } from "./parquet-writer.mjs";
 import "./write.mjs";
 import { parquetWriteRows } from "./write-rows.mjs";
-export { ByteWriter, parquetWriteRows };
+export { ByteWriter, ParquetWriter, parquetWriteRows };

package/dist/node_modules/.pnpm/hyparquet-writer@0.16.10_patch_hash_d26d002aede61ad95dd633d6557b56897cdcbc45dfc3a5d93fa0e9075ad5425f/node_modules/hyparquet-writer/src/node.mjs

@@ -1,8 +1,8 @@
 import { ByteWriter } from "./bytewriter.mjs";
 import "./schema.mjs";
 import "./wkb.mjs";
-import "./parquet-writer.mjs";
+import { ParquetWriter } from "./parquet-writer.mjs";
 import "./write.mjs";
 import { parquetWriteRows } from "./write-rows.mjs";
 import "./index.mjs";
-export { ByteWriter, parquetWriteRows };
+export { ByteWriter, ParquetWriter, parquetWriteRows };