@gscdump/lakehouse 1.4.0 → 1.4.1

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

@@ -0,0 +1,107 @@
+import { fetchAvroRecords } from "../fetch.mjs";
+import { transformResultType } from "./transform.mjs";
+import { writeManifestList } from "./manifest-list.mjs";
+import { computeFieldSummary } from "./stats.mjs";
+function currentSnapshot(metadata) {
+	const id = metadata["current-snapshot-id"];
+	if (id === void 0) return void 0;
+	return metadata.snapshots?.find((s) => s["snapshot-id"] === id);
+}
+async function loadPriorManifests(metadata, resolver) {
+	const snap = currentSnapshot(metadata);
+	if (!snap?.["manifest-list"]) return [];
+	return await fetchAvroRecords(snap["manifest-list"], resolver);
+}
+async function buildSnapshotUpdate({ tableUrl, metadata, resolver, snapshotId, sequenceNumber, manifestUuid, timestampMs, formatVersion, newManifests, summary, writtenFiles, priorManifests, skipPriorManifestPaths }) {
+	const writerFn = resolver.writer;
+	if (!writerFn) throw new Error("resolver.writer is required");
+	const rowLineage = formatVersion >= 3;
+	const firstRowId = rowLineage ? BigInt(metadata["next-row-id"] ?? 0) : 0n;
+	priorManifests ??= await loadPriorManifests(metadata, resolver);
+	if (skipPriorManifestPaths?.size) priorManifests = priorManifests.filter((manifest) => !skipPriorManifestPaths.has(manifest.manifest_path));
+	const allManifests = [...priorManifests, ...newManifests];
+	const addedRows = rowLineage ? assignFirstRowIds(allManifests, firstRowId) : 0n;
+	const manifestListPath = `${tableUrl}/metadata/snap-${snapshotId}-1-${manifestUuid}.avro`;
+	await writeManifestList({
+		writer: writerFn(manifestListPath),
+		snapshotId,
+		sequenceNumber,
+		manifests: allManifests,
+		formatVersion
+	});
+	const snapshot = {
+		"snapshot-id": Number(snapshotId),
+		"sequence-number": Number(sequenceNumber),
+		"timestamp-ms": timestampMs,
+		"manifest-list": manifestListPath,
+		summary,
+		"schema-id": metadata["current-schema-id"]
+	};
+	if (rowLineage) {
+		snapshot["first-row-id"] = toMetadataLong(firstRowId);
+		snapshot["added-rows"] = toMetadataLong(addedRows);
+	}
+	const rawCurrentSnapshotId = metadata["current-snapshot-id"];
+	const currentSnapshotId = rawCurrentSnapshotId === void 0 || rawCurrentSnapshotId === null || rawCurrentSnapshotId === -1 ? null : rawCurrentSnapshotId;
+	if (currentSnapshotId !== null) snapshot["parent-snapshot-id"] = currentSnapshotId;
+	const requirements = [{
+		type: "assert-table-uuid",
+		uuid: metadata["table-uuid"]
+	}, {
+		type: "assert-ref-snapshot-id",
+		ref: "main",
+		"snapshot-id": currentSnapshotId
+	}];
+	if (rowLineage) requirements.push({
+		type: "assert-next-row-id",
+		"next-row-id": toMetadataLong(metadata["next-row-id"] ?? 0)
+	});
+	return {
+		snapshot,
+		requirements,
+		updates: [{
+			action: "add-snapshot",
+			snapshot
+		}, {
+			action: "set-snapshot-ref",
+			"ref-name": "main",
+			type: "branch",
+			"snapshot-id": snapshot["snapshot-id"]
+		}],
+		writtenFiles: [...writtenFiles, manifestListPath]
+	};
+}
+function buildPartitionSummaries(partitions, schema, partitionSpec) {
+	return partitionSpec.fields.map((pf) => {
+		const sourceField = schema.fields.find((f) => f.id === pf["source-id"]);
+		if (!sourceField) throw new Error(`partition source field id ${pf["source-id"]} not found`);
+		const resultType = transformResultType(pf.transform, sourceField.type);
+		return computeFieldSummary(partitions.map((p) => p[pf.name]), resultType);
+	});
+}
+function assignFirstRowIds(manifests, firstRowId) {
+	let nextFirstRowId = firstRowId;
+	let assignedRows = 0n;
+	for (const manifest of manifests) {
+		if (manifest.content !== 0) {
+			manifest.first_row_id = void 0;
+			continue;
+		}
+		const rowIdRange = BigInt(manifest.added_rows_count ?? 0) + BigInt(manifest.existing_rows_count ?? 0);
+		if (manifest.first_row_id == null) {
+			manifest.first_row_id = nextFirstRowId;
+			nextFirstRowId += rowIdRange;
+			assignedRows += rowIdRange;
+		} else {
+			const manifestEnd = BigInt(manifest.first_row_id) + rowIdRange;
+			if (manifestEnd > nextFirstRowId) nextFirstRowId = manifestEnd;
+		}
+	}
+	return assignedRows;
+}
+function toMetadataLong(value) {
+	const out = Number(value);
+	if (!Number.isSafeInteger(out)) throw new Error(`metadata long exceeds JavaScript safe integer range: ${value}`);
+	return out;
+}
+export { buildPartitionSummaries, buildSnapshotUpdate, currentSnapshot, loadPriorManifests };

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

