@gscdump/lakehouse 1.4.1 → 1.4.3

package/dist/{node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057 → _virtual/node_modules/.pnpm/icebird@0.8.15_patch_hash=d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057}/node_modules/icebird/src/utils.mjs

@@ -11,6 +11,25 @@ function sanitize(name) {
 	}
 	return result;
 }
+function equalityMatch(row, deletePredicate, columnNamesById) {
+	for (const key of Object.keys(deletePredicate)) {
+		const columnName = columnNamesById ? columnNamesById[Number(key)] : key;
+		if (columnName === "file_path" || columnName === "pos") continue;
+		if (!columnName) return false;
+		if (!valuesEqual(row[columnName], deletePredicate[key])) return false;
+	}
+	return true;
+}
+function valuesEqual(a, b) {
+	if (typeof a === "number" && typeof b === "number" && Number.isNaN(a) && Number.isNaN(b)) return true;
+	if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+	if (a instanceof Uint8Array && b instanceof Uint8Array) {
+		if (a.length !== b.length) return false;
+		for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+		return true;
+	}
+	return a === b;
+}
 function bytesToHex(bytes) {
 	let hex = "";
 	for (let i = 0; i < bytes.length; i++) hex += bytes[i].toString(16).padStart(2, "0");
@@ -23,4 +42,4 @@ function uuid4() {
 		return (c === "x" ? r : r & 3 | 8).toString(16);
 	});
 }
-export { bytesToHex, sanitize, uuid4 };
+export { bytesToHex, equalityMatch, sanitize, uuid4, valuesEqual };

package/dist/_virtual/node_modules/.pnpm/icebird@0.8.15_patch_hash=d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/write/delete-file.mjs

@@ -0,0 +1,52 @@
+import { computeColumnStats } from "./stats.mjs";
+import { writeParquet } from "./parquet.mjs";
+const POSITION_DELETE_SCHEMA = {
+	type: "struct",
+	"schema-id": 0,
+	fields: [{
+		id: 2147483546,
+		name: "file_path",
+		required: true,
+		type: "string"
+	}, {
+		id: 2147483545,
+		name: "pos",
+		required: true,
+		type: "long"
+	}]
+};
+async function writePositionDeleteFile({ writer, deletes, codec }) {
+	if (!deletes?.length) throw new Error("writePositionDeleteFile requires at least one delete");
+	const records = deletes.map((d) => {
+		if (typeof d.file_path !== "string" || !d.file_path) throw new Error("position delete file_path must be a non-empty string");
+		if (d.pos === void 0 || d.pos === null) throw new Error("position delete pos is required");
+		const pos = typeof d.pos === "bigint" ? d.pos : BigInt(d.pos);
+		if (pos < 0n) throw new Error(`position delete pos must be non-negative: ${pos}`);
+		return {
+			file_path: d.file_path,
+			pos
+		};
+	});
+	records.sort((a, b) => {
+		if (a.file_path < b.file_path) return -1;
+		if (a.file_path > b.file_path) return 1;
+		if (a.pos < b.pos) return -1;
+		if (a.pos > b.pos) return 1;
+		return 0;
+	});
+	await writeParquet({
+		writer,
+		schema: POSITION_DELETE_SCHEMA,
+		records,
+		codec
+	});
+	const { value_counts, null_value_counts, lower_bounds, upper_bounds } = computeColumnStats(records, POSITION_DELETE_SCHEMA);
+	return {
+		record_count: BigInt(records.length),
+		value_counts,
+		null_value_counts,
+		lower_bounds,
+		upper_bounds
+	};
+}
+export { writePositionDeleteFile };

package/dist/{node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057 → _virtual/node_modules/.pnpm/icebird@0.8.15_patch_hash=d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057}/node_modules/icebird/src/write/manifest.mjs

@@ -176,6 +176,50 @@ function writeDataManifest({ writer, schema, partitionSpec, snapshotId, dataFile
 		}
 	});
 }
