@gscdump/lakehouse 1.3.2 → 1.4.1

package/dist/node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/types.d.mts

@@ -0,0 +1,255 @@
+import { AsyncBuffer } from "../../../../hyparquet@1.26.2/node_modules/hyparquet/types/index.mjs";
+import "../../../../hyparquet@1.26.2/node_modules/hyparquet/types/node.mjs";
+import { Writer } from "../../../../hyparquet-writer@0.16.1_patch_hash_7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/types/index.mjs";
+import "../../../../hyparquet-writer@0.16.1_patch_hash_7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/types/node.mjs";
+interface WriterOptions {
+  /**
+   * If `'*'`, the writer must create the object only if it does not already
+   * exist (S3 conditional write: `If-None-Match: *`). On collision the
+   * underlying `finish()` rejects with an error whose `status` is 412 (or 409
+   * on some providers). The HTTP/S3 `urlResolver` translates this to the
+   * `If-None-Match` header. Other resolvers may honor or ignore it.
+   */
+  ifNoneMatch?: '*';
+}
+interface Resolver {
+  reader: (path: string, byteLength?: number) => AsyncBuffer | Promise<AsyncBuffer>;
+  writer?: (path: string, options?: WriterOptions) => Writer;
+  deleter?: (path: string) => Promise<void>;
+}
+type Lister = (path: string) => Promise<string[]>;
+/** Catalogs */
+interface RestCatalogContext {
+  type: 'rest';
+  url: string;
+  prefix: string;
+  defaults: Record<string, string>;
+  overrides: Record<string, string>;
+  requestInit?: RequestInit;
+  /** Optional per-request auth hook (e.g. SigV4 signing). Called after merging requestInit. */
+  signRequest?: (url: string, init?: RequestInit) => Promise<RequestInit>;
+}
+interface FileCatalog {
+  type: 'file';
+  resolver: Resolver;
+  lister?: Lister;
+  /**
+   * Opt in to S3-safe metadata commits: every `vN.metadata.json` (the
+   * initial create and every subsequent commit) is written with
+   * `If-None-Match: *` and `version-hint.text` is best-effort. High-level
+   * write functions retry on 412/409 by reloading the latest metadata and
+   * re-staging. `icebergCreateTable` and `icebergTransaction` do not retry.
+   * Default false preserves backwards-compatible (overwrite) behavior.
+   */
+  conditionalCommits?: boolean;
+}
+type Catalog = RestCatalogContext | FileCatalog;
+interface TableIdentifier {
+  namespace: string[];
+  name: string;
+}
+interface LoadTableResponse {
+  metadataLocation?: string;
+  metadata: TableMetadata;
+  config: Record<string, string>;
+}
+interface TableMetadata {
+  'format-version': number;
+  'table-uuid': string;
+  location: string;
+  'last-sequence-number': number; // missing in V1, required in V2+
+  'last-updated-ms': number;
+  'last-column-id': number;
+  'current-schema-id': number; // optional in V1, required in V2+
+  schemas: Schema[]; // optional in V1, required in V2+
+  'default-spec-id': number; // optional in V1, required in V2+
+  'partition-specs': PartitionSpec[]; // optional in V1, required in V2+
+  'last-partition-id': number; // optional in V1, required in V2+
+  properties?: Record<string, string>;
+  'current-snapshot-id'?: number | bigint;
+  snapshots?: Snapshot[];
+  'snapshot-log'?: SnapshotLog[];
+  'metadata-log'?: MetadataLog[];
+  'sort-orders': SortOrder[]; // optional in V1, required in V2+
+  'default-sort-order-id': number; // optional in V1, required in V2+
+  refs?: Record<string, SnapshotRef>;
+  statistics?: TableStatistics[];
+  'partition-statistics'?: PartitionStatistics[];
+  'next-row-id'?: number | bigint; // required in V3
+  'encryption-keys'?: EncryptionKey[]; // V3
+}
+interface Schema {
+  type: 'struct';
+  'schema-id': number;
+  'identifier-field-ids'?: number[];
+  fields: Field[];
+}
+interface Field {
+  id: number;
+  name: string;
+  required: boolean;
+  type: IcebergType;
+  doc?: string;
+  'initial-default'?: any;
+  'write-default'?: any;
+}
+type IcebergType = 'unknown' | 'boolean' | 'int' | 'long' | 'float' | 'double' | 'date' | 'time' | 'timestamp' | 'timestamptz' | 'timestamp_ns' | 'timestamptz_ns' | 'string' | 'uuid' | `fixed[${number}]` | 'binary' | `decimal(${number},${number})` | `decimal(${number}, ${number})` | 'variant' | 'geometry' | `geometry(${string})` | 'geography' | `geography(${string})` | IcebergNestedType;
+type IcebergNestedType = Schema | {
+  type: 'list';
+  'element-id': number;
+  'element-required': boolean;
+  element: IcebergType;
+} | {
+  type: 'map';
+  'key-id': number;
+  key: IcebergType;
+  'value-id': number;
+  'value-required': boolean;
+  value: IcebergType;
+};
+interface PartitionSpec {
+  'spec-id': number;
+  fields: PartitionField[];
+}
+interface PartitionField {
+  'source-id'?: number;
+  'source-ids'?: number[];
+  'field-id': number;
+  name: string;
+  transform: PartitionTransform;
+}
+type PartitionTransform = 'identity' | `bucket[${number}]` | `truncate[${number}]` | 'year' | 'month' | 'day' | 'hour' | 'void' | string;
+interface PartitionStatistics {
+  'snapshot-id': bigint;
+  'statistics-path': string;
+  'file-size-in-bytes': bigint;
+}
+interface SortOrder {
+  'order-id': number;
+  'fields': SortField[];
+}
+interface SortField {
+  transform: string;
+  'source-id'?: number;
+  'source-ids'?: number[]; // V3
+  'direction': 'asc' | 'desc';
+  'null-order': 'nulls-first' | 'nulls-last';
+}
+interface Snapshot {
+  'snapshot-id': number | bigint;
+  'parent-snapshot-id'?: number | bigint;
+  'sequence-number': number;
+  'timestamp-ms': number;
+  'manifest-list': string;
+  manifests?: Manifest[];
+  summary: {
+    // spec: "value of these fields should be of string type"
+    operation: string;
+    // 'spark.app.id'?: string
+    'added-data-files'?: string;
+    'added-records'?: string;
+    'deleted-data-files'?: string;
+    'deleted-records'?: string;
+    'removed-files-size'?: string;
+    'added-delete-files'?: string;
+    'removed-delete-files'?: string;
+    'added-position-deletes'?: string;
+    'removed-position-deletes'?: string;
+    'added-equality-deletes'?: string;
+    'removed-equality-deletes'?: string;
+    'added-dvs'?: string;
+    'removed-dvs'?: string;
+    'added-files-size'?: string;
+    'changed-partition-count'?: string;
+    'total-records'?: string;
+    'total-files-size'?: string;
+    'total-data-files'?: string;
+    'total-delete-files'?: string;
+    'total-position-deletes'?: string;
+    'total-equality-deletes'?: string;
+  };
+  'schema-id'?: number;
+  'first-row-id'?: number; // V3
+  'added-rows'?: number; // V3
+  'key-id'?: string; // V3
+}
+interface TableStatistics {
+  'snapshot-id': number | bigint;
+  'statistics-path': string;
+  'file-size-in-bytes': bigint;
+  'file-footer-size-in-bytes': bigint;
+}
+interface SnapshotLog {
+  'timestamp-ms': number;
+  'snapshot-id': number | bigint;
+}
+interface SnapshotRef {
+  'snapshot-id': number | bigint;
+  type: 'branch' | 'tag';
+  'min-snapshots-to-keep'?: number;
+  'max-snapshot-age-ms'?: number;
+  'max-ref-age-ms'?: number;
+}
+interface EncryptionKey {
+  'key-id': string;
+  'key-metadata': string;
+}
+interface MetadataLog {
+  'timestamp-ms': number;
+  'metadata-file': string;
+}
+interface Manifest {
+  manifest_path: string;
+  manifest_length: bigint;
+  partition_spec_id: number;
+  content: 0 | 1; // 0=data, 1=deletes
+  sequence_number?: bigint;
+  min_sequence_number?: bigint;
+  added_snapshot_id: bigint;
+  added_files_count: number;
+  existing_files_count: number;
+  deleted_files_count: number;
+  added_rows_count: bigint;
+  existing_rows_count: bigint;
+  deleted_rows_count: bigint;
+  partitions?: FieldSummary[];
+  // key_metadata?: unknown
+  first_row_id?: bigint | number;
+}
+interface ManifestEntry {
+  status: 0 | 1 | 2; // 0=existing, 1=added, 2=deleted
+  snapshot_id?: bigint;
+  sequence_number?: bigint;
+  file_sequence_number?: bigint;
+  partition_spec_id?: number;
+  data_file: DataFile;
+}
+interface FieldSummary {
+  contains_null: boolean;
+  contains_nan?: boolean | null;
+  lower_bound?: Uint8Array | null;
+  upper_bound?: Uint8Array | null;
+}
+interface DataFile {
+  content: 0 | 1 | 2; // 0=data, 1=position_delete, 2=equality_delete
+  file_path: string;
+  file_format: 'avro' | 'orc' | 'parquet' | 'puffin';
+  partition: Record<string, unknown>; // keyed by partition-field name in Avro
+  record_count: bigint;
+  file_size_in_bytes: bigint;
+  column_sizes?: Record<number, bigint>;
+  value_counts?: Record<number, bigint>;
+  null_value_counts?: Record<number, bigint>;
+  nan_value_counts?: Record<number, bigint>;
+  lower_bounds?: Record<number, unknown>;
+  upper_bounds?: Record<number, unknown>;
+  // key_metadata?: string
+  split_offsets?: bigint[];
+  equality_ids?: number[];
+  sort_order_id?: number;
+  first_row_id?: bigint | number;
+  referenced_data_file?: string;
+  content_offset?: bigint;
+  content_size_in_bytes?: bigint;
+}
+export { Catalog, DataFile, Field, FileCatalog, IcebergNestedType, IcebergType, Lister, LoadTableResponse, Manifest, ManifestEntry, PartitionSpec, PartitionTransform, Resolver, RestCatalogContext, Schema, Snapshot, SnapshotRef, SortOrder, TableIdentifier, TableMetadata, WriterOptions };

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