@@ -0,0 +1,47 @@
+import { applyTransform, transformResultType } from "./transform.mjs";
+import { compare } from "./serde.mjs";
+function buildSortComparator(sortOrder, schema) {
+	if (!sortOrder?.fields?.length) return void 0;
+	const fields = sortOrder.fields.map((sf) => {
+		const sourceId = sf["source-id"] ?? sf["source-ids"]?.[0];
+		const sourceField = schema.fields.find((f) => f.id === sourceId);
+		if (!sourceField) throw new Error(`sort source field id ${sourceId} not found in schema`);
+		return {
+			name: sourceField.name,
+			transform: sf.transform,
+			sourceType: sourceField.type,
+			resultType: transformResultType(sf.transform, sourceField.type),
+			desc: sf.direction === "desc",
+			nullsFirst: sf["null-order"] === "nulls-first"
+		};
+	});
+	return (a, b) => {
+		for (const f of fields) {
+			const c = compareKeys(sortKey(a[f.name], f.transform, f.sourceType), sortKey(b[f.name], f.transform, f.sourceType), f.resultType, f.desc, f.nullsFirst);
+			if (c !== 0) return c;
+		}
+		return 0;
+	};
+}
+function sortKey(value, transform, sourceType) {
+	if (value === null || value === void 0) return null;
+	if (transform === "identity") return value;
+	return applyTransform(transform, value, sourceType);
+}
+function compareKeys(ka, kb, resultType, desc, nullsFirst) {
+	const aNull = ka === null || ka === void 0;
+	const bNull = kb === null || kb === void 0;
+	if (aNull && bNull) return 0;
+	if (aNull) return nullsFirst ? -1 : 1;
+	if (bNull) return nullsFirst ? 1 : -1;
+	const aNaN = typeof ka === "number" && Number.isNaN(ka);
+	const bNaN = typeof kb === "number" && Number.isNaN(kb);
+	if (aNaN || bNaN) {
+		if (aNaN && bNaN) return 0;
+		const c = aNaN ? 1 : -1;
+		return desc ? -c : c;
+	}
+	const c = compare(ka, kb, resultType);
+	return desc ? -c : c;
+}
+export { buildSortComparator };

package/dist/node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/write/stage-deletion-vector.mjs

@@ -0,0 +1,11 @@
+import "../puffin/deletion-vector.mjs";
+import "../puffin/puffin.mjs";
+import "../utils.mjs";
+import "../fetch.mjs";
+import "../schema.mjs";
+import "../delete.mjs";
+import "./manifest.mjs";
+import "./snapshot.mjs";
+import "./stage.mjs";
+import "./stage-position-delete.mjs";
+export {};

package/dist/node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/write/stage-position-delete.mjs

@@ -0,0 +1,8 @@
+import "../utils.mjs";
+import "../fetch.mjs";
+import "../schema.mjs";
+import "./manifest.mjs";
+import "./snapshot.mjs";
+import "./stage.mjs";
+import "./delete-file.mjs";
+export {};

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