+function writeDeleteManifest({ writer, schema, partitionSpec, snapshotId, deleteFiles, formatVersion = 2 }) {
+	const records = deleteFiles.map((deleteFile) => {
+		if (deleteFile.content !== 1 && deleteFile.content !== 2) throw new Error(`writeDeleteManifest expects delete files (content=1 or 2), got content=${deleteFile.content}`);
+		if (deleteFile.content === 2 && !deleteFile.equality_ids?.length) throw new Error("equality delete file missing equality_ids");
+		return manifestEntryRecord(deleteFile, schema, partitionSpec, snapshotId, formatVersion, 1);
+	});
+	return avroWrite({
+		writer,
+		schema: manifestEntrySchema(schema, partitionSpec, formatVersion, 1),
+		records,
+		metadata: {
+			"format-version": String(formatVersion),
+			content: "deletes",
+			schema: icebergSchemaJson(schema),
+			"partition-spec": partitionSpecJson(partitionSpec),
+			"partition-spec-id": String(partitionSpec["spec-id"])
+		}
+	});
+}
+function writeExistingDeleteManifest({ writer, schema, partitionSpec, entries, formatVersion = 2 }) {
+	const records = entries.map((entry) => {
+		const deleteFile = entry.data_file;
+		if (deleteFile.content !== 1 && deleteFile.content !== 2) throw new Error(`writeExistingDeleteManifest expects delete files (content=1 or 2), got content=${deleteFile.content}`);
+		const record = manifestEntryRecord(deleteFile, schema, partitionSpec, 0n, formatVersion, 1);
+		record.status = 0;
+		record.snapshot_id = entry.snapshot_id ?? null;
+		record.sequence_number = entry.sequence_number ?? null;
+		record.file_sequence_number = entry.file_sequence_number ?? null;
+		if (record.sequence_number == null || record.file_sequence_number == null) throw new Error("existing delete manifest entry missing sequence numbers");
+		return record;
+	});
+	return avroWrite({
+		writer,
+		schema: manifestEntrySchema(schema, partitionSpec, formatVersion, 1),
+		records,
+		metadata: {
+			"format-version": String(formatVersion),
+			content: "deletes",
+			schema: icebergSchemaJson(schema),
+			"partition-spec": partitionSpecJson(partitionSpec),
+			"partition-spec-id": String(partitionSpec["spec-id"])
+		}
+	});
+}
 function manifestEntryRecord(dataFile, schema, partitionSpec, snapshotId, formatVersion, manifestContent) {
 	const dataFileRecord = {
 		content: dataFile.content,
@@ -209,4 +253,4 @@ function manifestEntryRecord(dataFile, schema, partitionSpec, snapshotId, format
 		data_file: dataFileRecord
 	};
 }
-export { writeDataManifest };
+export { writeDataManifest, writeDeleteManifest, writeExistingDeleteManifest };

package/dist/{node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057 → _virtual/node_modules/.pnpm/icebird@0.8.15_patch_hash=d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057}/node_modules/icebird/src/write/parquet.mjs

@@ -1,5 +1,5 @@
-import { parquetWrite } from "../../../../../hyparquet-writer@0.16.1_patch_hash_7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/src/write.mjs";
-import "../../../../../hyparquet-writer@0.16.1_patch_hash_7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/src/node.mjs";
+import { parquetWrite } from "../../../../../hyparquet-writer@0.16.1_patch_hash=7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/src/write.mjs";
+import "../../../../../hyparquet-writer@0.16.1_patch_hash=7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/src/node.mjs";
 import { sanitize } from "../utils.mjs";
 import { typeName } from "../schema.mjs";
 import { decimalRequiredBytes, parseDecimalType } from "./conversions.mjs";

package/dist/_virtual/node_modules/.pnpm/icebird@0.8.15_patch_hash=d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/write/rewrite.mjs

@@ -0,0 +1,174 @@
+import { uuid4 } from "../utils.mjs";
+import { groupByPartition } from "./partition.mjs";
+import { writeDataManifest } from "./manifest.mjs";
+import { computeColumnStats } from "./stats.mjs";
+import { buildPartitionSummaries, buildSnapshotUpdate, currentSnapshot, loadPriorManifests } from "./snapshot.mjs";
+import { writeParquet } from "./parquet.mjs";
+import { buildSortComparator } from "./sort.mjs";
+import { checkWriteFormat, newSnapshotId, resolveParquetCodec } from "./stage.mjs";
+import { icebergRead } from "../read.mjs";
+async function icebergStageRewrite({ tableUrl, metadata, resolver, sortOrderId, partitionSpecId, targetFileRows }) {
+	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"];
+	if (targetFileRows !== void 0 && !(targetFileRows > 0)) throw new Error("targetFileRows must be a positive number");
+	if (!currentSnapshot(metadata)) throw new Error("no current snapshot to rewrite");
+	const schema = metadata.schemas.find((s) => s["schema-id"] === metadata["current-schema-id"]);
+	if (!schema) throw new Error("current schema not found in metadata");
+	const specId = partitionSpecId ?? metadata["default-spec-id"];
+	const partitionSpec = metadata["partition-specs"].find((s) => s["spec-id"] === specId);
+	if (!partitionSpec) throw new Error(`partition spec ${specId} not found in metadata`);
+	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;
+	checkWriteFormat(metadata.properties?.["write.format.default"]);
+	const codec = resolveParquetCodec(metadata.properties?.["write.parquet.compression-codec"]);
+	const liveRows = await icebergRead({
+		tableUrl,
+		metadata,
+		resolver
+	});
+	const sortedRows = comparator ? [...liveRows].sort(comparator) : liveRows;
+	const rowLineage = formatVersion >= 3;
+	const allLineage = rowLineage && liveRows.length > 0 && liveRows.every((r) => r._row_id != null && r._last_updated_sequence_number != null);
+	const minRowId = allLineage ? liveRows.reduce((min, r) => r._row_id < min ? r._row_id : min, liveRows[0]._row_id) : void 0;
+	const groups = partitionSpec.fields.length ? groupByPartition(sortedRows, schema, partitionSpec) : [{
+		partition: {},
+		records: sortedRows
+	}];
+	const snapshotId = newSnapshotId(metadata);
+	const manifestUuid = uuid4();
+	const writeSchema = rowLineage ? {
+		...schema,
+		fields: [
+			...schema.fields,
+			{
+				id: 2147483540,
+				name: "_row_id",
+				required: false,
+				type: "long"
+			},
+			{
+				id: 2147483539,
+				name: "_last_updated_sequence_number",
+				required: false,
+				type: "long"
+			}
+		]
+	} : schema;
+	const writtenDataFiles = [];
+	for (const group of groups) {
+		const chunks = targetFileRows ? chunkRecords(group.records, targetFileRows) : [group.records];
+		for (const chunk of chunks) {
+			if (chunk.length === 0) continue;
+			const dataPath = `${tableUrl}/data/${uuid4()}.parquet`;
+			const dataWriter = writerFn(dataPath);
+			await writeParquet({
+				writer: dataWriter,
+				schema: writeSchema,
+				records: chunk,
+				codec
+			});
+			const stats = computeColumnStats(chunk, schema);
+			writtenDataFiles.push({
+				partition: group.partition,
+				dataFile: {
+					content: 0,
+					file_path: dataPath,
+					file_format: "parquet",
+					partition: group.partition,
+					record_count: BigInt(chunk.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,
+		dataFiles: writtenDataFiles.map((f) => f.dataFile),
+		formatVersion
+	});
+	const manifestLength = BigInt(manifestWriter.offset);
+	const sequenceNumber = BigInt(metadata["last-sequence-number"] ?? 0) + 1n;
+	const timestampMs = Date.now();
+	const addedRowCount = writtenDataFiles.reduce((sum, f) => sum + f.dataFile.record_count, 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);
+	const newManifest = {
+		manifest_path: manifestPath,
+		manifest_length: manifestLength,
+		partition_spec_id: partitionSpec["spec-id"],
+		content: 0,
+		sequence_number: sequenceNumber,
+		min_sequence_number: sequenceNumber,
+		added_snapshot_id: snapshotId,
+		added_files_count: writtenDataFiles.length,
+		existing_files_count: 0,
+		deleted_files_count: 0,
+		added_rows_count: addedRowCount,
+		existing_rows_count: 0n,
+		deleted_rows_count: 0n,
+		partitions
+	};
+	if (allLineage) newManifest.first_row_id = minRowId;
+	const priorManifests = await loadPriorManifests(metadata, resolver);
+	const skipPriorManifestPaths = new Set(priorManifests.map((m) => m.manifest_path));
+	let deletedDataFiles = 0;
+	let deletedRecords = 0n;
+	for (const m of priorManifests) {
+		if (m.content !== 0) continue;
+		deletedDataFiles += (m.added_files_count ?? 0) + (m.existing_files_count ?? 0);
+		deletedRecords += BigInt(m.added_rows_count ?? 0) + BigInt(m.existing_rows_count ?? 0);
+	}
+	const summary = {
+		operation: "replace",
+		"added-data-files": String(writtenDataFiles.length),
+		"added-records": String(addedRowCount),
+		"added-files-size": String(addedFilesSize),
+		"deleted-data-files": String(deletedDataFiles),
+		"deleted-records": String(deletedRecords),
+		"total-records": String(addedRowCount),
+		"total-files-size": String(addedFilesSize),
+		"total-data-files": String(writtenDataFiles.length),
+		"total-delete-files": "0",
+		"total-position-deletes": "0",
+		"total-equality-deletes": "0"
+	};
+	return await buildSnapshotUpdate({
+		tableUrl,
+		metadata,
+		resolver,
+		snapshotId,
+		sequenceNumber,
+		manifestUuid,
+		timestampMs,
+		formatVersion,
+		newManifests: [newManifest],
+		summary,
+		writtenFiles: [...writtenDataFiles.map((f) => f.path), manifestPath],
+		priorManifests,
+		skipPriorManifestPaths
+	});
+}
+function chunkRecords(arr, size) {
+	const out = [];
+	for (let i = 0; i < arr.length; i += size) out.push(arr.slice(i, i + size));
+	return out;
+}
+export { icebergStageRewrite };

package/dist/_virtual/node_modules/.pnpm/icebird@0.8.15_patch_hash=d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/write/stage-deletion-vector.mjs

@@ -0,0 +1,295 @@
+import { writeDeletionVector } from "../puffin/deletion-vector.mjs";
+import { writePuffinFile } from "../puffin/puffin.mjs";
+import { uuid4 } from "../utils.mjs";
+import { fetchDeleteMaps } from "../fetch.mjs";
+import { validateSchemaForVersion } from "../schema.mjs";
+import { deleteFileAppliesToDataEntry } from "../delete.mjs";
+import { writeDeleteManifest, writeExistingDeleteManifest } from "./manifest.mjs";
+import { buildPartitionSummaries, buildSnapshotUpdate, currentSnapshot, loadPriorManifests } from "./snapshot.mjs";
+import { checkWriteFormat, newSnapshotId } from "./stage.mjs";
+import { findDataFileEntries, loadManifestEntries, partitionTupleKey } from "./stage-position-delete.mjs";
+async function icebergStageDeletionVector({ tableUrl, metadata, deletes, resolver }) {
+	if (!tableUrl) throw new Error("tableUrl is required");
+	if (!resolver?.writer) throw new Error("resolver.writer is required");
+	if (!Array.isArray(deletes) || !deletes.length) throw new Error("deletes must be a non-empty array");
+	const writerFn = resolver.writer;
+	if (metadata["format-version"] !== 3) throw new Error("icebergStageDeletionVector requires format-version 3");
+	const formatVersion = 3;
+	if (!metadata["partition-specs"].find((s) => s["spec-id"] === metadata["default-spec-id"])) 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 snapshotId = newSnapshotId();
+	const sequenceNumber = BigInt(metadata["last-sequence-number"] ?? 0) + 1n;
+	const manifestUuid = uuid4();
+	const timestampMs = Date.now();
+	checkWriteFormat(metadata.properties?.["write.format.default"]);
+	const dataFileMap = await findDataFileEntries(metadata, resolver);
+	const byFile = /* @__PURE__ */ new Map();
+	for (const d of deletes) {
+		if (typeof d.file_path !== "string" || !d.file_path) throw new Error("deletion vector file_path must be a non-empty string");
+		if (d.pos === void 0 || d.pos === null) throw new Error("deletion vector pos is required");
+		const pos = typeof d.pos === "bigint" ? d.pos : BigInt(d.pos);
+		if (pos < 0n) throw new Error(`deletion vector pos must be non-negative: ${pos}`);
+		let entry = byFile.get(d.file_path);
+		if (!entry) {
+			const found = dataFileMap.get(d.file_path);
+			if (!found) throw new Error(`target data file not found in current snapshot: ${d.file_path}`);
+			entry = {
+				positions: /* @__PURE__ */ new Set(),
+				partition: found.partition,
+				partitionSpecId: found.partitionSpecId,
+				dataEntry: found.entry
+			};
+			byFile.set(d.file_path, entry);
+		}
+		entry.positions.add(pos);
+	}
+	const priorManifests = await loadPriorManifests(metadata, resolver);
+	const priorDeleteManifests = await loadPriorDeleteManifestEntries(priorManifests, resolver);
+	const priorPositionDeleteEntries = priorDeleteManifests.flatMap((m) => m.entries).filter((entry) => entry.data_file.content === 1);
+	const targetPaths = new Set(byFile.keys());
+	const obsoletePositionDeleteEntries = /* @__PURE__ */ new Set();
+	if (priorPositionDeleteEntries.length) {
+		const { positionDeletesMap } = await fetchDeleteMaps(priorPositionDeleteEntries, resolver);
+		const positionDeleteTargets = /* @__PURE__ */ new Map();
+		for (const [targetPath, groups] of positionDeletesMap) for (const group of groups) {
+			let targets = positionDeleteTargets.get(group.deleteEntry);
+			if (!targets) {
+				targets = /* @__PURE__ */ new Set();
+				positionDeleteTargets.set(group.deleteEntry, targets);
+			}
+			targets.add(targetPath);
+		}
+		for (const [targetPath, info] of byFile) {
+			const groups = positionDeletesMap.get(targetPath) ?? [];
+			for (const group of groups) {
+				if (!deleteFileAppliesToDataEntry(info.dataEntry, group.deleteEntry, metadata, "position")) continue;
+				for (const pos of group.positions) info.positions.add(pos);
+			}
+		}
+		for (const [entry, coveredTargets] of positionDeleteTargets) {
+			if (isDeletionVectorForTarget(entry, targetPaths)) continue;
+			let allTargetsCovered = true;
+			let appliesToTarget = false;
+			for (const targetPath of coveredTargets) {
+				if (!targetPaths.has(targetPath)) {
+					allTargetsCovered = false;
+					break;
+				}
+				const info = byFile.get(targetPath);
+				if (info && deleteFileAppliesToDataEntry(info.dataEntry, entry, metadata, "position")) appliesToTarget = true;
+			}
+			if (allTargetsCovered && appliesToTarget) obsoletePositionDeleteEntries.add(entry);
+		}
+	}
+	const skipPriorManifestPaths = /* @__PURE__ */ new Set();
+	const replacementManifests = [];
+	const replacementManifestPaths = [];
+	let replacementIndex = 0;
+	let removedDeleteFiles = 0n;
+	let removedPositionDeletes = 0n;
+	let removedDvs = 0n;
+	for (const { manifest, entries } of priorDeleteManifests) {
+		const obsolete = entries.filter((entry) => isObsoleteDeleteEntry(entry, targetPaths, obsoletePositionDeleteEntries));
+		if (!obsolete.length) continue;
+		skipPriorManifestPaths.add(manifest.manifest_path);
+		removedDeleteFiles += BigInt(obsolete.length);
+		removedPositionDeletes += obsolete.reduce((sum, entry) => sum + entry.data_file.record_count, 0n);
+		removedDvs += BigInt(obsolete.filter((entry) => isDeletionVectorForTarget(entry, targetPaths)).length);
+		const retained = entries.filter((entry) => !isObsoleteDeleteEntry(entry, targetPaths, obsoletePositionDeleteEntries)).map((entry) => ({
+			...entry,
+			status: 0
+		}));
+		if (!retained.length) continue;
+		const spec = metadata["partition-specs"].find((s) => s["spec-id"] === manifest.partition_spec_id);
+		if (!spec) throw new Error(`partition spec ${manifest.partition_spec_id} not found in metadata`);
+		const manifestPath = `${tableUrl}/metadata/${manifestUuid}-r${replacementIndex}.avro`;
+		const manifestWriter = writerFn(manifestPath);
+		await writeExistingDeleteManifest({
+			writer: manifestWriter,
+			schema,
+			partitionSpec: spec,
+			entries: retained,
+			formatVersion
+		});
+		const existingRows = retained.reduce((sum, entry) => sum + entry.data_file.record_count, 0n);
+		replacementManifests.push({
+			manifest_path: manifestPath,
+			manifest_length: BigInt(manifestWriter.offset),
+			partition_spec_id: spec["spec-id"],
+			content: 1,
+			sequence_number: sequenceNumber,
+			min_sequence_number: minEntrySequenceNumber(retained, sequenceNumber),
+			added_snapshot_id: snapshotId,
+			added_files_count: 0,
+			existing_files_count: retained.length,
+			deleted_files_count: 0,
+			added_rows_count: 0n,
+			existing_rows_count: existingRows,
+			deleted_rows_count: 0n,
+			partitions: manifest.partitions ?? []
+		});
+		replacementManifestPaths.push(manifestPath);
+		replacementIndex++;
+	}
+	const writtenPuffinPaths = [];
+	const writtenDeleteFiles = await Promise.all([...byFile.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(async ([targetPath, info]) => {
+		const blob = writeDeletionVector(info.positions);
+		const puffin = writePuffinFile({ blobs: [{
+			type: "deletion-vector-v1",
+			fields: [],
+			snapshotId: -1,
+			sequenceNumber: -1,
+			data: blob,
+			properties: {
+				"referenced-data-file": targetPath,
+				cardinality: String(info.positions.size)
+			}
+		}] });
+		const puffinPath = `${tableUrl}/data/${uuid4()}-deletes.puffin`;
+		const puffinWriter = writerFn(puffinPath);
+		puffinWriter.appendBytes(puffin);
+		await puffinWriter.finish();
+		writtenPuffinPaths.push(puffinPath);
+		const deleteFile = {
+			content: 1,
+			file_path: puffinPath,
+			file_format: "puffin",
+			partition: info.partition,
+			record_count: BigInt(info.positions.size),
+			file_size_in_bytes: BigInt(puffinWriter.offset),
+			referenced_data_file: targetPath,
+			content_offset: 4n,
+			content_size_in_bytes: BigInt(blob.byteLength)
+		};
+		return {
+			specId: info.partitionSpecId,
+			partition: info.partition,
+			deleteFile
+		};
+	}));
+	const bySpec = /* @__PURE__ */ new Map();
+	for (const f of writtenDeleteFiles) {
+		let bucket = bySpec.get(f.specId);
+		if (!bucket) {
+			const spec = metadata["partition-specs"].find((s) => s["spec-id"] === f.specId);
+			if (!spec) throw new Error(`partition spec ${f.specId} not found in metadata`);
+			bucket = {
+				spec,
+				files: [],
+				partitions: []
+			};
+			bySpec.set(f.specId, bucket);
+		}
+		bucket.files.push(f.deleteFile);
+		bucket.partitions.push(f.partition);
+	}
+	const newManifests = [];
+	const writtenManifestPaths = [];
+	let manifestIndex = 0;
+	for (const { spec, files, partitions } of bySpec.values()) {
+		const manifestPath = `${tableUrl}/metadata/${manifestUuid}-m${manifestIndex}.avro`;
+		const manifestWriter = writerFn(manifestPath);
+		await writeDeleteManifest({
+			writer: manifestWriter,
+			schema,
+			partitionSpec: spec,
+			snapshotId,
+			deleteFiles: files,
+			formatVersion
+		});
+		const manifestLength = BigInt(manifestWriter.offset);
+		const totalAddedRows = files.reduce((sum, f) => sum + f.record_count, 0n);
+		newManifests.push({
+			manifest_path: manifestPath,
+			manifest_length: manifestLength,
+			partition_spec_id: spec["spec-id"],
+			content: 1,
+			sequence_number: sequenceNumber,
+			min_sequence_number: sequenceNumber,
+			added_snapshot_id: snapshotId,
+			added_files_count: files.length,
+			existing_files_count: 0,
+			deleted_files_count: 0,
+			added_rows_count: totalAddedRows,
+			existing_rows_count: 0n,
+			deleted_rows_count: 0n,
+			partitions: spec.fields.length ? buildPartitionSummaries(partitions, schema, spec) : []
+		});
+		writtenManifestPaths.push(manifestPath);
+		manifestIndex++;
+	}
+	const partitionKeys = /* @__PURE__ */ new Set();
+	for (const f of writtenDeleteFiles) partitionKeys.add(`${f.specId}|${partitionTupleKey(f.partition)}`);
+	const totalAddedRows = writtenDeleteFiles.reduce((sum, f) => sum + f.deleteFile.record_count, 0n);
+	const totalAddedSize = writtenDeleteFiles.reduce((sum, f) => sum + f.deleteFile.file_size_in_bytes, 0n);
+	const prevSummary = currentSnapshot(metadata)?.summary;
+	const prevTotals = {
+		records: BigInt(prevSummary?.["total-records"] ?? "0"),
+		size: BigInt(prevSummary?.["total-files-size"] ?? "0"),
+		dataFiles: BigInt(prevSummary?.["total-data-files"] ?? "0"),
+		deleteFiles: BigInt(prevSummary?.["total-delete-files"] ?? "0"),
+		posDeletes: BigInt(prevSummary?.["total-position-deletes"] ?? "0"),
+		eqDeletes: BigInt(prevSummary?.["total-equality-deletes"] ?? "0")
+	};
+	const summary = {
+		operation: "delete",
+		"added-delete-files": String(writtenDeleteFiles.length),
+		"added-dvs": String(writtenDeleteFiles.length),
+		"added-position-deletes": String(totalAddedRows),
+		"added-files-size": String(totalAddedSize),
+		"changed-partition-count": String(partitionKeys.size),
+		"total-records": String(prevTotals.records),
+		"total-files-size": String(prevTotals.size + totalAddedSize),
+		"total-data-files": String(prevTotals.dataFiles),
+		"total-delete-files": String(prevTotals.deleteFiles + BigInt(writtenDeleteFiles.length) - removedDeleteFiles),
+		"total-position-deletes": String(prevTotals.posDeletes + totalAddedRows - removedPositionDeletes),
+		"total-equality-deletes": String(prevTotals.eqDeletes)
+	};
+	if (removedDeleteFiles > 0n) {
+		summary["removed-delete-files"] = String(removedDeleteFiles);
+		summary["removed-position-deletes"] = String(removedPositionDeletes);
+		if (removedDvs > 0n) summary["removed-dvs"] = String(removedDvs);
+	}
+	return await buildSnapshotUpdate({
+		tableUrl,
+		metadata,
+		resolver,
+		snapshotId,
+		sequenceNumber,
+		manifestUuid,
+		timestampMs,
+		formatVersion,
+		newManifests: [...replacementManifests, ...newManifests],
+		summary,
+		writtenFiles: [
+			...replacementManifestPaths,
+			...writtenPuffinPaths,
+			...writtenManifestPaths
+		],
+		priorManifests,
+		skipPriorManifestPaths
+	});
+}
+async function loadPriorDeleteManifestEntries(manifests, resolver) {
+	return (await Promise.all(manifests.map(async (manifest) => {
+		if (manifest.content !== 1) return;
+		return {
+			manifest,
+			entries: await loadManifestEntries(manifest, resolver)
+		};
+	}))).filter((g) => g !== void 0);
+}
+function isDeletionVectorForTarget(entry, targetPaths) {
+	return entry.data_file.content === 1 && entry.data_file.file_format.toLowerCase() === "puffin" && entry.data_file.referenced_data_file !== void 0 && targetPaths.has(entry.data_file.referenced_data_file);
+}
+function isObsoleteDeleteEntry(entry, targetPaths, obsoletePositionDeleteEntries) {
+	return isDeletionVectorForTarget(entry, targetPaths) || obsoletePositionDeleteEntries.has(entry);
+}
+function minEntrySequenceNumber(entries, fallback) {
+	let min = fallback;
+	for (const entry of entries) if (entry.sequence_number !== void 0 && entry.sequence_number < min) min = entry.sequence_number;
+	return min;
+}
+export { icebergStageDeletionVector };