@@ -0,0 +1,26 @@
+function sanitize(name) {
+	let result = "";
+	for (let i = 0; i < name.length; i++) {
+		const ch = name.charAt(i);
+		const isLetter = /^[A-Za-z]$/.test(ch);
+		const isDigit = /^[0-9]$/.test(ch);
+		if (i === 0) if (isLetter || ch === "_") result += ch;
+		else result += isDigit ? "_" + ch : "_x" + ch.charCodeAt(0).toString(16).toUpperCase();
+		else if (isLetter || isDigit || ch === "_") result += ch;
+		else result += "_x" + ch.charCodeAt(0).toString(16).toUpperCase();
+	}
+	return result;
+}
+function bytesToHex(bytes) {
+	let hex = "";
+	for (let i = 0; i < bytes.length; i++) hex += bytes[i].toString(16).padStart(2, "0");
+	return hex;
+}
+function uuid4() {
+	if (globalThis.crypto?.randomUUID) return globalThis.crypto.randomUUID();
+	return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+		const r = Math.random() * 16 | 0;
+		return (c === "x" ? r : r & 3 | 8).toString(16);
+	});
+}
+export { bytesToHex, sanitize, uuid4 };

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

@@ -0,0 +1,392 @@
+import { stringifyIcebergJson } from "../json.mjs";
+import { maxFieldId, validateSchemaForVersion } from "../schema.mjs";
+import { parseDecimalType } from "./conversions.mjs";
+import { validatePartitionSpecForWrite } from "./partition.mjs";
+async function fileCatalogCommit({ tableUrl, metadata, metadataFileName, currentVersion, staged, resolver, conditionalCommits }) {
+	if (!tableUrl) throw new Error("tableUrl is required");
+	if (!resolver?.writer) throw new Error("resolver.writer is required");
+	checkRequirements(metadata, staged.requirements);
+	const updated = applyUpdates(staged.updates.some((up) => up.action === "add-snapshot") ? metadata : {
+		...metadata,
+		"last-updated-ms": Date.now()
+	}, staged.updates);
+	const priorMetadataLog = metadata["metadata-log"] ?? [];
+	const derivedVersion = currentVersion ?? deriveCurrentVersion(priorMetadataLog);
+	const newVersion = derivedVersion + 1;
+	const currentMetadataPath = metadataFileName ? `${tableUrl}/metadata/${metadataFileName}` : `${tableUrl}/metadata/v${derivedVersion}.metadata.json`;
+	const newMetadataPath = `${tableUrl}/metadata/v${newVersion}.metadata.json`;
+	const appendedLog = [...priorMetadataLog, {
+		"timestamp-ms": metadata["last-updated-ms"],
+		"metadata-file": currentMetadataPath
+	}];
+	const max = Number(updated.properties?.["write.metadata.previous-versions-max"] ?? 100);
+	const droppedLog = max > 0 && appendedLog.length > max ? appendedLog.slice(0, appendedLog.length - max) : [];
+	const trimmedLog = droppedLog.length > 0 ? appendedLog.slice(-max) : appendedLog;
+	const newMetadata = {
+		...updated,
+		"metadata-log": trimmedLog
+	};
+	const metaWriter = conditionalCommits ? resolver.writer(newMetadataPath, { ifNoneMatch: "*" }) : resolver.writer(newMetadataPath);
+	metaWriter.appendBytes(new TextEncoder().encode(stringifyIcebergJson(newMetadata)));
+	await metaWriter.finish();
+	try {
+		const hintWriter = resolver.writer(`${tableUrl}/metadata/version-hint.text`);
+		hintWriter.appendBytes(new TextEncoder().encode(String(newVersion)));
+		await hintWriter.finish();
+	} catch {}
+	if (updated.properties?.["write.metadata.delete-after-commit.enabled"] === "true" && droppedLog.length > 0 && resolver.deleter) {
+		const { deleter } = resolver;
+		await Promise.allSettled(droppedLog.map((entry) => deleter(entry["metadata-file"])));
+	}
+	return newMetadata;
+}
+function deriveCurrentVersion(priorMetadataLog) {
+	if (priorMetadataLog.length === 0) return 1;
+	const match = (priorMetadataLog[priorMetadataLog.length - 1]["metadata-file"].split("/").pop() ?? "").match(/^(?:v(\d+)|0*(\d+)-[0-9a-f-]+)\.metadata\.json$/);
+	if (match) return Number(match[1] ?? match[2]) + 1;
+	return priorMetadataLog.length + 1;
+}
+function checkRequirements(metadata, requirements) {
+	for (const req of requirements) if (req.type === "assert-create") throw new Error("requirement failed: assert-create against an existing table");
+	else if (req.type === "assert-table-uuid") {
+		if (metadata["table-uuid"] !== req.uuid) throw new Error(`requirement failed: table-uuid expected ${req.uuid}, got ${metadata["table-uuid"]}`);
+	} else if (req.type === "assert-ref-snapshot-id") {
+		let current = (metadata.refs ?? {})[req.ref]?.["snapshot-id"] ?? null;
+		if (current === null && req.ref === "main") current = metadata["current-snapshot-id"] ?? null;
+		const expected = req["snapshot-id"];
+		if (!(current === expected || current != null && expected != null && BigInt(current) === BigInt(expected))) throw new Error(`requirement failed: ref ${req.ref} expected snapshot ${expected}, got ${current}`);
+	} else if (req.type === "assert-next-row-id") {
+		const current = Number(metadata["next-row-id"] ?? 0);
+		if (current !== req["next-row-id"]) throw new Error(`requirement failed: next-row-id expected ${req["next-row-id"]}, got ${current}`);
+	} else if (req.type === "assert-current-schema-id") {
+		const current = metadata["current-schema-id"];
+		if (current !== req["current-schema-id"]) throw new Error(`requirement failed: current-schema-id expected ${req["current-schema-id"]}, got ${current}`);
+	} else if (req.type === "assert-last-assigned-field-id") {
+		const current = metadata["last-column-id"];
+		if (current !== req["last-assigned-field-id"]) throw new Error(`requirement failed: last-assigned-field-id expected ${req["last-assigned-field-id"]}, got ${current}`);
+	} else if (req.type === "assert-last-assigned-partition-id") {
+		const current = metadata["last-partition-id"];
+		if (current !== req["last-assigned-partition-id"]) throw new Error(`requirement failed: last-assigned-partition-id expected ${req["last-assigned-partition-id"]}, got ${current}`);
+	} else if (req.type === "assert-default-spec-id") {
+		const current = metadata["default-spec-id"];
+		if (current !== req["default-spec-id"]) throw new Error(`requirement failed: default-spec-id expected ${req["default-spec-id"]}, got ${current}`);
+	} else if (req.type === "assert-default-sort-order-id") {
+		const current = metadata["default-sort-order-id"];
+		if (current !== req["default-sort-order-id"]) throw new Error(`requirement failed: default-sort-order-id expected ${req["default-sort-order-id"]}, got ${current}`);
+	} else throw new Error(`unknown requirement: ${JSON.stringify(req)}`);
+}
+function applyUpdates(metadata, updates) {
+	let next = { ...metadata };
+	for (const up of updates) if (up.action === "add-snapshot") {
+		const snap = up.snapshot;
+		const priorSnapshots = next.snapshots ?? [];
+		if (priorSnapshots.some((s) => s["snapshot-id"] === snap["snapshot-id"])) throw new Error(`add-snapshot: snapshot-id ${snap["snapshot-id"]} already exists`);
+		next = {
+			...next,
+			snapshots: [...priorSnapshots, snap],
+			"last-sequence-number": Math.max(next["last-sequence-number"] ?? 0, snap["sequence-number"]),
+			"last-updated-ms": snap["timestamp-ms"]
+		};
+		if (next["format-version"] >= 3 && snap["first-row-id"] !== void 0 && snap["added-rows"] !== void 0) {
+			const nextRowId = snap["first-row-id"] + snap["added-rows"];
+			next["next-row-id"] = Math.max(Number(next["next-row-id"] ?? 0), nextRowId);
+		}
+	} else if (up.action === "set-properties") next = {
+		...next,
+		properties: {
+			...next.properties,
+			...up.updates
+		}
+	};
+	else if (up.action === "remove-properties") {
+		const properties = { ...next.properties };
+		for (const key of up.removals) delete properties[key];
+		next = {
+			...next,
+			properties
+		};
+	} else if (up.action === "add-schema") {
+		const schemas = next.schemas ?? [];
+		let schemaId = up.schema["schema-id"];
+		if (schemaId === -1) schemaId = schemas.reduce((m, s) => Math.max(m, s["schema-id"]), -1) + 1;
+		else if (schemas.some((s) => s["schema-id"] === schemaId)) throw new Error(`add-schema: schema-id ${schemaId} already exists`);
+		const newSchema = {
+			...up.schema,
+			"schema-id": schemaId
+		};
+		validateSchemaForVersion(newSchema, next["format-version"]);
+		const priorLastColumnId = next["last-column-id"] ?? 0;
+		validateAssignedFieldIds(newSchema, currentAssignedIdIndex(schemas, next["current-schema-id"]), priorLastColumnId);
+		validateSchemaEvolution(schemas, newSchema, priorLastColumnId, next["format-version"]);
+		validateNewRequiredFields(newSchema, priorLastColumnId);
+		next = {
+			...next,
+			schemas: [...schemas, newSchema],
+			"last-column-id": Math.max(priorLastColumnId, maxFieldId(newSchema.fields))
+		};
+	} else if (up.action === "set-current-schema") {
+		let id = up["schema-id"];
+		const schemas = next.schemas ?? [];
+		if (id === -1) {
+			if (schemas.length === 0) throw new Error("set-current-schema: table has no schemas");
+			id = schemas[schemas.length - 1]["schema-id"];
+		} else if (!schemas.some((s) => s["schema-id"] === id)) throw new Error(`set-current-schema: schema-id ${id} not found`);
+		next = {
+			...next,
+			"current-schema-id": id
+		};
+	} else if (up.action === "add-sort-order") {
+		const orders = next["sort-orders"] ?? [];
+		let orderId = up["sort-order"]["order-id"];
+		if (orderId === -1) orderId = orders.reduce((m, o) => Math.max(m, o["order-id"]), -1) + 1;
+		else if (orders.some((o) => o["order-id"] === orderId)) throw new Error(`add-sort-order: order-id ${orderId} already exists`);
+		const newOrder = {
+			...up["sort-order"],
+			"order-id": orderId
+		};
+		next = {
+			...next,
+			"sort-orders": [...orders, newOrder]
+		};
+	} else if (up.action === "set-default-sort-order") {
+		let id = up["sort-order-id"];
+		const orders = next["sort-orders"] ?? [];
+		if (id === -1) {
+			if (orders.length === 0) throw new Error("set-default-sort-order: table has no sort orders");
+			id = orders[orders.length - 1]["order-id"];
+		} else if (!orders.some((o) => o["order-id"] === id)) throw new Error(`set-default-sort-order: sort-order-id ${id} not found`);
+		next = {
+			...next,
+			"default-sort-order-id": id
+		};
+	} else if (up.action === "add-spec") {
+		const specs = next["partition-specs"] ?? [];
+		let specId = up.spec["spec-id"];
+		if (specId === -1) specId = specs.reduce((m, s) => Math.max(m, s["spec-id"]), -1) + 1;
+		else if (specs.some((s) => s["spec-id"] === specId)) throw new Error(`add-spec: spec-id ${specId} already exists`);
+		const newSpec = {
+			...up.spec,
+			"spec-id": specId
+		};
+		validatePartitionSpecEvolution(specs, newSpec, currentSchemaForMetadata(next));
+		let nextLastPartitionId = next["last-partition-id"] ?? 0;
+		for (const f of newSpec.fields) if (f["field-id"] > nextLastPartitionId) nextLastPartitionId = f["field-id"];
+		next = {
+			...next,
+			"partition-specs": [...specs, newSpec],
+			"last-partition-id": nextLastPartitionId
+		};
+	} else if (up.action === "set-default-spec") {
+		let id = up["spec-id"];
+		const specs = next["partition-specs"] ?? [];
+		if (id === -1) {
+			if (specs.length === 0) throw new Error("set-default-spec: table has no partition specs");
+			id = specs[specs.length - 1]["spec-id"];
+		} else if (!specs.some((s) => s["spec-id"] === id)) throw new Error(`set-default-spec: spec-id ${id} not found`);
+		next = {
+			...next,
+			"default-spec-id": id
+		};
+	} else if (up.action === "remove-snapshots") {
+		const removeIds = new Set(up["snapshot-ids"]);
+		const snapshots = (next.snapshots ?? []).filter((s) => !removeIds.has(s["snapshot-id"]));
+		const log = (next["snapshot-log"] ?? []).filter((e) => !removeIds.has(e["snapshot-id"]));
+		next = {
+			...next,
+			snapshots,
+			"snapshot-log": log
+		};
+	} else if (up.action === "set-snapshot-ref") {
+		const ref = {
+			"snapshot-id": up["snapshot-id"],
+			type: up.type
+		};
+		if (up["min-snapshots-to-keep"] !== void 0) ref["min-snapshots-to-keep"] = up["min-snapshots-to-keep"];
+		if (up["max-snapshot-age-ms"] !== void 0) ref["max-snapshot-age-ms"] = up["max-snapshot-age-ms"];
+		if (up["max-ref-age-ms"] !== void 0) ref["max-ref-age-ms"] = up["max-ref-age-ms"];
+		next = {
+			...next,
+			refs: {
+				...next.refs,
+				[up["ref-name"]]: ref
+			}
+		};
+		if (up["ref-name"] === "main" && up.type === "branch") {
+			next["current-snapshot-id"] = up["snapshot-id"];
+			next["snapshot-log"] = [...next["snapshot-log"] ?? [], {
+				"timestamp-ms": next["last-updated-ms"],
+				"snapshot-id": up["snapshot-id"]
+			}];
+		}
+	} else throw new Error(`unknown update: ${JSON.stringify(up)}`);
+	return next;
+}
+function currentAssignedIdIndex(schemas, currentSchemaId) {
+	const currentSchema = schemas.find((s) => s["schema-id"] === currentSchemaId) ?? schemas[schemas.length - 1];
+	const assignedIds = /* @__PURE__ */ new Map();
+	if (currentSchema) indexAssignedFieldIds(currentSchema.fields, "", assignedIds);
+	return assignedIds;
+}
+function indexAssignedFieldIds(fields, prefix, assignedIds) {
+	for (const field of fields) {
+		const path = prefix ? `${prefix}.${field.name}` : field.name;
+		assignedIds.set(field.id, {
+			kind: "field",
+			path
+		});
+		indexAssignedTypeIds(field.type, path, assignedIds);
+	}
+}
+function indexAssignedTypeIds(type, path, assignedIds) {
+	if (typeof type === "string") return;
+	if (type.type === "struct") indexAssignedFieldIds(type.fields, path, assignedIds);
+	else if (type.type === "list") {
+		assignedIds.set(type["element-id"], {
+			kind: "list element",
+			path: `${path}.element`
+		});
+		indexAssignedTypeIds(type.element, `${path}.element`, assignedIds);
+	} else if (type.type === "map") {
+		assignedIds.set(type["key-id"], {
+			kind: "map key",
+			path: `${path}.key`
+		});
+		assignedIds.set(type["value-id"], {
+			kind: "map value",
+			path: `${path}.value`
+		});
+		indexAssignedTypeIds(type.key, `${path}.key`, assignedIds);
+		indexAssignedTypeIds(type.value, `${path}.value`, assignedIds);
+	}
+}
+function validateAssignedFieldIds(schema, priorAssignedIds, priorLastColumnId) {
+	validateAssignedFields(schema.fields, "", priorAssignedIds, priorLastColumnId);
+}
+function validateAssignedFields(fields, prefix, priorAssignedIds, priorLastColumnId) {
+	for (const field of fields) {
+		const path = prefix ? `${prefix}.${field.name}` : field.name;
+		validateAssignedId(field.id, "field", path, priorAssignedIds, priorLastColumnId);
+		validateAssignedTypeIds(field.type, path, priorAssignedIds, priorLastColumnId);
+	}
+}
+function validateAssignedTypeIds(type, path, priorAssignedIds, priorLastColumnId) {
+	if (typeof type === "string") return;
+	if (type.type === "struct") validateAssignedFields(type.fields, path, priorAssignedIds, priorLastColumnId);
+	else if (type.type === "list") {
+		validateAssignedId(type["element-id"], "list element", `${path}.element`, priorAssignedIds, priorLastColumnId);
+		validateAssignedTypeIds(type.element, `${path}.element`, priorAssignedIds, priorLastColumnId);
+	} else if (type.type === "map") {
+		validateAssignedId(type["key-id"], "map key", `${path}.key`, priorAssignedIds, priorLastColumnId);
+		validateAssignedId(type["value-id"], "map value", `${path}.value`, priorAssignedIds, priorLastColumnId);
+		validateAssignedTypeIds(type.key, `${path}.key`, priorAssignedIds, priorLastColumnId);
+		validateAssignedTypeIds(type.value, `${path}.value`, priorAssignedIds, priorLastColumnId);
+	}
+}
+function validateAssignedId(id, kind, path, priorAssignedIds, priorLastColumnId) {
+	if (id > priorLastColumnId) return;
+	const prior = priorAssignedIds.get(id);
+	if (!prior) throw new Error(`add-schema: ${kind} ${path} uses unassigned id ${id} (last-column-id ${priorLastColumnId})`);
+	if (prior.kind !== kind) throw new Error(`add-schema: ${kind} ${path} uses id ${id} previously assigned to ${prior.kind} ${prior.path}`);
+}
+function validateNewRequiredFields(schema, priorLastColumnId) {
+	for (const field of schema.fields) if (field.id > priorLastColumnId && field.required) {
+		if (field["initial-default"] == null) throw new Error(`add-schema: required field ${field.name} (id ${field.id}) needs a non-null initial-default`);
+		if (field["write-default"] == null) throw new Error(`add-schema: required field ${field.name} (id ${field.id}) needs a non-null write-default`);
+	}
+}
+function validateSchemaEvolution(schemas, newSchema, priorLastColumnId, formatVersion) {
+	for (const field of newSchema.fields) {
+		if (field.id > priorLastColumnId) continue;
+		const prior = latestFieldById(schemas, field.id);
+		if (!prior) continue;
+		if (!canPromoteType(prior.type, field.type, formatVersion)) throw new Error(`add-schema: cannot promote field ${field.name} from ${typeToString(prior.type)} to ${typeToString(field.type)}`);
+		if (!defaultsEqual(prior["initial-default"], field["initial-default"])) throw new Error(`add-schema: initial-default for field ${field.name} cannot change`);
+	}
+}
+function latestFieldById(schemas, id) {
+	for (let i = schemas.length - 1; i >= 0; i--) {
+		const field = schemas[i].fields.find((f) => f.id === id);
+		if (field) return field;
+	}
+}
+function canPromoteType(from, to, formatVersion) {
+	if (typesEqual(from, to)) return true;
+	if (typeof from !== "string" || typeof to !== "string") return false;
+	if (formatVersion >= 3 && from === "unknown") return true;
+	if (from === "int" && to === "long") return true;
+	if (from === "float" && to === "double") return true;
+	if (formatVersion >= 3 && from === "date" && (to === "timestamp" || to === "timestamp_ns")) return true;
+	return decimalPromotionAllowed(from, to);
+}
+function typesEqual(a, b) {
+	if (typeof a === "string" || typeof b === "string") return a === b;
+	return JSON.stringify(a) === JSON.stringify(b);
+}
+function decimalPromotionAllowed(from, to) {
+	const a = parseDecimalType(from);
+	const b = parseDecimalType(to);
+	return Boolean(a && b && b.precision > a.precision && b.scale === a.scale);
+}
+function typeToString(type) {
+	return typeof type === "string" ? type : JSON.stringify(type);
+}
+function defaultsEqual(a, b) {
+	if (Object.is(a, b)) return true;
+	if (!a || !b || typeof a !== "object" || typeof b !== "object") return false;
+	if (Array.isArray(a) || Array.isArray(b)) {
+		if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+		for (let i = 0; i < a.length; i++) if (!defaultsEqual(a[i], b[i])) return false;
+		return true;
+	}
+	const aKeys = Object.keys(a);
+	const bKeys = Object.keys(b);
+	if (aKeys.length !== bKeys.length) return false;
+	for (const key of aKeys) {
+		if (!Object.hasOwn(b, key)) return false;
+		if (!defaultsEqual(a[key], b[key])) return false;
+	}
+	return true;
+}
+function validatePartitionSpecEvolution(specs, newSpec, schema) {
+	validateWritablePartitionSpec(newSpec, schema);
+	if (specs.some((spec) => partitionSpecsEquivalent(spec, newSpec))) throw new Error("add-spec: equivalent partition spec already exists");
+	for (const field of newSpec.fields) {
+		const equivalent = equivalentPartitionField(specs, field);
+		if (equivalent && equivalent["field-id"] !== field["field-id"]) throw new Error(`add-spec: partition field ${field.name} must reuse field-id ${equivalent["field-id"]}`);
+	}
+}
+function validateWritablePartitionSpec(spec, schema) {
+	try {
+		validatePartitionSpecForWrite(schema, spec, "add-spec");
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		if (message.startsWith("unsupported partition transform: ")) throw new Error(`add-spec: ${message}`);
+		throw err;
+	}
+}
+function currentSchemaForMetadata(metadata) {
+	const schema = metadata.schemas?.find((s) => s["schema-id"] === metadata["current-schema-id"]);
+	if (!schema) throw new Error("add-spec: current schema not found in metadata");
+	return schema;
+}
+function equivalentPartitionField(specs, field) {
+	for (const spec of specs) {
+		const found = spec.fields.find((existing) => partitionFieldsEquivalent(existing, field));
+		if (found) return found;
+	}
+}
+function partitionSpecsEquivalent(a, b) {
+	if (a.fields.length !== b.fields.length) return false;
+	for (let i = 0; i < a.fields.length; i++) if (!partitionFieldsEquivalent(a.fields[i], b.fields[i])) return false;
+	return true;
+}
+function partitionFieldsEquivalent(a, b) {
+	return a["source-id"] === b["source-id"] && idsListEquivalent(a["source-ids"], b["source-ids"]) && a.transform === b.transform && a.name === b.name;
+}
+function idsListEquivalent(a, b) {
+	if (a === void 0 || b === void 0) return a === b;
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
+export { applyUpdates, checkRequirements, fileCatalogCommit };