@@ -0,0 +1,237 @@
+import { uuid4 } from "../utils.mjs";
+import { validateSchemaForVersion } from "../schema.mjs";
+import { groupByPartition } from "./partition.mjs";
+import "./commit.mjs";
+import { writeDataManifest } from "./manifest.mjs";
+import { computeColumnStats } from "./stats.mjs";
+import { buildPartitionSummaries, buildSnapshotUpdate, currentSnapshot } from "./snapshot.mjs";
+import { writeParquet } from "./parquet.mjs";
+import { buildSortComparator } from "./sort.mjs";
+async function prepareAppend({ tableUrl, metadata, records, resolver, sortOrderId, snapshotId }) {
+	if (!tableUrl) throw new Error("tableUrl is required");
+	if (!resolver?.writer) throw new Error("resolver.writer is required");
+	const writerFn = resolver.writer;
+	if (metadata["format-version"] !== 2 && metadata["format-version"] !== 3) throw new Error(`unsupported format-version: ${metadata["format-version"]}`);
+	const formatVersion = metadata["format-version"];
+	const partitionSpec = metadata["partition-specs"].find((s) => s["spec-id"] === metadata["default-spec-id"]);
+	if (!partitionSpec) throw new Error("default partition spec not found in metadata");
+	const schema = metadata.schemas.find((s) => s["schema-id"] === metadata["current-schema-id"]);
+	if (!schema) throw new Error("current schema not found in metadata");
+	validateSchemaForVersion(schema, formatVersion);
+	const appendSnapshotId = snapshotId ?? newSnapshotId(metadata);
+	const manifestUuid = uuid4();
+	checkWriteFormat(metadata.properties?.["write.format.default"]);
+	const codec = resolveParquetCodec(metadata.properties?.["write.parquet.compression-codec"]);
+	const orderId = sortOrderId ?? metadata["default-sort-order-id"] ?? 0;
+	const sortOrder = (metadata["sort-orders"] ?? []).find((o) => o["order-id"] === orderId);
+	if (sortOrderId !== void 0 && !sortOrder) throw new Error(`sort order ${sortOrderId} not found in metadata`);
+	const comparator = buildSortComparator(sortOrder, schema);
+	const appliedSortOrderId = comparator ? orderId : 0;
+	const groups = partitionSpec.fields.length ? groupByPartition(records, schema, partitionSpec) : [{
+		partition: {},
+		records
+	}];
+	const writtenDataFiles = await Promise.all(groups.map(async (group) => {
+		const sortedRecords = comparator ? [...group.records].sort(comparator) : group.records;
+		const dataPath = `${tableUrl}/data/${uuid4()}.parquet`;
+		const dataWriter = writerFn(dataPath);
+		await writeParquet({
+			writer: dataWriter,
+			schema,
+			records: sortedRecords,
+			codec
+		});
+		const stats = computeColumnStats(sortedRecords, schema);
+		return {
+			partition: group.partition,
+			records: sortedRecords,
+			dataFile: {
+				content: 0,
+				file_path: dataPath,
+				file_format: "parquet",
+				partition: group.partition,
+				record_count: BigInt(sortedRecords.length),
+				file_size_in_bytes: BigInt(dataWriter.offset),
+				value_counts: stats.value_counts,
+				null_value_counts: stats.null_value_counts,
+				nan_value_counts: stats.nan_value_counts,
+				lower_bounds: stats.lower_bounds,
+				upper_bounds: stats.upper_bounds,
+				sort_order_id: appliedSortOrderId
+			},
+			path: dataPath
+		};
+	}));
+	const manifestPath = `${tableUrl}/metadata/${manifestUuid}-m0.avro`;
+	const manifestWriter = writerFn(manifestPath);
+	await writeDataManifest({
+		writer: manifestWriter,
+		schema,
+		partitionSpec,
+		snapshotId: appendSnapshotId,
+		dataFiles: writtenDataFiles.map((f) => f.dataFile),
+		formatVersion
+	});
+	const manifestLength = BigInt(manifestWriter.offset);
+	const addedRowCount = writtenDataFiles.reduce((sum, f) => sum + BigInt(f.records.length), 0n);
+	const addedFilesSize = writtenDataFiles.reduce((sum, f) => sum + f.dataFile.file_size_in_bytes, 0n);
+	const partitions = buildPartitionSummaries(writtenDataFiles.map((f) => f.dataFile.partition), schema, partitionSpec);
+	return {
+		snapshotId: appendSnapshotId,
+		manifestUuid,
+		formatVersion,
+		manifestPath,
+		manifestLength,
+		partitionSpecId: partitionSpec["spec-id"],
+		partitions,
+		addedDataFilesCount: writtenDataFiles.length,
+		addedRowCount,
+		addedFilesSize,
+		recordsCount: records.length,
+		writtenFiles: [...writtenDataFiles.map((f) => f.path), manifestPath]
+	};
+}
+async function stageSnapshotForAppend({ tableUrl, metadata, prepared, resolver, snapshotProperties }) {
+	if (!tableUrl) throw new Error("tableUrl is required");
+	if (!resolver?.writer) throw new Error("resolver.writer is required");
+	const sequenceNumber = BigInt(metadata["last-sequence-number"] ?? 0) + 1n;
+	const timestampMs = Date.now();
+	const newManifest = {
+		manifest_path: prepared.manifestPath,
+		manifest_length: prepared.manifestLength,
+		partition_spec_id: prepared.partitionSpecId,
+		content: 0,
+		sequence_number: sequenceNumber,
+		min_sequence_number: sequenceNumber,
+		added_snapshot_id: prepared.snapshotId,
+		added_files_count: prepared.addedDataFilesCount,
+		existing_files_count: 0,
+		deleted_files_count: 0,
+		added_rows_count: prepared.addedRowCount,
+		existing_rows_count: 0n,
+		deleted_rows_count: 0n,
+		partitions: prepared.partitions
+	};
+	const prevSummary = currentSnapshot(metadata)?.summary;
+	const prevTotals = {
+		records: BigInt(prevSummary?.["total-records"] ?? "0"),
+		size: BigInt(prevSummary?.["total-files-size"] ?? "0"),
+		files: BigInt(prevSummary?.["total-data-files"] ?? "0")
+	};
+	const summary = {
+		operation: "append",
+		"added-data-files": String(prepared.addedDataFilesCount),
+		"added-records": String(prepared.recordsCount),
+		"added-files-size": String(prepared.addedFilesSize),
+		"changed-partition-count": String(prepared.addedDataFilesCount),
+		"total-records": String(prevTotals.records + BigInt(prepared.recordsCount)),
+		"total-files-size": String(prevTotals.size + prepared.addedFilesSize),
+		"total-data-files": String(prevTotals.files + BigInt(prepared.addedDataFilesCount)),
+		"total-delete-files": "0",
+		"total-position-deletes": "0",
+		"total-equality-deletes": "0",
+		...snapshotProperties ?? {}
+	};
+	return await buildSnapshotUpdate({
+		tableUrl,
+		metadata,
+		resolver,
+		snapshotId: prepared.snapshotId,
+		sequenceNumber,
+		manifestUuid: prepared.manifestUuid,
+		timestampMs,
+		formatVersion: prepared.formatVersion,
+		newManifests: [newManifest],
+		summary,
+		writtenFiles: []
+	});
+}
+async function stageSnapshotForAppendBatches({ tableUrl, metadata, prepared, resolver, snapshotProperties }) {
+	if (!tableUrl) throw new Error("tableUrl is required");
+	if (!resolver?.writer) throw new Error("resolver.writer is required");
+	if (prepared.length === 0) throw new Error("prepared batches must not be empty");
+	const first = prepared[0];
+	for (const batch of prepared) {
+		if (batch.snapshotId !== first.snapshotId) throw new Error("prepared batches must share one snapshot id");
+		if (batch.formatVersion !== first.formatVersion) throw new Error("prepared batches must share one format version");
+	}
+	const sequenceNumber = BigInt(metadata["last-sequence-number"] ?? 0) + 1n;
+	const timestampMs = Date.now();
+	const newManifests = prepared.map((batch) => ({
+		manifest_path: batch.manifestPath,
+		manifest_length: batch.manifestLength,
+		partition_spec_id: batch.partitionSpecId,
+		content: 0,
+		sequence_number: sequenceNumber,
+		min_sequence_number: sequenceNumber,
+		added_snapshot_id: first.snapshotId,
+		added_files_count: batch.addedDataFilesCount,
+		existing_files_count: 0,
+		deleted_files_count: 0,
+		added_rows_count: batch.addedRowCount,
+		existing_rows_count: 0n,
+		deleted_rows_count: 0n,
+		partitions: batch.partitions
+	}));
+	const addedDataFilesCount = prepared.reduce((sum, batch) => sum + batch.addedDataFilesCount, 0);
+	const recordsCount = prepared.reduce((sum, batch) => sum + batch.recordsCount, 0);
+	const addedFilesSize = prepared.reduce((sum, batch) => sum + batch.addedFilesSize, 0n);
+	const prevSummary = currentSnapshot(metadata)?.summary;
+	const prevTotals = {
+		records: BigInt(prevSummary?.["total-records"] ?? "0"),
+		size: BigInt(prevSummary?.["total-files-size"] ?? "0"),
+		files: BigInt(prevSummary?.["total-data-files"] ?? "0")
+	};
+	const summary = {
+		operation: "append",
+		"added-data-files": String(addedDataFilesCount),
+		"added-records": String(recordsCount),
+		"added-files-size": String(addedFilesSize),
+		"changed-partition-count": String(addedDataFilesCount),
+		"total-records": String(prevTotals.records + BigInt(recordsCount)),
+		"total-files-size": String(prevTotals.size + addedFilesSize),
+		"total-data-files": String(prevTotals.files + BigInt(addedDataFilesCount)),
+		"total-delete-files": "0",
+		"total-position-deletes": "0",
+		"total-equality-deletes": "0",
+		...snapshotProperties ?? {}
+	};
+	return await buildSnapshotUpdate({
+		tableUrl,
+		metadata,
+		resolver,
+		snapshotId: first.snapshotId,
+		sequenceNumber,
+		manifestUuid: first.manifestUuid,
+		timestampMs,
+		formatVersion: first.formatVersion,
+		newManifests,
+		summary,
+		writtenFiles: []
+	});
+}
+function checkWriteFormat(value) {
+	if (value === void 0) return;
+	if (value.toLowerCase() !== "parquet") throw new Error(`unsupported write.format.default: ${value}`);
+}
+function resolveParquetCodec(value) {
+	if (value === void 0) return void 0;
+	switch (value.toLowerCase()) {
+		case "snappy": return "SNAPPY";
+		case "none":
+		case "uncompressed": return "UNCOMPRESSED";
+		default: throw new Error(`unsupported write.parquet.compression-codec: ${value}`);
+	}
+}
+function newSnapshotId(metadata) {
+	const used = new Set((metadata?.snapshots ?? []).map((s) => BigInt(s["snapshot-id"])));
+	const arr = /* @__PURE__ */ new BigInt64Array(1);
+	for (let attempt = 0; attempt < 32; attempt++) {
+		globalThis.crypto.getRandomValues(arr);
+		const masked = arr[0] & 9007199254740991n;
+		const id = masked === 0n ? 1n : masked;
+		if (!used.has(id)) return id;
+	}
+	throw new Error("newSnapshotId: failed to find an unused id after 32 attempts");
+}
+export { checkWriteFormat, newSnapshotId, prepareAppend, resolveParquetCodec, stageSnapshotForAppend, stageSnapshotForAppendBatches };

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

