@gscdump/lakehouse 1.4.1 → 1.4.2

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

@@ -0,0 +1,216 @@
+import { bytesToHex, uuid4 } from "../utils.mjs";
+import { fetchAvroRecords } from "../fetch.mjs";
+import { validateSchemaForVersion } from "../schema.mjs";
+import { writeDeleteManifest } from "./manifest.mjs";
+import { buildPartitionSummaries, buildSnapshotUpdate, currentSnapshot } from "./snapshot.mjs";
+import { checkWriteFormat, newSnapshotId, resolveParquetCodec } from "./stage.mjs";
+import { writePositionDeleteFile } from "./delete-file.mjs";
+async function icebergStagePositionDelete({ 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"] !== 2 && metadata["format-version"] !== 3) throw new Error(`unsupported format-version: ${metadata["format-version"]}`);
+	if (metadata["format-version"] === 3) throw new Error("format-version 3 tables must use deletion vectors, not new position delete files");
+	const formatVersion = metadata["format-version"];
+	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 codec = resolveParquetCodec(metadata.properties?.["write.parquet.compression-codec"]);
+	const partitionMap = await findDataFilePartitions(metadata, resolver);
+	const groups = /* @__PURE__ */ new Map();
+	for (const d of deletes) {
+		const found = partitionMap.get(d.file_path);
+		if (!found) throw new Error(`target data file not found in current snapshot: ${d.file_path}`);
+		const { partition, partitionSpecId: specId } = found;
+		const key = `${specId}|${partitionTupleKey(partition)}`;
+		let group = groups.get(key);
+		if (!group) {
+			group = {
+				specId,
+				partition,
+				deletes: []
+			};
+			groups.set(key, group);
+		}
+		group.deletes.push(d);
+	}
+	const writtenDeleteFiles = await Promise.all([...groups.values()].map(async (group) => {
+		const referencedDataFile = new Set(group.deletes.map((d) => d.file_path)).size === 1 ? group.deletes[0].file_path : void 0;
+		const deletePath = `${tableUrl}/data/${uuid4()}-deletes.parquet`;
+		const deleteWriter = writerFn(deletePath);
+		const stats = await writePositionDeleteFile({
+			writer: deleteWriter,
+			deletes: group.deletes,
+			codec
+		});
+		const deleteFile = {
+			content: 1,
+			file_path: deletePath,
+			file_format: "parquet",
+			partition: group.partition,
+			record_count: stats.record_count,
+			file_size_in_bytes: BigInt(deleteWriter.offset),
+			value_counts: stats.value_counts,
+			null_value_counts: stats.null_value_counts,
+			lower_bounds: stats.lower_bounds,
+			upper_bounds: stats.upper_bounds,
+			sort_order_id: 0,
+			referenced_data_file: referencedDataFile
+		};
+		return {
+			specId: group.specId,
+			partition: group.partition,
+			deleteFile,
+			path: deletePath
+		};
+	}));
+	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 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 addedSize = writtenDeleteFiles.reduce((sum, f) => sum + f.deleteFile.file_size_in_bytes, 0n);
+	const addedPosDeletes = writtenDeleteFiles.reduce((sum, f) => sum + f.deleteFile.record_count, 0n);
+	return await buildSnapshotUpdate({
+		tableUrl,
+		metadata,
+		resolver,
+		snapshotId,
+		sequenceNumber,
+		manifestUuid,
+		timestampMs,
+		formatVersion,
+		newManifests,
+		summary: {
+			operation: "delete",
+			"added-delete-files": String(writtenDeleteFiles.length),
+			"added-position-deletes": String(addedPosDeletes),
+			"added-files-size": String(addedSize),
+			"changed-partition-count": String(groups.size),
+			"total-records": String(prevTotals.records),
+			"total-files-size": String(prevTotals.size + addedSize),
+			"total-data-files": String(prevTotals.dataFiles),
+			"total-delete-files": String(prevTotals.deleteFiles + BigInt(writtenDeleteFiles.length)),
+			"total-position-deletes": String(prevTotals.posDeletes + addedPosDeletes),
+			"total-equality-deletes": String(prevTotals.eqDeletes)
+		},
+		writtenFiles: [...writtenDeleteFiles.map((f) => f.path), ...writtenManifestPaths]
+	});
+}
+async function loadManifestEntries(manifest, resolver) {
+	const entries = await fetchAvroRecords(manifest.manifest_path, resolver, Number(manifest.manifest_length));
+	for (const entry of entries) {
+		entry.partition_spec_id = manifest.partition_spec_id ?? 0;
+		if (entry.sequence_number === void 0) entry.sequence_number = manifest.sequence_number ?? 0n;
+		if (entry.status === 1 && entry.file_sequence_number === void 0) entry.file_sequence_number = manifest.sequence_number ?? 0n;
+	}
+	return entries;
+}
+async function findDataFilePartitions(metadata, resolver) {
+	const entries = await findDataFileEntries(metadata, resolver);
+	const out = /* @__PURE__ */ new Map();
+	for (const [path, found] of entries) out.set(path, {
+		partition: found.partition,
+		partitionSpecId: found.partitionSpecId
+	});
+	return out;
+}
+async function findDataFileEntries(metadata, resolver) {
+	const snap = currentSnapshot(metadata);
+	if (!snap?.["manifest-list"]) return /* @__PURE__ */ new Map();
+	const manifests = await fetchAvroRecords(snap["manifest-list"], resolver);
+	const out = /* @__PURE__ */ new Map();
+	await Promise.all(manifests.map(async (manifest) => {
+		if (manifest.content !== 0) return;
+		const entries = await loadManifestEntries(manifest, resolver);
+		for (const entry of entries) {
+			if (entry.status === 2) continue;
+			const f = entry.data_file;
+			if (f.content !== 0) continue;
+			out.set(f.file_path, {
+				partition: f.partition ?? {},
+				partitionSpecId: manifest.partition_spec_id ?? 0,
+				entry
+			});
+		}
+	}));
+	return out;
+}
+function partitionTupleKey(partition) {
+	return Object.keys(partition).sort().map((k) => `${k}=${valueTag(partition[k])}`).join(",");
+}
+function valueTag(v) {
+	if (v === null || v === void 0) return "null";
+	if (typeof v === "bigint") return `b:${v.toString()}`;
+	if (typeof v === "number") {
+		if (Number.isNaN(v)) return "n:NaN";
+		if (Object.is(v, -0)) return "n:-0";
+		return `n:${v}`;
+	}
+	if (v instanceof Date) return `d:${v.getTime()}`;
+	if (v instanceof Uint8Array) return `x:${bytesToHex(v)}`;
+	return `${typeof v}:${String(v)}`;
+}
+export { findDataFileEntries, icebergStagePositionDelete, loadManifestEntries, partitionTupleKey };

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/stage.mjs

@@ -1,7 +1,7 @@
 import { uuid4 } from "../utils.mjs";
 import { validateSchemaForVersion } from "../schema.mjs";
 import { groupByPartition } from "./partition.mjs";
-import "./commit.mjs";
+import { applyUpdates } from "./commit.mjs";
 import { writeDataManifest } from "./manifest.mjs";
 import { computeColumnStats } from "./stats.mjs";
 import { buildPartitionSummaries, buildSnapshotUpdate, currentSnapshot } from "./snapshot.mjs";
@@ -210,6 +210,123 @@ async function stageSnapshotForAppendBatches({ tableUrl, metadata, prepared, res
 		writtenFiles: []
 	});
 }
