@gscdump/lakehouse 1.4.0 → 1.4.2

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

@@ -0,0 +1,220 @@
+import { typeName } from "../schema.mjs";
+import { uuidToBytes } from "./conversions.mjs";
+function parseTransform(transform) {
+	if (transform === "identity" || transform === "void" || transform === "year" || transform === "month" || transform === "day" || transform === "hour") return { kind: transform };
+	let m = /^bucket\[(\d+)\]$/.exec(transform);
+	if (m) {
+		const n = parseInt(m[1], 10);
+		if (n > 0) return {
+			kind: "bucket",
+			n
+		};
+	}
+	m = /^truncate\[(\d+)\]$/.exec(transform);
+	if (m) {
+		const w = parseInt(m[1], 10);
+		if (w > 0) return {
+			kind: "truncate",
+			w
+		};
+	}
+	throw new Error(`unsupported partition transform: ${transform}`);
+}
+function transformResultType(transform, sourceType) {
+	const parsed = parseTransform(transform);
+	validateTransformSource(parsed, sourceType);
+	switch (parsed.kind) {
+		case "identity":
+		case "truncate": return sourceType;
+		case "void": return "int";
+		case "year":
+		case "month":
+		case "day":
+		case "hour":
+		case "bucket": return "int";
+	}
+}
+function applyTransform(transform, value, sourceType) {
+	const parsed = parseTransform(transform);
+	validateTransformSource(parsed, sourceType);
+	if (value == null) return null;
+	switch (parsed.kind) {
+		case "identity": return value;
+		case "void": return null;
+		case "year": return yearTransform(value, sourceType);
+		case "month": return monthTransform(value, sourceType);
+		case "day": return dayTransform(value, sourceType);
+		case "hour": return hourTransform(value, sourceType);
+		case "bucket": return bucketTransform(value, sourceType, parsed.n);
+		case "truncate": return truncateTransform(value, sourceType, parsed.w);
+	}
+}
+function dateAsMillis(value, sourceType, transform) {
+	const t = typeName(sourceType);
+	validateTransformSource({ kind: transform }, sourceType);
+	if (value instanceof Date) return value.getTime();
+	const n = typeof value === "bigint" ? value : BigInt(value);
+	switch (t) {
+		case "date": return Number(n) * 864e5;
+		case "timestamp":
+		case "timestamptz": return Number(n / 1000n);
+		default: return Number(n / 1000000n);
+	}
+}
+function yearTransform(v, t) {
+	return new Date(dateAsMillis(v, t, "year")).getUTCFullYear() - 1970;
+}
+function monthTransform(v, t) {
+	const d = new Date(dateAsMillis(v, t, "month"));
+	return (d.getUTCFullYear() - 1970) * 12 + d.getUTCMonth();
+}
+function dayTransform(v, t) {
+	return Math.floor(dateAsMillis(v, t, "day") / 864e5);
+}
+function hourTransform(v, t) {
+	return Math.floor(dateAsMillis(v, t, "hour") / 36e5);
+}
+function bucketTransform(value, sourceType, n) {
+	return (murmur3_32(bucketBytes(value, sourceType), 0) & 2147483647) % n;
+}
+function bucketBytes(value, sourceType) {
+	const t = typeName(sourceType);
+	if (t.startsWith("decimal(")) return decimalToUnscaledBytes(value, t);
+	if (t === "uuid") return uuidToBytes(value, "uuid partition value");
+	if (t.startsWith("fixed[") || t === "binary" || t === "fixed") return value instanceof Uint8Array ? value : new Uint8Array(value);
+	switch (t) {
+		case "int":
+		case "long":
+		case "date":
+		case "time":
+		case "timestamp":
+		case "timestamptz":
+		case "timestamp_ns":
+		case "timestamptz_ns": {
+			let v;
+			if (t === "date") v = value instanceof Date ? BigInt(Math.floor(value.getTime() / 864e5)) : BigInt(value);
+			else if (t === "timestamp" || t === "timestamptz") v = value instanceof Date ? BigInt(value.getTime()) * 1000n : BigInt(value);
+			else if (t === "timestamp_ns" || t === "timestamptz_ns") v = value instanceof Date ? BigInt(value.getTime()) * 1000n : BigInt(value) / 1000n;
+			else v = typeof value === "bigint" ? value : BigInt(value);
+			const out = /* @__PURE__ */ new Uint8Array(8);
+			new DataView(out.buffer).setBigInt64(0, v, true);
+			return out;
+		}
+		case "string": return new TextEncoder().encode(String(value));
+		default: throw new Error(`bucket transform: unsupported source type ${t}`);
+	}
+}
+function decimalToUnscaledBytes(value, decimalType) {
+	const m = /^decimal\((\d+),\s*(\d+)\)$/.exec(decimalType);
+	if (!m) throw new Error(`bucket transform: invalid decimal type ${decimalType}`);
+	const scale = parseInt(m[2], 10);
+	const factor = 10n ** BigInt(scale);
+	const unscaled = typeof value === "bigint" ? value * factor : BigInt(Math.round(Number(value) * Number(factor)));
+	const bytes = [];
+	let v = unscaled;
+	while (true) {
+		const byte = Number(v & 255n);
+		bytes.unshift(byte);
+		v >>= 8n;
+		const sign = byte & 128;
+		if (!sign && v === 0n || sign && v === -1n) break;
+	}
+	return new Uint8Array(bytes);
+}
+function truncateTransform(value, sourceType, w) {
+	const t = typeName(sourceType);
+	if (t.startsWith("decimal(")) {
+		const m = /^decimal\((\d+),\s*(\d+)\)$/.exec(t);
+		if (!m) throw new Error(`truncate transform: invalid decimal type ${t}`);
+		const scale = parseInt(m[2], 10);
+		const factor = 10n ** BigInt(scale);
+		const unscaled = typeof value === "bigint" ? value * factor : BigInt(Math.round(Number(value) * Number(factor)));
+		const W = BigInt(w);
+		const truncated = unscaled - (unscaled % W + W) % W;
+		return Number(truncated) / Number(factor);
+	}
+	if (t === "binary") return (value instanceof Uint8Array ? value : new Uint8Array(value)).slice(0, w);
+	switch (t) {
+		case "int": {
+			const v = Number(value);
+			return v - (v % w + w) % w;
+		}
+		case "long": {
+			const W = BigInt(w);
+			const v = typeof value === "bigint" ? value : BigInt(value);
+			return v - (v % W + W) % W;
+		}
+		case "string": {
+			const s = String(value);
+			let count = 0;
+			let i = 0;
+			while (i < s.length && count < w) {
+				const code = s.codePointAt(i);
+				i += code > 65535 ? 2 : 1;
+				count++;
+			}
+			return s.slice(0, i);
+		}
+		default: throw new Error(`truncate transform: unsupported source type ${t}`);
+	}
+}
+function validateTransformSource(parsed, sourceType) {
+	const t = typeName(sourceType);
+	switch (parsed.kind) {
+		case "identity":
+			if (t === "variant" || t === "geometry" || t.startsWith("geometry(") || t === "geography" || t.startsWith("geography(")) throw new Error(`identity transform: unsupported source type ${t}`);
+			return;
+		case "void": return;
+		case "bucket":
+			if (t === "int" || t === "long" || t.startsWith("decimal(") || t === "date" || t === "time" || t === "timestamp" || t === "timestamptz" || t === "timestamp_ns" || t === "timestamptz_ns" || t === "string" || t === "uuid" || t.startsWith("fixed[") || t === "binary" || t === "fixed") return;
+			throw new Error(`bucket transform: unsupported source type ${t}`);
+		case "truncate":
+			if (t === "int" || t === "long" || t.startsWith("decimal(") || t === "string" || t === "binary") return;
+			throw new Error(`truncate transform: unsupported source type ${t}`);
+		case "year":
+		case "month":
+		case "day":
+			if (t === "date" || t === "timestamp" || t === "timestamptz" || t === "timestamp_ns" || t === "timestamptz_ns") return;
+			throw new Error(`${parsed.kind} transform: unsupported source type ${t}`);
+		case "hour":
+			if (t === "timestamp" || t === "timestamptz" || t === "timestamp_ns" || t === "timestamptz_ns") return;
+			throw new Error("hour transform: unsupported source type " + t);
+	}
+}
+function murmur3_32(data, seed) {
+	const c1 = 3432918353;
+	const c2 = 461845907;
+	const len = data.length;
+	const nBlocks = len >>> 2;
+	let h1 = seed >>> 0;
+	for (let i = 0; i < nBlocks; i++) {
+		const off = i * 4;
+		let k1 = data[off] | data[off + 1] << 8 | data[off + 2] << 16 | data[off + 3] << 24;
+		k1 = Math.imul(k1, c1);
+		k1 = k1 << 15 | k1 >>> 17;
+		k1 = Math.imul(k1, c2);
+		h1 ^= k1;
+		h1 = h1 << 13 | h1 >>> 19;
+		h1 = Math.imul(h1, 5) + 3864292196 | 0;
+	}
+	let k1 = 0;
+	const tail = nBlocks * 4;
+	switch (len & 3) {
+		case 3: k1 ^= data[tail + 2] << 16;
+		case 2: k1 ^= data[tail + 1] << 8;
+		case 1:
+			k1 ^= data[tail];
+			k1 = Math.imul(k1, c1);
+			k1 = k1 << 15 | k1 >>> 17;
+			k1 = Math.imul(k1, c2);
+			h1 ^= k1;
+	}
+	h1 ^= len;
+	h1 ^= h1 >>> 16;
+	h1 = Math.imul(h1, 2246822507);
+	h1 ^= h1 >>> 13;
+	h1 = Math.imul(h1, 3266489909);
+	h1 ^= h1 >>> 16;
+	return h1 >>> 0;
+}
+export { applyTransform, murmur3_32, parseTransform, transformResultType };

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