@@ -0,0 +1,153 @@
+import { typeName } from "../schema.mjs";
+import { computeGeoBounds, isGeoType } from "./geospatial.mjs";
+import { compare, serializeValue } from "./serde.mjs";
+const TRUNCATE_LIMIT = 16;
+function computeColumnStats(records, schema) {
+	const value_counts = {};
+	const null_value_counts = {};
+	const nan_value_counts = {};
+	const lower_bounds = {};
+	const upper_bounds = {};
+	for (const field of schema.fields) {
+		const type = typeName(field.type);
+		if (type === "unknown") continue;
+		if (type === "list" || type === "map" || type === "struct") continue;
+		if (isGeoType(type)) {
+			const { value_count, null_count, lower, upper } = computeGeoBounds(records, field);
+			value_counts[field.id] = value_count;
+			null_value_counts[field.id] = null_count;
+			if (lower) lower_bounds[field.id] = lower;
+			if (upper) upper_bounds[field.id] = upper;
+			continue;
+		}
+		let nulls = 0n;
+		let nans = 0n;
+		let min;
+		let max;
+		const isFloat = type === "float" || type === "double";
+		const trackBounds = hasComparableBounds(field.type);
+		const writeDefault = field["write-default"];
+		for (const record of records) {
+			let v = record[field.name];
+			if (v === void 0 && writeDefault !== void 0) v = writeDefault;
+			if (v === null || v === void 0) {
+				nulls++;
+				continue;
+			}
+			if (isFloat && Number.isNaN(v)) {
+				nans++;
+				continue;
+			}
+			if (trackBounds) {
+				if (min === void 0 || compare(v, min, field.type) < 0) min = v;
+				if (max === void 0 || compare(v, max, field.type) > 0) max = v;
+			}
+		}
+		value_counts[field.id] = BigInt(records.length);
+		null_value_counts[field.id] = nulls;
+		if (isFloat) nan_value_counts[field.id] = nans;
+		if (min !== void 0) {
+			const lo = serializeValue(truncateLower(min, field.type), field.type);
+			if (lo) lower_bounds[field.id] = lo;
+		}
+		if (max !== void 0) {
+			const truncated = truncateUpper(max, field.type);
+			if (truncated !== void 0) {
+				const hi = serializeValue(truncated, field.type);
+				if (hi) upper_bounds[field.id] = hi;
+			}
+		}
+	}
+	return {
+		value_counts,
+		null_value_counts,
+		nan_value_counts,
+		lower_bounds,
+		upper_bounds
+	};
+}
+function hasComparableBounds(type) {
+	const name = typeName(type);
+	if (isGeoType(name)) return false;
+	return name !== "unknown" && name !== "variant";
+}
+function computeFieldSummary(values, type) {
+	const name = typeName(type);
+	const isFloat = name === "float" || name === "double";
+	const trackBounds = hasComparableBounds(type);
+	let containsNull = false;
+	let containsNan = false;
+	let min;
+	let max;
+	for (const v of values) {
+		if (v === null || v === void 0) {
+			containsNull = true;
+			continue;
+		}
+		if (isFloat && Number.isNaN(v)) {
+			containsNan = true;
+			continue;
+		}
+		if (trackBounds) {
+			if (min === void 0 || compare(v, min, type) < 0) min = v;
+			if (max === void 0 || compare(v, max, type) > 0) max = v;
+		}
+	}
+	const summary = { contains_null: containsNull };
+	if (isFloat) summary.contains_nan = containsNan;
+	if (min !== void 0) {
+		const lo = serializeValue(truncateLower(min, type), type);
+		if (lo) summary.lower_bound = lo;
+	}
+	if (max !== void 0) {
+		const truncated = truncateUpper(max, type);
+		if (truncated !== void 0) {
+			const hi = serializeValue(truncated, type);
+			if (hi) summary.upper_bound = hi;
+		}
+	}
+	return summary;
+}
+function truncateLower(value, type) {
+	const name = typeName(type);
+	if (name === "string" && typeof value === "string") {
+		const cps = Array.from(value);
+		if (cps.length <= TRUNCATE_LIMIT) return value;
+		return cps.slice(0, TRUNCATE_LIMIT).join("");
+	}
+	if ((name === "binary" || name.startsWith("fixed[")) && value instanceof Uint8Array) {
+		if (value.length <= TRUNCATE_LIMIT) return value;
+		return value.slice(0, TRUNCATE_LIMIT);
+	}
+	return value;
+}
+function truncateUpper(value, type) {
+	const name = typeName(type);
+	if (name === "string" && typeof value === "string") {
+		const cps = Array.from(value);
+		if (cps.length <= TRUNCATE_LIMIT) return value;
+		const prefix = cps.slice(0, TRUNCATE_LIMIT);
+		while (prefix.length > 0) {
+			const cp = prefix[prefix.length - 1].codePointAt(0);
+			const next = cp + 1 === 55296 ? 57344 : cp + 1;
+			if (next <= 1114111) {
+				prefix[prefix.length - 1] = String.fromCodePoint(next);
+				return prefix.join("");
+			}
+			prefix.pop();
+		}
+		return;
+	}
+	if ((name === "binary" || name.startsWith("fixed[")) && value instanceof Uint8Array) {
+		if (value.length <= TRUNCATE_LIMIT) return value;
+		const prefix = value.slice(0, TRUNCATE_LIMIT);
+		for (let i = prefix.length - 1; i >= 0; i--) if (prefix[i] < 255) {
+			const out = prefix.slice(0, i + 1);
+			out[i]++;
+			return out;
+		}
+		return;
+	}
+	return value;
+}
+export { computeColumnStats, computeFieldSummary };