@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/partition.mjs

@@ -0,0 +1,178 @@
+import { bytesToHex } from "../utils.mjs";
+import { decimalRequiredBytes, decimalToFixedBytes, parseDecimalType, toUint8Array, uuidToBytes } from "./conversions.mjs";
+import { applyTransform, transformResultType } from "./transform.mjs";
+function groupByPartition(records, schema, partitionSpec) {
+	const sourceFields = partitionSpec.fields.map((pf) => {
+		const sourceId = pf["source-id"];
+		if (sourceId === void 0) throw new Error(`partition field ${pf.name} is missing source-id`);
+		const sourceField = schema.fields.find((f) => f.id === sourceId);
+		if (!sourceField) throw new Error(`partition source field id ${sourceId} not found in schema`);
+		return {
+			partitionName: pf.name,
+			sourceName: sourceField.name,
+			sourceType: sourceField.type,
+			sourceWriteDefault: sourceField["write-default"],
+			transform: pf.transform,
+			resultType: transformResultType(pf.transform, sourceField.type)
+		};
+	});
+	const groups = /* @__PURE__ */ new Map();
+	for (const record of records) {
+		const partition = {};
+		const keyParts = [];
+		for (const { partitionName, sourceName, sourceType, sourceWriteDefault, transform, resultType } of sourceFields) {
+			let v = record[sourceName];
+			if (v === void 0 && sourceWriteDefault !== void 0) v = sourceWriteDefault;
+			partition[partitionName] = applyTransform(transform, v === void 0 ? null : v, sourceType);
+			keyParts.push(partitionKeyPart(partition[partitionName], resultType));
+		}
+		const key = JSON.stringify(keyParts);
+		let group = groups.get(key);
+		if (!group) {
+			group = {
+				partition,
+				records: []
+			};
+			groups.set(key, group);
+		}
+		group.records.push(record);
+	}
+	return [...groups.values()];
+}
+function validatePartitionSpecForWrite(schema, partitionSpec, label = "partition spec") {
+	for (const pf of partitionSpec.fields) {
+		const sourceId = pf["source-id"];
+		if (sourceId === void 0) throw new Error(`${label}: partition field ${pf.name} is missing source-id`);
+		const sourceField = schema.fields.find((f) => f.id === sourceId);
+		if (!sourceField) throw new Error(`${label}: partition source field id ${sourceId} not found in schema`);
+		icebergTypeToAvro(transformResultType(pf.transform, sourceField.type), pf["field-id"]);
+	}
+}
+function partitionAvroSchema(schema, partitionSpec) {
+	return {
+		type: "record",
+		name: "r102",
+		fields: 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 {
+				name: pf.name,
+				"field-id": pf["field-id"],
+				default: null,
+				type: ["null", icebergTypeToAvro(resultType, pf["field-id"])]
+			};
+		})
+	};
+}
+function partitionSpecJson(partitionSpec) {
+	return JSON.stringify(partitionSpec.fields);
+}
+function partitionToAvroRecord(partition, schema, partitionSpec) {
+	const out = {};
+	for (const pf of partitionSpec.fields) {
+		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);
+		const value = partition[pf.name];
+		out[pf.name] = value == null ? null : coerceForAvro(value, resultType);
+	}
+	return out;
+}
+function partitionKeyPart(value, type) {
+	if (value === null || value === void 0) return "__null__";
+	const name = typeof type === "string" ? type : type.type;
+	if (name === "uuid") return `uuid:${bytesToHex(uuidToBytes(value, "uuid partition value"))}`;
+	if (typeof value === "number" && (name === "float" || name === "double")) return `${name}:${floatPartitionKey(value, name)}`;
+	if (name === "long") return `long:${BigInt(value)}`;
+	if (typeof value === "bigint") return `b:${value.toString()}`;
+	if (value instanceof Date) return `d:${value.getTime()}`;
+	if (value instanceof Uint8Array) return `x:${bytesToHex(value)}`;
+	return `${typeof value}:${String(value)}`;
+}
+function floatPartitionKey(value, type) {
+	if (Number.isNaN(value)) return "nan";
+	const bytes = new Uint8Array(type === "float" ? 4 : 8);
+	const view = new DataView(bytes.buffer);
+	if (type === "float") view.setFloat32(0, value, false);
+	else view.setFloat64(0, value, false);
+	return bytesToHex(bytes);
+}
+function icebergTypeToAvro(type, fieldId) {
+	const name = typeof type === "string" ? type : type.type;
+	const decimal = parseDecimalType(name);
+	if (decimal) return {
+		type: "fixed",
+		name: `r102_${fieldId}`,
+		size: decimalRequiredBytes(decimal.precision),
+		logicalType: "decimal",
+		precision: decimal.precision,
+		scale: decimal.scale
+	};
+	const fixed = /^fixed\[(\d+)\]$/.exec(name);
+	if (fixed) return {
+		type: "fixed",
+		name: `r102_${fieldId}`,
+		size: parseInt(fixed[1], 10)
+	};
+	switch (name) {
+		case "boolean": return "boolean";
+		case "int": return "int";
+		case "long": return "long";
+		case "float": return "float";
+		case "double": return "double";
+		case "string": return "string";
+		case "uuid": return {
+			type: "fixed",
+			name: `r102_${fieldId}`,
+			size: 16,
+			logicalType: "uuid"
+		};
+		case "binary": return "bytes";
+		case "date": return {
+			type: "int",
+			logicalType: "date"
+		};
+		case "time": return {
+			type: "long",
+			logicalType: "time-micros"
+		};
+		case "timestamp": return {
+			type: "long",
+			logicalType: "timestamp-micros",
+			"adjust-to-utc": false
+		};
+		case "timestamptz": return {
+			type: "long",
+			logicalType: "timestamp-micros",
+			"adjust-to-utc": true
+		};
+		case "timestamp_ns": return {
+			type: "long",
+			logicalType: "timestamp-nanos",
+			"adjust-to-utc": false
+		};
+		case "timestamptz_ns": return {
+			type: "long",
+			logicalType: "timestamp-nanos",
+			"adjust-to-utc": true
+		};
+		default: throw new Error(`unsupported partition source type: ${name}`);
+	}
+}
+function coerceForAvro(value, type) {
+	const name = typeof type === "string" ? type : type.type;
+	if (name === "long") return typeof value === "bigint" ? value : BigInt(value);
+	if (name === "uuid") return uuidToBytes(value, "uuid partition value");
+	const decimal = parseDecimalType(name);
+	if (decimal) return decimalToFixedBytes(value, decimal.precision, decimal.scale, `decimal(${decimal.precision},${decimal.scale}) partition value`);
+	const fixed = /^fixed\[(\d+)\]$/.exec(name);
+	if (fixed) {
+		const bytes = toUint8Array(value);
+		const expected = parseInt(fixed[1], 10);
+		if (bytes.length !== expected) throw new Error(`expected fixed[${expected}] partition value`);
+		return bytes;
+	}
+	return value;
+}
+export { groupByPartition, partitionAvroSchema, partitionSpecJson, partitionToAvroRecord, validatePartitionSpecForWrite };

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