@@ -0,0 +1,476 @@
+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 { 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,
+	maxMs: 3e3,
+	factor: 2,
+	totalTimeoutMs: 1800 * 1e3
+});
+async function icebergAppend({ catalog, namespace, table, tableUrl, resolver, records, sortOrderId, snapshotProperties }) {
+	const ctx = await loadTable({
+		catalog,
+		namespace,
+		table,
+		tableUrl,
+		resolver
+	});
+	const prepared = await prepareAppend({
+		tableUrl: ctx.tableUrl,
+		metadata: ctx.metadata,
+		records,
+		resolver: requireResolver(ctx.resolver, "icebergAppend"),
+		sortOrderId
+	});
+	return await commitWithRetry({
+		catalog,
+		target: {
+			namespace,
+			table
+		},
+		ctx,
+		stage: (workingCtx) => stageSnapshotForAppend({
+			tableUrl: workingCtx.tableUrl,
+			metadata: workingCtx.metadata,
+			prepared,
+			resolver: requireResolver(workingCtx.resolver, "icebergAppend"),
+			snapshotProperties
+		})
+	});
+}
+async function icebergAppendBatches({ catalog, namespace, table, tableUrl, resolver, batches, sortOrderId, snapshotProperties }) {
+	const ctx = await loadTable({
+		catalog,
+		namespace,
+		table,
+		tableUrl,
+		resolver
+	});
+	const writer = requireResolver(ctx.resolver, "icebergAppendBatches");
+	const prepared = [];
+	let snapshotId;
+	for await (const records of batches) {
+		if (records.length === 0) continue;
+		const batch = await prepareAppend({
+			tableUrl: ctx.tableUrl,
+			metadata: ctx.metadata,
+			records,
+			resolver: writer,
+			sortOrderId,
+			snapshotId
+		});
+		snapshotId ??= batch.snapshotId;
+		prepared.push(batch);
+	}
+	if (prepared.length === 0) return ctx.metadata;
+	return await commitWithRetry({
+		catalog,
+		target: {
+			namespace,
+			table
+		},
+		ctx,
+		stage: (workingCtx) => stageSnapshotForAppendBatches({
+			tableUrl: workingCtx.tableUrl,
+			metadata: workingCtx.metadata,
+			prepared,
+			resolver: requireResolver(workingCtx.resolver, "icebergAppendBatches"),
+			snapshotProperties
+		})
+	});
+}
+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");
+		if (!schema) throw new Error("schema is required for rest catalogs");
+		const { metadata } = await restCatalogCreateTable(catalog, {
+			namespace,
+			table,
+			schema,
+			location: tableUrl,
+			partitionSpec,
+			writeOrder: sortOrder,
+			stageCreate,
+			properties
+		});
+		return metadata;
+	}
+	if (!tableUrl) throw new Error("tableUrl is required for file catalogs");
+	return await icebergCreate({
+		tableUrl,
+		resolver: catalog.resolver,
+		schema,
+		formatVersion,
+		partitionSpec,
+		sortOrder,
+		properties,
+		conditionalCommits: catalog.conditionalCommits
+	});
+}
+async function icebergDropTable({ catalog, namespace, table, tableUrl, lister, purgeRequested }) {
+	if (catalog.type === "rest") {
+		if (!namespace || !table) throw new Error("namespace and table are required for rest catalogs");
+		await restCatalogDropTable(catalog, {
+			namespace,
+			table,
+			purgeRequested
+		});
+		return;
+	}
+	if (!tableUrl) throw new Error("tableUrl is required for file catalogs");
+	if (!lister) throw new Error("lister is required to drop a file catalog table");
+	const { deleter } = catalog.resolver;
+	if (!deleter) throw new Error("resolver.deleter is required to drop a file catalog table");
+	const dirs = purgeRequested ? ["metadata", "data"] : ["metadata"];
+	for (const dir of dirs) {
+		const names = await lister(`${tableUrl}/${dir}`).catch(() => []);
+		await Promise.allSettled(names.map((n) => deleter(`${tableUrl}/${dir}/${n}`)));
+	}
+}
+function requireResolver(resolver, caller) {
+	if (!resolver) throw new Error(`${caller}: resolver is required`);
+	return resolver;
+}
+async function commitStaged(catalog, target, ctx, staged) {
+	if (catalog.type === "rest") {
+		const { metadata } = await restCatalogUpdateTable(catalog, {
+			namespace: target.namespace,
+			table: target.table,
+			requirements: staged.requirements,
+			updates: staged.updates
+		});
+		return metadata;
+	}
+	if (!ctx.resolver) throw new Error("resolver is required to commit to a file catalog");
+	return await fileCatalogCommit({
+		tableUrl: ctx.tableUrl,
+		metadata: ctx.metadata,
+		metadataFileName: ctx.metadataFileName,
+		currentVersion: ctx.version,
+		staged,
+		resolver: ctx.resolver,
+		conditionalCommits: catalog.type === "file" && catalog.conditionalCommits
+	});
+}
+async function commitWithRetry({ catalog, target, ctx, stage }) {
+	const retryEnabled = catalog.type === "rest" || catalog.type === "file" && catalog.conditionalCommits === true;
+	const policy = resolveRetryPolicy(ctx.metadata);
+	const startedAt = Date.now();
+	let workingCtx = ctx;
+	for (let attempt = 1; attempt <= policy.maxAttempts; attempt++) {
+		const staged = await stage(workingCtx);
+		try {
+			return await commitStaged(catalog, target, workingCtx, staged);
+		} catch (err) {
+			if (!retryEnabled || !isCommitConflict(err)) throw err;
+			if (attempt === policy.maxAttempts) throw new Error(`${catalog.type} catalog commit failed after ${policy.maxAttempts} attempts due to concurrent commits`);
+			const elapsed = Date.now() - startedAt;
+			if (elapsed >= policy.totalTimeoutMs) throw new Error(`${catalog.type} catalog commit retry budget exhausted after ${attempt} attempts and ${elapsed}ms (limit ${policy.totalTimeoutMs}ms)`);
+			const remaining = policy.totalTimeoutMs - elapsed;
+			await sleep(Math.min(jitteredBackoff(attempt, policy), remaining));
+			workingCtx = await reloadCtx(catalog, target, workingCtx, err);
+		}
+	}
+	throw new Error("unreachable");
+}
+async function reloadCtx(catalog, target, workingCtx, lastErr) {
+	if (catalog.type === "rest") {
+		if (!target.namespace || !target.table) throw lastErr;
+		const { metadata } = await restCatalogLoadTable(catalog, {
+			namespace: target.namespace,
+			table: target.table
+		});
+		return {
+			metadata,
+			metadataFileName: workingCtx.metadataFileName,
+			version: workingCtx.version,
+			tableUrl: workingCtx.tableUrl,
+			resolver: workingCtx.resolver
+		};
+	}
+	if (!workingCtx.resolver) throw lastErr;
+	const fresh = await loadLatestFileCatalogMetadata({
+		tableUrl: workingCtx.tableUrl,
+		resolver: workingCtx.resolver,
+		lister: catalog.lister
+	});
+	return {
+		metadata: fresh.metadata,
+		metadataFileName: fresh.metadataFileName,
+		version: fresh.version,
+		tableUrl: workingCtx.tableUrl,
+		resolver: workingCtx.resolver
+	};
+}
+function resolveRetryPolicy(metadata) {
+	const props = metadata.properties ?? {};
+	const numRetries = parseTableProp(props["commit.retry.num-retries"]);
+	const maxAttempts = numRetries === void 0 ? DEFAULT_RETRY.maxAttempts : numRetries + 1;
+	const initialMs = parseTableProp(props["commit.retry.min-wait-ms"]) ?? DEFAULT_RETRY.initialMs;
+	const maxMs = parseTableProp(props["commit.retry.max-wait-ms"]) ?? DEFAULT_RETRY.maxMs;
+	const totalTimeoutMs = parseTableProp(props["commit.retry.total-timeout-ms"]) ?? DEFAULT_RETRY.totalTimeoutMs;
+	return {
+		maxAttempts,
+		initialMs,
+		maxMs,
+		factor: DEFAULT_RETRY.factor,
+		totalTimeoutMs
+	};
+}
+function parseTableProp(value) {
+	if (value === void 0 || value === null || value === "") return void 0;
+	const n = Number(value);
+	if (!Number.isFinite(n) || n < 0) return void 0;
+	return n;
+}
+function jitteredBackoff(attempt, policy) {
+	if (policy.initialMs === 0 || policy.maxMs === 0) return 0;
+	const base = Math.min(policy.maxMs, policy.initialMs * policy.factor ** (attempt - 1));
+	return Math.floor(Math.random() * base);
+}
+function sleep(ms) {
+	if (ms <= 0) return Promise.resolve();
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isCommitConflict(err) {
+	if (!err || typeof err !== "object") return false;
+	const { status } = err;
+	return status === 412 || status === 409;
+}
+export { IcebergTransactionConflictError, icebergAppend, icebergAppendBatches, icebergCreateTable, icebergDelete, icebergDropTable, icebergExpireSnapshots, icebergRewrite, icebergSetRef, icebergTransaction, icebergUpdateSchema };

package/dist/_virtual/node_modules/.pnpm/icebird@0.8.15_patch_hash=d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/types/catalog/file.d.mts

@@ -0,0 +1 @@
+import "../../src/types.mjs";