+async function icebergStageAppend({ tableUrl, metadata, records, resolver, sortOrderId }) {
+	const prepared = await prepareAppend({
+		tableUrl,
+		metadata,
+		records,
+		resolver,
+		sortOrderId
+	});
+	const staged = await stageSnapshotForAppend({
+		tableUrl,
+		metadata,
+		prepared,
+		resolver
+	});
+	return {
+		...staged,
+		writtenFiles: [...prepared.writtenFiles, ...staged.writtenFiles]
+	};
+}
+function icebergStageSetRef({ metadata, ref, snapshotId, type = "branch", minSnapshotsToKeep, maxSnapshotAgeMs, maxRefAgeMs }) {
+	if (!ref) throw new Error("ref is required");
+	if (type !== "branch" && type !== "tag") throw new Error(`unknown ref type: ${type}`);
+	if (type === "tag" && (minSnapshotsToKeep !== void 0 || maxSnapshotAgeMs !== void 0)) throw new Error("tags do not support min-snapshots-to-keep or max-snapshot-age-ms");
+	const targetId = BigInt(snapshotId);
+	const snapshot = metadata.snapshots?.find((s) => BigInt(s["snapshot-id"]) === targetId);
+	if (!snapshot) throw new Error(`snapshot ${snapshotId} not found in metadata.snapshots`);
+	const existingRef = metadata.refs?.[ref];
+	let currentSnapshotId = existingRef?.["snapshot-id"] ?? null;
+	if (currentSnapshotId === null && ref === "main") currentSnapshotId = metadata["current-snapshot-id"] ?? null;
+	if (existingRef && existingRef.type !== type) throw new Error(`ref ${ref} is a ${existingRef.type}, cannot set as ${type}`);
+	const requirements = [{
+		type: "assert-table-uuid",
+		uuid: metadata["table-uuid"]
+	}, {
+		type: "assert-ref-snapshot-id",
+		ref,
+		"snapshot-id": currentSnapshotId
+	}];
+	const update = {
+		action: "set-snapshot-ref",
+		"ref-name": ref,
+		type,
+		"snapshot-id": snapshotId
+	};
+	if (minSnapshotsToKeep !== void 0) update["min-snapshots-to-keep"] = minSnapshotsToKeep;
+	if (maxSnapshotAgeMs !== void 0) update["max-snapshot-age-ms"] = maxSnapshotAgeMs;
+	if (maxRefAgeMs !== void 0) update["max-ref-age-ms"] = maxRefAgeMs;
+	return {
+		snapshot,
+		requirements,
+		updates: [update],
+		writtenFiles: []
+	};
+}
+function icebergStageExpireSnapshots({ metadata, snapshotIds }) {
+	if (!Array.isArray(snapshotIds) || snapshotIds.length === 0) throw new Error("snapshotIds must be a non-empty array");
+	const removeIds = new Set(snapshotIds.map(BigInt));
+	const snapshots = metadata.snapshots ?? [];
+	for (const id of removeIds) if (!snapshots.some((s) => BigInt(s["snapshot-id"]) === id)) throw new Error(`snapshot ${id} not found in metadata.snapshots`);
+	const refs = metadata.refs ?? {};
+	for (const [name, ref] of Object.entries(refs)) if (removeIds.has(BigInt(ref["snapshot-id"]))) throw new Error(`snapshot ${ref["snapshot-id"]} is referenced by ${ref.type} ${name}`);
+	const currentId = metadata["current-snapshot-id"];
+	if (currentId !== void 0 && currentId !== null && removeIds.has(BigInt(currentId)) && !refs.main) throw new Error(`snapshot ${currentId} is the current snapshot`);
+	const requirements = [{
+		type: "assert-table-uuid",
+		uuid: metadata["table-uuid"]
+	}, {
+		type: "assert-ref-snapshot-id",
+		ref: "main",
+		"snapshot-id": refs.main?.["snapshot-id"] ?? currentId ?? null
+	}];
+	const update = {
+		action: "remove-snapshots",
+		"snapshot-ids": snapshotIds
+	};
+	const tip = currentSnapshot(metadata) ?? snapshots[0];
+	if (!tip) throw new Error("cannot expire snapshots from a table with no snapshots");
+	return {
+		snapshot: tip,
+		requirements,
+		updates: [update],
+		writtenFiles: []
+	};
+}
+function icebergStageUpdateSchema({ metadata, schema }) {
+	if (!schema || schema.type !== "struct" || !Array.isArray(schema.fields)) throw new Error("schema must be a struct with a fields array");
+	const requirements = [
+		{
+			type: "assert-table-uuid",
+			uuid: metadata["table-uuid"]
+		},
+		{
+			type: "assert-current-schema-id",
+			"current-schema-id": metadata["current-schema-id"]
+		},
+		{
+			type: "assert-last-assigned-field-id",
+			"last-assigned-field-id": metadata["last-column-id"]
+		}
+	];
+	const updates = [{
+		action: "add-schema",
+		schema: {
+			...schema,
+			"schema-id": -1
+		}
+	}, {
+		action: "set-current-schema",
+		"schema-id": -1
+	}];
+	applyUpdates(metadata, updates);
+	return {
+		requirements,
+		updates,
+		writtenFiles: []
+	};
+}
 function checkWriteFormat(value) {
 	if (value === void 0) return;
 	if (value.toLowerCase() !== "parquet") throw new Error(`unsupported write.format.default: ${value}`);
@@ -234,4 +351,4 @@ function newSnapshotId(metadata) {
 	}
 	throw new Error("newSnapshotId: failed to find an unused id after 32 attempts");
 }