@@ -0,0 +1,148 @@
+import { typeName } from "../schema.mjs";
+function serializeValue(value, type) {
+	const name = typeName(type);
+	if (name.startsWith("decimal(")) {
+		const m = /^decimal\((\d+),\s*(\d+)\)$/.exec(name);
+		if (!m) return void 0;
+		const scale = parseInt(m[2], 10);
+		if (typeof value !== "number" && typeof value !== "bigint") return void 0;
+		const factor = 10n ** BigInt(scale);
+		return twosComplementMinBigEndian(typeof value === "bigint" ? value * factor : BigInt(Math.round(value * Number(factor))));
+	}
+	if (name.startsWith("fixed[")) return value instanceof Uint8Array ? value : void 0;
+	switch (name) {
+		case "boolean": return new Uint8Array([value ? 1 : 0]);
+		case "int": {
+			const buf = /* @__PURE__ */ new ArrayBuffer(4);
+			new DataView(buf).setInt32(0, value, true);
+			return new Uint8Array(buf);
+		}
+		case "long": {
+			const buf = /* @__PURE__ */ new ArrayBuffer(8);
+			new DataView(buf).setBigInt64(0, typeof value === "bigint" ? value : BigInt(value), true);
+			return new Uint8Array(buf);
+		}
+		case "float": {
+			const buf = /* @__PURE__ */ new ArrayBuffer(4);
+			new DataView(buf).setFloat32(0, value, true);
+			return new Uint8Array(buf);
+		}
+		case "double": {
+			const buf = /* @__PURE__ */ new ArrayBuffer(8);
+			new DataView(buf).setFloat64(0, value, true);
+			return new Uint8Array(buf);
+		}
+		case "date": {
+			const days = value instanceof Date ? Math.floor(value.getTime() / 864e5) : Number(value);
+			const buf = /* @__PURE__ */ new ArrayBuffer(4);
+			new DataView(buf).setInt32(0, days, true);
+			return new Uint8Array(buf);
+		}
+		case "time": {
+			const buf = /* @__PURE__ */ new ArrayBuffer(8);
+			new DataView(buf).setBigInt64(0, typeof value === "bigint" ? value : BigInt(value), true);
+			return new Uint8Array(buf);
+		}
+		case "timestamp":
+		case "timestamptz": {
+			const buf = /* @__PURE__ */ new ArrayBuffer(8);
+			new DataView(buf).setBigInt64(0, timestampToMicros(value), true);
+			return new Uint8Array(buf);
+		}
+		case "timestamp_ns":
+		case "timestamptz_ns": {
+			const buf = /* @__PURE__ */ new ArrayBuffer(8);
+			new DataView(buf).setBigInt64(0, timestampToNanos(value), true);
+			return new Uint8Array(buf);
+		}
+		case "string": return new TextEncoder().encode(value);
+		case "binary": return value instanceof Uint8Array ? value : void 0;
+		case "uuid":
+			if (value instanceof Uint8Array && value.length === 16) return value;
+			if (typeof value === "string") return uuidStringToBytes(value);
+			return;
+		default: return;
+	}
+}
+function compare(a, b, type) {
+	switch (typeName(type)) {
+		case "boolean": return (a ? 1 : 0) - (b ? 1 : 0);
+		case "int": return a < b ? -1 : a > b ? 1 : 0;
+		case "float":
+		case "double": return compareFloating(a, b);
+		case "long": {
+			const ai = typeof a === "bigint" ? a : BigInt(a);
+			const bi = typeof b === "bigint" ? b : BigInt(b);
+			return ai < bi ? -1 : ai > bi ? 1 : 0;
+		}
+		case "date": {
+			const ad = dateToDays(a);
+			const bd = dateToDays(b);
+			if (Number.isNaN(ad) || Number.isNaN(bd)) return NaN;
+			return ad < bd ? -1 : ad > bd ? 1 : 0;
+		}
+		case "timestamp":
+		case "timestamptz": return compareBigInt(timestampToMicros(a), timestampToMicros(b));
+		case "timestamp_ns":
+		case "timestamptz_ns": return compareBigInt(timestampToNanos(a), timestampToNanos(b));
+		case "string": return a < b ? -1 : a > b ? 1 : 0;
+		case "binary":
+		case "uuid": return compareBytes(a, b);
+		default:
+			if (typeName(type).startsWith("fixed[")) return compareBytes(a, b);
+			return a < b ? -1 : a > b ? 1 : 0;
+	}
+}
+function compareFloating(a, b) {
+	if (Object.is(a, b)) return 0;
+	if (a === 0 && b === 0) return Object.is(a, -0) ? -1 : 1;
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+function compareBigInt(a, b) {
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+function dateToDays(value) {
+	if (value instanceof Date) return Math.floor(value.getTime() / 864e5);
+	if (typeof value === "bigint") return Number(value);
+	if (typeof value === "number") return value;
+	if (typeof value === "string") {
+		const ms = Date.parse(value);
+		return Number.isNaN(ms) ? NaN : Math.floor(ms / 864e5);
+	}
+	return NaN;
+}
+function timestampToMicros(value) {
+	return typeof value === "bigint" ? value : value instanceof Date ? BigInt(value.getTime()) * 1000n : BigInt(value);
+}
+function timestampToNanos(value) {
+	return typeof value === "bigint" ? value : value instanceof Date ? BigInt(value.getTime()) * 1000000n : BigInt(value);
+}
+function compareBytes(a, b) {
+	const len = Math.min(a.length, b.length);
+	for (let i = 0; i < len; i++) if (a[i] !== b[i]) return a[i] - b[i];
+	return a.length - b.length;
+}
+function twosComplementMinBigEndian(value) {
+	const bytes = [];
+	let v = value;
+	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 uuidStringToBytes(s) {
+	const hex = s.replace(/-/g, "");
+	if (hex.length !== 32) return void 0;
+	const out = /* @__PURE__ */ new Uint8Array(16);
+	for (let i = 0; i < 16; i++) {
+		const byte = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+		if (Number.isNaN(byte)) return void 0;
+		out[i] = byte;
+	}
+	return out;
+}
+export { compare, compareBigInt, compareBytes, compareFloating, dateToDays, serializeValue, timestampToMicros, timestampToNanos, twosComplementMinBigEndian, uuidStringToBytes };

package/dist/_virtual/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/_virtual/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 };