-export { checkWriteFormat, newSnapshotId, prepareAppend, resolveParquetCodec, stageSnapshotForAppend, stageSnapshotForAppendBatches };
+export { checkWriteFormat, icebergStageAppend, icebergStageExpireSnapshots, icebergStageSetRef, icebergStageUpdateSchema, newSnapshotId, prepareAppend, resolveParquetCodec, stageSnapshotForAppend, stageSnapshotForAppendBatches };

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/write.mjs

@@ -1,12 +1,12 @@
-import { loadLatestFileCatalogMetadata } from "../metadata.mjs";
 import { restCatalogCreateTable, restCatalogDropTable, restCatalogLoadTable, restCatalogUpdateTable } from "../catalog/rest.mjs";
+import { loadLatestFileCatalogMetadata } from "../metadata.mjs";
 import { loadTable } from "../catalog/loadTable.mjs";
 import { icebergCreate } from "../create.mjs";
-import { fileCatalogCommit } from "./commit.mjs";
-import { prepareAppend, stageSnapshotForAppend, stageSnapshotForAppendBatches } from "./stage.mjs";
-import "./stage-position-delete.mjs";
-import "./stage-deletion-vector.mjs";
-import "./rewrite.mjs";
+import { applyUpdates, fileCatalogCommit } from "./commit.mjs";
+import { icebergStageAppend, icebergStageExpireSnapshots, icebergStageSetRef, icebergStageUpdateSchema, prepareAppend, stageSnapshotForAppend, stageSnapshotForAppendBatches } from "./stage.mjs";
+import { icebergStagePositionDelete } from "./stage-position-delete.mjs";
+import { icebergStageDeletionVector } from "./stage-deletion-vector.mjs";
+import { icebergStageRewrite } from "./rewrite.mjs";
 const DEFAULT_RETRY = Object.freeze({
 	maxAttempts: 50,
 	initialMs: 50,
@@ -86,6 +86,235 @@ async function icebergAppendBatches({ catalog, namespace, table, tableUrl, resol
 		})
 	});
 }
+async function icebergRewrite({ catalog, namespace, table, tableUrl, resolver, sortOrderId, partitionSpecId, targetFileRows }) {
+	const ctx = await loadTable({
+		catalog,
+		namespace,
+		table,
+		tableUrl,
+		resolver
+	});
+	const staged = await icebergStageRewrite({
+		tableUrl: ctx.tableUrl,
+		metadata: ctx.metadata,
+		resolver: requireResolver(ctx.resolver, "icebergRewrite"),
+		sortOrderId,
+		partitionSpecId,
+		targetFileRows
+	});
+	return await commitStaged(catalog, {
+		namespace,
+		table
+	}, ctx, staged);
+}
+async function icebergDelete({ catalog, namespace, table, tableUrl, resolver, deletes, mode }) {
+	const ctx = await loadTable({
+		catalog,
+		namespace,
+		table,
+		tableUrl,
+		resolver
+	});
+	return await commitWithRetry({
+		catalog,
+		target: {
+			namespace,
+			table
+		},
+		ctx,
+		stage: async (workingCtx) => {
+			const writer = requireResolver(workingCtx.resolver, "icebergDelete");
+			const formatVersion = workingCtx.metadata["format-version"];
+			const effective = mode ?? (formatVersion === 3 ? "puffin" : "parquet");
+			if (effective === "puffin") return await icebergStageDeletionVector({
+				tableUrl: workingCtx.tableUrl,
+				metadata: workingCtx.metadata,
+				deletes,
+				resolver: writer
+			});
+			if (effective === "parquet") return await icebergStagePositionDelete({
+				tableUrl: workingCtx.tableUrl,
+				metadata: workingCtx.metadata,
+				deletes,
+				resolver: writer
+			});
+			throw new Error(`unknown delete mode: ${effective}`);
+		}
+	});
+}
+async function icebergSetRef({ catalog, namespace, table, tableUrl, resolver, ref, snapshotId, type, minSnapshotsToKeep, maxSnapshotAgeMs, maxRefAgeMs }) {
+	const ctx = await loadTable({
+		catalog,
+		namespace,
+		table,
+		tableUrl,
+		resolver
+	});
+	return await commitWithRetry({
+		catalog,
+		target: {
+			namespace,
+			table
+		},
+		ctx,
+		stage: (workingCtx) => icebergStageSetRef({
+			metadata: workingCtx.metadata,
+			ref,
+			snapshotId,
+			type,
+			minSnapshotsToKeep,
+			maxSnapshotAgeMs,
+			maxRefAgeMs
+		})
+	});
+}
+async function icebergUpdateSchema({ catalog, namespace, table, tableUrl, resolver, schema }) {
+	const ctx = await loadTable({
+		catalog,
+		namespace,
+		table,
+		tableUrl,
+		resolver
+	});
+	return await commitWithRetry({
+		catalog,
+		target: {
+			namespace,
+			table
+		},
+		ctx,
+		stage: (workingCtx) => icebergStageUpdateSchema({
+			metadata: workingCtx.metadata,
+			schema
+		})
+	});
+}
+async function icebergExpireSnapshots({ catalog, namespace, table, tableUrl, resolver, snapshotIds }) {
+	const ctx = await loadTable({
+		catalog,
+		namespace,
+		table,
+		tableUrl,
+		resolver
+	});
+	return await commitWithRetry({
+		catalog,
+		target: {
+			namespace,
+			table
+		},
+		ctx,
+		stage: (workingCtx) => icebergStageExpireSnapshots({
+			metadata: workingCtx.metadata,
+			snapshotIds
+		})
+	});
+}
+async function icebergTransaction({ catalog, namespace, table, tableUrl, resolver }, callback) {
+	const ctx = await loadTable({
+		catalog,
+		namespace,
+		table,
+		tableUrl,
+		resolver
+	});
+	const deleter = ctx.resolver?.deleter;
+	let workingMetadata = ctx.metadata;
+	const allRequirements = [];
+	const allUpdates = [];
+	const allWrittenFiles = [];
+	let lastSnapshot;
+	function mergeStaged(staged) {
+		for (const req of staged.requirements) {
+			const key = requirementKey(req);
+			if (!allRequirements.some((r) => requirementKey(r) === key)) allRequirements.push(req);
+		}
+		allUpdates.push(...staged.updates);
+		allWrittenFiles.push(...staged.writtenFiles);
+		workingMetadata = applyUpdates(workingMetadata, staged.updates);
+		lastSnapshot = staged.snapshot;
+	}
+	await callback({
+		async append({ records, sortOrderId }) {
+			const writer = requireResolver(ctx.resolver, "icebergTransaction.append");
+			mergeStaged(await icebergStageAppend({
+				tableUrl: ctx.tableUrl,
+				metadata: workingMetadata,
+				records,
+				resolver: writer,
+				sortOrderId
+			}));
+		},
+		async delete({ deletes, mode }) {
+			const writer = requireResolver(ctx.resolver, "icebergTransaction.delete");
+			const formatVersion = workingMetadata["format-version"];
+			const effective = mode ?? (formatVersion === 3 ? "puffin" : "parquet");
+			let staged;
+			if (effective === "puffin") staged = await icebergStageDeletionVector({
+				tableUrl: ctx.tableUrl,
+				metadata: workingMetadata,
+				deletes,
+				resolver: writer
+			});
+			else if (effective === "parquet") staged = await icebergStagePositionDelete({
+				tableUrl: ctx.tableUrl,
+				metadata: workingMetadata,
+				deletes,
+				resolver: writer
+			});
+			else throw new Error(`unknown delete mode: ${effective}`);
+			mergeStaged(staged);
+		},
+		setRef({ ref, snapshotId, type, minSnapshotsToKeep, maxSnapshotAgeMs, maxRefAgeMs }) {
+			mergeStaged(icebergStageSetRef({
+				metadata: workingMetadata,
+				ref,
+				snapshotId,
+				type,
+				minSnapshotsToKeep,
+				maxSnapshotAgeMs,
+				maxRefAgeMs
+			}));
+		},
+		expireSnapshots({ snapshotIds }) {
+			mergeStaged(icebergStageExpireSnapshots({
+				metadata: workingMetadata,
+				snapshotIds
+			}));
+		}
+	});
+	if (allUpdates.length === 0) return ctx.metadata;
+	if (!lastSnapshot) throw new Error("icebergTransaction: no snapshot produced");
+	try {
+		return await commitStaged(catalog, {
+			namespace,
+			table
+		}, ctx, {
+			snapshot: lastSnapshot,
+			requirements: allRequirements,
+			updates: allUpdates,
+			writtenFiles: allWrittenFiles
+		});
+	} catch (err) {
+		if (deleter && allWrittenFiles.length > 0) await Promise.allSettled(allWrittenFiles.map((p) => deleter(p)));
+		if (isCommitConflict(err)) throw new IcebergTransactionConflictError(err);
+		throw err;
+	}
+}
+var IcebergTransactionConflictError = class extends Error {
+	constructor(cause) {
+		const status = cause?.status;
+		const detail = cause?.message;
+		super(`icebergTransaction commit conflicted with a concurrent writer${status ? ` (status ${status})` : ""}. The transaction was not applied and staged files were cleaned up. Wrap the icebergTransaction call in your own retry loop if the callback is safe to re-run; for append-only workloads prefer icebergAppend, which retries without re-uploading data.` + (detail ? ` (cause: ${detail})` : ""));
+		this.name = "IcebergTransactionConflictError";
+		this.cause = cause;
+		if (typeof status === "number") this.status = status;
+	}
+};
+function requirementKey(req) {
+	if (req.type === "assert-ref-snapshot-id") return `${req.type}:${req.ref}`;
+	return req.type;
+}
 async function icebergCreateTable({ catalog, namespace, table, tableUrl, schema, partitionSpec, sortOrder, properties, formatVersion, stageCreate }) {
 	if (catalog.type === "rest") {
 		if (!namespace || !table) throw new Error("namespace and table are required for rest catalogs");
@@ -244,4 +473,4 @@ function isCommitConflict(err) {
 	const { status } = err;
 	return status === 412 || status === 409;
 }
-export { icebergAppend, icebergAppendBatches, icebergCreateTable, icebergDropTable };
+export { IcebergTransactionConflictError, icebergAppend, icebergAppendBatches, icebergCreateTable, icebergDelete, icebergDropTable, icebergExpireSnapshots, icebergRewrite, icebergSetRef, icebergTransaction, icebergUpdateSchema };

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/types/index.d.mts

@@ -1,8 +1,8 @@
 import { icebergAppend, icebergCreateTable, icebergDropTable } from "./write/write.mjs";
-import "./create.mjs";
-import "./catalog/file.mjs";
 import { restCatalogConnect, restCatalogCreateNamespace, restCatalogListTables, restCatalogLoadTable } from "./catalog/rest.mjs";
 import { cachingResolver } from "./fetch.mjs";
+import "./create.mjs";
+import "./catalog/file.mjs";
 import { s3SignedResolver } from "./s3.mjs";
 import "./read.mjs";
 import "./metadata.mjs";
@@ -10,4 +10,4 @@ import { icebergManifests } from "./manifest.mjs";
 import "../../../../squirreling@0.15.0/node_modules/squirreling/src/index.mjs";
 import "./sql/icebergDataSource.mjs";
 import "./sql/icebergQuery.mjs";
-export { cachingResolver, icebergAppend, icebergCreateTable, icebergDropTable, icebergManifests, restCatalogConnect, restCatalogCreateNamespace, restCatalogListTables, restCatalogLoadTable, s3SignedResolver };
+export { icebergAppend, icebergCreateTable, icebergDropTable, icebergManifests, restCatalogConnect, restCatalogCreateNamespace, restCatalogListTables, restCatalogLoadTable, s3SignedResolver };

package/dist/{node_modules → _virtual/node_modules}/.pnpm/unstorage@1.17.5_aws4fetch@1.0.20_db0@0.3.4_ioredis@5.10.1_supports-color@10.2.2_/node_modules/unstorage/drivers/db0.d.mts

@@ -1,2 +1,2 @@
-import "../../../../db0@0.3.4_drizzle-orm@1.0.0-rc.3_@cloudflare_workers-types@5.20260722.1_valibot@1.4.2_typescript@7.0.2__zod@4.4.3_/node_modules/db0/dist/index.mjs";
+import "../../../../db0@0.3.4_drizzle-orm@1.0.0-rc.3_@cloudflare+workers-types@5.20260722.1_valibot@1.4.2_typescript@7.0.2__zod@4.4.3_/node_modules/db0/dist/index.mjs";
 import "../dist/index.mjs";

package/dist/catalog-cache.d.mts

@@ -1,5 +1,5 @@
-import { a as Storage } from "./node_modules/.pnpm/unstorage@1.17.5_aws4fetch@1.0.20_db0@0.3.4_ioredis@5.10.1_supports-color@10.2.2_/node_modules/unstorage/dist/shared/unstorage.DqlWKU2I.mjs";
-import "./node_modules/.pnpm/unstorage@1.17.5_aws4fetch@1.0.20_db0@0.3.4_ioredis@5.10.1_supports-color@10.2.2_/node_modules/unstorage/dist/index2.mjs";
+import { a as Storage } from "./_virtual/node_modules/.pnpm/unstorage@1.17.5_aws4fetch@1.0.20_db0@0.3.4_ioredis@5.10.1_supports-color@10.2.2_/node_modules/unstorage/dist/shared/unstorage.DqlWKU2I.mjs";
+import "./_virtual/node_modules/.pnpm/unstorage@1.17.5_aws4fetch@1.0.20_db0@0.3.4_ioredis@5.10.1_supports-color@10.2.2_/node_modules/unstorage/dist/index2.mjs";
 /** Injected catalog cache: an unstorage `Storage` plus an optional defer hook. */
 interface CatalogCache {
   /** unstorage storage instance — the driver is the caller's choice. */