@sixb/core 0.1.8 → 0.1.10

package/dist/{chunk-mth82m8t.js → chunk-qyeptdyv.js}

@@ -1,30 +1,56 @@
 // @bun
 import {
-  LakeConcurrencyError,
-  LakeStorageError,
-  cloneDatasetMergeChange,
-  encodeDatasetPrimaryKey,
-  getDatasetMergeChangeValidationError,
-  getDatasetPrimaryKeyColumns
-} from "./chunk-n4khvw9n.js";
-import {
-  assertDatasetDefinition,
   datasetSequenceValue,
-  getDatasetRowValidationError
-} from "./chunk-pc7ys28c.js";
+  assertDatasetDefinition2,
+  getDatasetRowValidationError2
+} from "./chunk-860dwwy0.js";
+import {
+  LakeStorageError2,
+  LakeConcurrencyError2,
+  getDatasetPrimaryKeyColumns2,
+  encodeDatasetPrimaryKey2,
+  getDatasetMergeChangeValidationError2,
+  cloneDatasetMergeChange2
+} from "./chunk-9qsh3p5y.js";
 import {
-  normalizeDecimalValue
-} from "./chunk-04b07a9q.js";
+  normalizeDecimalValue2
+} from "./chunk-3bh94gbw.js";
 import {
-  stableJsonStringify
-} from "./chunk-n6jxh8sw.js";
+  stableJsonStringify2
+} from "./chunk-wy0qdqfm.js";
+// src/lake-storage/changes.ts
+function resolveDatasetChangeColumns2(input, before, after) {
+  for (const value of [input.datasetId, input.fromVersionId, input.toVersionId]) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+      throw new LakeStorageError2("[LakeStorage] Change reads require explicit dataset and version ids.");
+    }
+  }
+  if (input.keyColumns.length === 0 || new Set(input.keyColumns).size !== input.keyColumns.length || input.columns.length === 0 || new Set(input.columns).size !== input.columns.length || input.columns.some((column) => typeof column !== "string" || column.length === 0) || input.keyColumns.some((column) => !input.columns.includes(column))) {
+    throw new LakeStorageError2("[LakeStorage] Change reads require distinct columns including every key column.");
+  }
+  if (!before || !after)
+    return null;
+  const oldColumns = new Map(before.schema.columns.map((column) => [column.name, column]));
+  const newColumns = new Map(after.schema.columns.map((column) => [column.name, column]));
+  const columns = [];
+  for (const name of input.columns) {
+    const previous = oldColumns.get(name);
+    const next = newColumns.get(name);
+    if (!previous || !next || previous.type !== next.type)
+      return null;
+    if (input.keyColumns.includes(name) && next.type !== "string")
+      return null;
+    columns.push(next);
+  }
+  return columns;
+}
 // src/lake-storage/definition-updates.ts
 var SCHEMA_UPDATE_V1_POLICY = "Dataset definition updates V1 support only adding nullable columns.";
-function planDatasetDefinitionUpdate(existing, requested) {
+function planDatasetDefinitionUpdate2(existing, requested) {
   assertSameDataset(existing, requested);
-  assertDatasetDefinition(requested, (message) => new LakeStorageError(`[SixbLake] ${message}`));
+  assertDatasetDefinition2(requested, (message) => new LakeStorageError2(`[SixbLake] ${message}`));
   if (existing.sequenceBy !== requested.sequenceBy) {
-    throw new LakeStorageError(`[SixbLake] Dataset '${requested.id}' sequenceBy is immutable. Create a new dataset and backfill to adopt or change source ordering.`);
+    throw new LakeStorageError2(`[SixbLake] Dataset '${requested.id}' sequenceBy is immutable. Create a new dataset and backfill to adopt or change source ordering.`);
   }
   assertPrimaryKeyUnchanged(existing, requested);
   const addedColumns = getAddedColumnsAfterValidatingExistingColumns(existing, requested);
@@ -44,23 +70,23 @@ function planDatasetDefinitionUpdate(existing, requested) {
     changed: schema.kind !== "none" || metadata.descriptionChanged || metadata.partitionByChanged
   };
 }
-function mergeStrictDatasetDefinition(options) {
-  assertDatasetDefinition(options.next, (message) => new LakeStorageError(`[SixbLake] ${message}`));
+function mergeStrictDatasetDefinition2(options) {
+  assertDatasetDefinition2(options.next, (message) => new LakeStorageError2(`[SixbLake] ${message}`));
   if (!options.existing) {
     return structuredClone(options.next);
   }
-  const plan = planDatasetDefinitionUpdate(options.existing, options.next);
+  const plan = planDatasetDefinitionUpdate2(options.existing, options.next);
   if (plan.schema.kind !== "none") {
-    throw new LakeStorageError(`[SixbLake] Dataset '${options.next.id}' cannot be redefined with an incompatible schema.`);
+    throw new LakeStorageError2(`[SixbLake] Dataset '${options.next.id}' cannot be redefined with an incompatible schema.`);
   }
   return structuredClone(plan.definition);
 }
-async function assertLakeDatasetDefinitionsCompatible(options) {
+async function assertLakeDatasetDefinitionsCompatible2(options) {
   await options.lakeStorage.assertDatasetDefinitionsCompatible(options.definitions);
 }
 function assertSameDataset(existing, requested) {
   if (existing.id !== requested.id) {
-    throw new LakeStorageError(`[SixbLake] Cannot update dataset '${existing.id}' with definition for '${requested.id}'.`);
+    throw new LakeStorageError2(`[SixbLake] Cannot update dataset '${existing.id}' with definition for '${requested.id}'.`);
   }
 }
 function assertPrimaryKeyUnchanged(existing, requested) {
@@ -68,7 +94,7 @@ function assertPrimaryKeyUnchanged(existing, requested) {
   const requestedPrimaryKey = requested.primaryKey;
   const unchanged = existingPrimaryKey === undefined || requestedPrimaryKey === undefined ? existingPrimaryKey === requestedPrimaryKey : areDefinitionValuesEqual(existingPrimaryKey, requestedPrimaryKey);
   if (!unchanged) {
-    throw new LakeStorageError(`[SixbLake] Dataset '${requested.id}' cannot be redefined with an incompatible primaryKey. Primary keys are immutable.`);
+    throw new LakeStorageError2(`[SixbLake] Dataset '${requested.id}' cannot be redefined with an incompatible primaryKey. Primary keys are immutable.`);
   }
 }
 function getAddedColumnsAfterValidatingExistingColumns(existing, requested) {
@@ -129,7 +155,7 @@ function assertCompatibleMetadataField(datasetId, field, existing, requested) {
   if (existing === undefined || requested === undefined || areDefinitionValuesEqual(existing, requested)) {
     return;
   }
-  throw new LakeStorageError(`[SixbLake] Dataset '${datasetId}' cannot be redefined with an incompatible ${field}.`);
+  throw new LakeStorageError2(`[SixbLake] Dataset '${datasetId}' cannot be redefined with an incompatible ${field}.`);
 }
 function areStringArraysEqual(left, right) {
   if (left === undefined || right === undefined) {
@@ -150,23 +176,24 @@ function cloneColumns(columns) {
   return columns.map((column) => ({ ...column }));
 }
 function throwUnsupportedSchemaUpdate(datasetId, detail) {
-  throw new LakeStorageError(`[SixbLake] Dataset '${datasetId}' cannot apply schema update because ${detail}. ${SCHEMA_UPDATE_V1_POLICY}`);
+  throw new LakeStorageError2(`[SixbLake] Dataset '${datasetId}' cannot apply schema update because ${detail}. ${SCHEMA_UPDATE_V1_POLICY}`);
 }
 // src/lake-storage/in-memory.ts
 import { randomUUID } from "crypto";
+import { isDeepStrictEqual } from "util";
 
 // src/lake-storage/merge.ts
-async function retryDatasetMergeCommit(merge, commit, run) {
+async function retryDatasetMergeCommit2(merge, commit, run) {
   const attempts = commit?.retryOnConflict && merge.dataset.sequenceBy !== undefined && merge.expectedLatestVersionId === undefined ? 3 : 1;
   for (let attempt = 0;; attempt += 1) {
     commit?.signal?.throwIfAborted();
     try {
       return await run(attempt > 0);
     } catch (error) {
-      if (!(error instanceof LakeConcurrencyError) || attempts === 1)
+      if (!(error instanceof LakeConcurrencyError2) || attempts === 1)
         throw error;
       if (attempt + 1 === attempts) {
-        throw new LakeConcurrencyError(`[SixbLake] Dataset '${merge.dataset.id}' merge exhausted ${attempts} concurrency attempts. No changes from this operation were committed.`, { cause: error });
+        throw new LakeConcurrencyError2(`[SixbLake] Dataset '${merge.dataset.id}' merge exhausted ${attempts} concurrency attempts. No changes from this operation were committed.`, { cause: error });
       }
     }
   }
@@ -174,15 +201,15 @@ async function retryDatasetMergeCommit(merge, commit, run) {
 
 // src/lake-storage/source-ordering.ts
 import { createHash } from "crypto";
-function datasetSequenceChange(dataset, change) {
+function datasetSequenceChange2(dataset, change) {
   const value = change.kind === "upsert" ? change.row[dataset.sequenceBy ?? ""] : change.sequence;
   return {
-    key: encodeDatasetPrimaryKey(dataset, change.kind === "upsert" ? change.row : change.key),
+    key: encodeDatasetPrimaryKey2(dataset, change.kind === "upsert" ? change.row : change.key),
     sequence: datasetSequenceValue(dataset, value).toString(),
     content: change.kind === "delete" ? null : rowDigest(dataset, change.row)
   };
 }
-function reconcileDatasetSequences(dataset, previous, changes) {
+function reconcileDatasetSequences2(dataset, previous, changes) {
   const states = new Map(previous);
   const accepted = new Map;
   for (const [index, change] of changes.entries()) {
@@ -193,7 +220,7 @@ function reconcileDatasetSequences(dataset, previous, changes) {
         continue;
       if (difference === 0n) {
         if (current.content !== change.content) {
-          throw new LakeStorageError(`[SixbLake] Dataset '${dataset.id}' has conflicting content at source sequence '${change.sequence}' for key ${change.key}.`);
+          throw new LakeStorageError2(`[SixbLake] Dataset '${dataset.id}' has conflicting content at source sequence '${change.sequence}' for key ${change.key}.`);
         }
         continue;
       }
@@ -220,22 +247,22 @@ function rowDigest(dataset, row) {
         content[column.name] = new Date(value).toISOString().slice(0, 10);
         break;
       case "decimal":
-        content[column.name] = normalizeDecimalValue(value);
+        content[column.name] = normalizeDecimalValue2(value);
         break;
       default:
         content[column.name] = value;
     }
   }
-  return createHash("sha256").update(stableJsonStringify(JSON.parse(JSON.stringify(content)))).digest("hex");
+  return createHash("sha256").update(stableJsonStringify2(JSON.parse(JSON.stringify(content)))).digest("hex");
 }
-function assertUnsequencedDatasetWrite(dataset) {
+function assertUnsequencedDatasetWrite2(dataset) {
   if (dataset.sequenceBy !== undefined) {
-    throw new LakeStorageError(`[SixbLake] Dataset '${dataset.id}' declares sequenceBy; use beginMerge with source-ordered changes.`);
+    throw new LakeStorageError2(`[SixbLake] Dataset '${dataset.id}' declares sequenceBy; use beginMerge with source-ordered changes.`);
   }
 }
 
 // src/lake-storage/version-inputs.ts
-function hasDatasetInputChanges(previous, next) {
+function hasDatasetInputChanges2(previous, next) {
   if (next === undefined)
     return false;
   const keys = (refs) => new Set(refs.map((ref) => JSON.stringify([ref.datasetId, ref.versionId])));
@@ -280,7 +307,7 @@ function sameRowContent(left, right) {
 }
 function assertDatasetId(datasetId) {
   if (datasetId.trim().length === 0) {
-    throw new LakeStorageError("[LakeStorage] Dataset id must not be empty");
+    throw new LakeStorageError2("[LakeStorage] Dataset id must not be empty");
   }
 }
 function errorMessage(error) {
@@ -302,14 +329,14 @@ class InMemoryLakeWriteSession {
     const stagedRows = [];
     const stagedPrimaryKeys = new Set;
     for await (const row of rows) {
-      const validationError = getDatasetRowValidationError(row, this.input.dataset);
+      const validationError = getDatasetRowValidationError2(row, this.input.dataset);
       if (validationError) {
-        throw new LakeStorageError(`[LakeStorage] ${validationError}`);
+        throw new LakeStorageError2(`[LakeStorage] ${validationError}`);
       }
-      if (getDatasetPrimaryKeyColumns(this.input.dataset) !== null) {
-        const primaryKey = encodeDatasetPrimaryKey(this.input.dataset, row);
+      if (getDatasetPrimaryKeyColumns2(this.input.dataset) !== null) {
+        const primaryKey = encodeDatasetPrimaryKey2(this.input.dataset, row);
         if (this.primaryKeys.has(primaryKey) || stagedPrimaryKeys.has(primaryKey)) {
-          throw new LakeStorageError(`[LakeStorage] Dataset '${this.input.dataset.id}' write contains duplicate primary key ${primaryKey}.`);
+          throw new LakeStorageError2(`[LakeStorage] Dataset '${this.input.dataset.id}' write contains duplicate primary key ${primaryKey}.`);
         }
         stagedPrimaryKeys.add(primaryKey);
       }
@@ -335,7 +362,7 @@ class InMemoryLakeWriteSession {
   }
   assertOpen() {
     if (this.closed) {
-      throw new LakeStorageError("[LakeStorage] Write session is already closed");
+      throw new LakeStorageError2("[LakeStorage] Write session is already closed");
     }
   }
 }
@@ -355,18 +382,18 @@ class InMemoryLakeMergeSession {
     this.assertOpen();
     const stagedChanges = [];
     for await (const change of changes) {
-      const validationError = getDatasetMergeChangeValidationError(change, this.input.dataset);
+      const validationError = getDatasetMergeChangeValidationError2(change, this.input.dataset);
       if (validationError) {
-        throw new LakeStorageError(`[LakeStorage] ${validationError}`);
+        throw new LakeStorageError2(`[LakeStorage] ${validationError}`);
       }
-      stagedChanges.push(cloneDatasetMergeChange(change));
+      stagedChanges.push(cloneDatasetMergeChange2(change));
     }
     this.changes.push(...stagedChanges);
   }
   async commit(input) {
     this.assertOpen();
     this.closed = true;
-    return retryDatasetMergeCommit(this.input, input, async (rebase) => this.storage.commitMerge({
+    return retryDatasetMergeCommit2(this.input, input, async (rebase) => this.storage.commitMerge({
       merge: this.input,
       baseVersionId: rebase ? (await this.storage.getLatestVersion(this.input.dataset.id))?.versionId ?? null : this.baseVersionId,
       changes: this.changes,
@@ -379,12 +406,12 @@ class InMemoryLakeMergeSession {
   }
   assertOpen() {
     if (this.closed) {
-      throw new LakeStorageError("[LakeStorage] Merge session is already closed");
+      throw new LakeStorageError2("[LakeStorage] Merge session is already closed");
     }
   }
 }
 
-class InMemoryLakeStorage {
+class InMemoryLakeStorage2 {
   datasets = new Map;
   versionsByDataset = new Map;
   rowsByVersionId = new Map;
@@ -394,7 +421,7 @@ class InMemoryLakeStorage {
   async createDataset(definition) {
     assertDatasetId(definition.id);
     const existing = this.datasets.get(definition.id);
-    const stored = mergeStrictDatasetDefinition({
+    const stored = mergeStrictDatasetDefinition2({
       existing,
       next: definition
     });
@@ -410,7 +437,7 @@ class InMemoryLakeStorage {
         if (!existing) {
           continue;
         }
-        mergeStrictDatasetDefinition({
+        mergeStrictDatasetDefinition2({
           existing,
           next: definition
         });
@@ -421,7 +448,7 @@ class InMemoryLakeStorage {
     if (failures.length > 0) {
       const details = failures.join(`
 `);
-      throw new LakeStorageError(`[SixbLake] Lake dataset definition check failed for ${failures.length} dataset(s).
+      throw new LakeStorageError2(`[SixbLake] Lake dataset definition check failed for ${failures.length} dataset(s).
 ${details}`);
     }
   }
@@ -458,9 +485,9 @@ ${details}`);
   async beginWrite(input) {
     const definition = await this.getDataset(input.dataset.id);
     if (!definition) {
-      throw new LakeStorageError(`[LakeStorage] Unknown dataset '${input.dataset.id}'`);
+      throw new LakeStorageError2(`[LakeStorage] Unknown dataset '${input.dataset.id}'`);
     }
-    assertUnsequencedDatasetWrite(definition);
+    assertUnsequencedDatasetWrite2(definition);
     return new InMemoryLakeWriteSession(this, {
       ...input,
       dataset: definition,
@@ -470,14 +497,14 @@ ${details}`);
   async beginMerge(input) {
     const definition = await this.getDataset(input.dataset.id);
     if (!definition) {
-      throw new LakeStorageError(`[LakeStorage] Unknown dataset '${input.dataset.id}'`);
+      throw new LakeStorageError2(`[LakeStorage] Unknown dataset '${input.dataset.id}'`);
     }
-    if (getDatasetPrimaryKeyColumns(definition) === null) {
-      throw new LakeStorageError(`[LakeStorage] Dataset '${definition.id}' must define a primaryKey before it can be merged.`);
+    if (getDatasetPrimaryKeyColumns2(definition) === null) {
+      throw new LakeStorageError2(`[LakeStorage] Dataset '${definition.id}' must define a primaryKey before it can be merged.`);
     }
     const latestVersion = await this.getLatestVersion(definition.id);
     if (input.expectedLatestVersionId !== undefined && latestVersion?.versionId !== input.expectedLatestVersionId) {
-      throw new LakeConcurrencyError(`[LakeStorage] Optimistic merge start failed for dataset '${definition.id}': expected latest version '${input.expectedLatestVersionId}', found '${latestVersion?.versionId ?? "none"}'`);
+      throw new LakeConcurrencyError2(`[LakeStorage] Optimistic merge start failed for dataset '${definition.id}': expected latest version '${input.expectedLatestVersionId}', found '${latestVersion?.versionId ?? "none"}'`);
     }
     return new InMemoryLakeMergeSession(this, {
       ...input,
@@ -499,11 +526,11 @@ ${details}`);
   async* readRows(input) {
     const definition = this.datasets.get(input.datasetId);
     if (!definition) {
-      throw new LakeStorageError(`[LakeStorage] Unknown dataset '${input.datasetId}'`);
+      throw new LakeStorageError2(`[LakeStorage] Unknown dataset '${input.datasetId}'`);
     }
     const version = input.versionId === undefined ? await this.getLatestVersion(input.datasetId) : await this.getVersion(input.datasetId, input.versionId);
     if (!version) {
-      throw new LakeStorageError(`[LakeStorage] No committed version found for dataset '${input.datasetId}'`);
+      throw new LakeStorageError2(`[LakeStorage] No committed version found for dataset '${input.datasetId}'`);
     }
     const offset = Math.max(0, input.offset ?? 0);
     const limit = input.limit === undefined ? undefined : Math.max(0, input.limit);
@@ -512,6 +539,73 @@ ${details}`);
       yield selectColumns(row, input.columns);
     }
   }
+  async readChanges(input) {
+    input.signal?.throwIfAborted();
+    const before = await this.getVersion(input.datasetId, input.fromVersionId);
+    const after = await this.getVersion(input.datasetId, input.toVersionId);
+    if (!resolveDatasetChangeColumns2(input, before, after))
+      return null;
+    const previous = this.rowsByVersionId.get(input.fromVersionId);
+    const next = this.rowsByVersionId.get(input.toVersionId);
+    const index = (rows) => {
+      const result = new Map;
+      for (const row of rows) {
+        input.signal?.throwIfAborted();
+        const values = input.keyColumns.map((column) => row[column]);
+        if (values.some((value) => typeof value !== "string" || value.trim().length === 0))
+          return null;
+        const key = JSON.stringify(values);
+        if (result.has(key))
+          return null;
+        result.set(key, row);
+      }
+      return result;
+    };
+    const oldRows = index(previous);
+    const newRows = index(next);
+    if (!oldRows || !newRows)
+      return null;
+    let pending = [];
+    for (const [key, row] of oldRows) {
+      const newRow = newRows.get(key);
+      if (!newRow || input.columns.some((column) => !isDeepStrictEqual(row[column] ?? null, newRow[column] ?? null))) {
+        pending.push({
+          before: selectColumns(row, input.columns),
+          after: newRow ? selectColumns(newRow, input.columns) : null
+        });
+      }
+    }
+    for (const [key, row] of newRows) {
+      if (!oldRows.has(key))
+        pending.push({ before: null, after: selectColumns(row, input.columns) });
+    }
+    let closed = false;
+    const changeCount = pending.length;
+    return {
+      fromRowCount: previous.length,
+      toRowCount: next.length,
+      changeCount,
+      changes: async function* () {
+        if (closed)
+          throw new LakeStorageError2("[LakeStorage] Change reader is closed.");
+        try {
+          for (let i = 0;i < changeCount; i++) {
+            input.signal?.throwIfAborted();
+            if (closed)
+              throw new LakeStorageError2("[LakeStorage] Change reader is closed.");
+            yield structuredClone(pending[i]);
+          }
+        } finally {
+          closed = true;
+          pending = [];
+        }
+      }(),
+      async close() {
+        closed = true;
+        pending = [];
+      }
+    };
+  }
   async commitWrite(options) {
     return this.withDatasetCommitLock(options.write.dataset.id, () => this.commitWriteUnlocked(options));
   }
@@ -519,25 +613,25 @@ ${details}`);
     return this.withDatasetCommitLock(options.merge.dataset.id, async () => {
       const definition = this.datasets.get(options.merge.dataset.id);
       if (!definition) {
-        throw new LakeStorageError(`[LakeStorage] Unknown dataset '${options.merge.dataset.id}'`);
+        throw new LakeStorageError2(`[LakeStorage] Unknown dataset '${options.merge.dataset.id}'`);
       }
       const latestVersion = await this.getLatestVersion(options.merge.dataset.id);
       options.commit?.signal?.throwIfAborted();
       const actualVersionId = latestVersion?.versionId ?? null;
       if (actualVersionId !== options.baseVersionId) {
-        throw new LakeConcurrencyError(`[LakeStorage] Optimistic merge commit failed for dataset '${options.merge.dataset.id}': expected latest version '${options.baseVersionId ?? "none"}', found '${actualVersionId ?? "none"}'`);
+        throw new LakeConcurrencyError2(`[LakeStorage] Optimistic merge commit failed for dataset '${options.merge.dataset.id}': expected latest version '${options.baseVersionId ?? "none"}', found '${actualVersionId ?? "none"}'`);
       }
       const previousRows = this.rowsByVersionId.get(latestVersion?.versionId ?? "") ?? [];
       const previousByKey = this.rowsByPrimaryKey(previousRows, definition);
       const finalChanges = new Map;
-      const ordered = definition.sequenceBy === undefined ? undefined : reconcileDatasetSequences(definition, this.sequencesByVersionId.get(actualVersionId ?? "") ?? new Map, options.changes.map((change) => datasetSequenceChange(definition, change)));
+      const ordered = definition.sequenceBy === undefined ? undefined : reconcileDatasetSequences2(definition, this.sequencesByVersionId.get(actualVersionId ?? "") ?? new Map, options.changes.map((change) => datasetSequenceChange2(definition, change)));
       if (ordered) {
         for (const [key, index] of ordered.accepted)
           finalChanges.set(key, options.changes[index]);
       } else {
         for (const change of options.changes) {
           const value = change.kind === "upsert" ? change.row : change.key;
-          finalChanges.set(encodeDatasetPrimaryKey(definition, value), change);
+          finalChanges.set(encodeDatasetPrimaryKey2(definition, value), change);
         }
       }
       const nextByKey = new Map(previousByKey);
@@ -583,19 +677,19 @@ ${details}`);
   async commitWriteUnlocked(options) {
     const definition = this.datasets.get(options.write.dataset.id);
     if (!definition) {
-      throw new LakeStorageError(`[LakeStorage] Unknown dataset '${options.write.dataset.id}'`);
+      throw new LakeStorageError2(`[LakeStorage] Unknown dataset '${options.write.dataset.id}'`);
     }
     const mode = options.write.mode ?? "snapshot";
-    assertUnsequencedDatasetWrite(definition);
+    assertUnsequencedDatasetWrite2(definition);
     const latestVersion = await this.getLatestVersion(options.write.dataset.id);
     if (options.commit?.expectedLatestVersionId !== undefined) {
       const actual = latestVersion?.versionId ?? null;
       if (actual !== options.commit.expectedLatestVersionId) {
-        throw new LakeConcurrencyError(`[LakeStorage] Optimistic commit failed for dataset '${options.write.dataset.id}': expected latest version '${options.commit.expectedLatestVersionId ?? "none"}', found '${actual ?? "none"}'`);
+        throw new LakeConcurrencyError2(`[LakeStorage] Optimistic commit failed for dataset '${options.write.dataset.id}': expected latest version '${options.commit.expectedLatestVersionId ?? "none"}', found '${actual ?? "none"}'`);
       }
     }
     this.assertKeyedWriteIsUnique(mode, options.rows, latestVersion, definition);
-    if (latestVersion && !hasDatasetInputChanges(latestVersion.inputs, options.write.inputs) && this.isUnchangedWrite(mode, latestVersion, options.rows, definition.schema)) {
+    if (latestVersion && !hasDatasetInputChanges2(latestVersion.inputs, options.write.inputs) && this.isUnchangedWrite(mode, latestVersion, options.rows, definition.schema)) {
       return { ...latestVersion, outcome: "unchanged" };
     }
     const versionId = `ver_${randomUUID()}`;
@@ -629,7 +723,7 @@ ${details}`);
     return sameRowContent(rows.map((row) => rowContentKey(row, schema)), previousRows.map((row) => rowContentKey(row, schema)));
   }
   assertKeyedWriteIsUnique(mode, rows, latestVersion, definition) {
-    if (getDatasetPrimaryKeyColumns(definition) === null) {
+    if (getDatasetPrimaryKeyColumns2(definition) === null) {
       return;
     }
     const stagedByKey = this.rowsByPrimaryKey(rows, definition);
@@ -640,16 +734,16 @@ ${details}`);
     const previousByKey = this.rowsByPrimaryKey(previousRows, definition);
     for (const primaryKey of stagedByKey.keys()) {
       if (previousByKey.has(primaryKey)) {
-        throw new LakeStorageError(`[LakeStorage] Dataset '${definition.id}' append contains duplicate primary key ${primaryKey}.`);
+        throw new LakeStorageError2(`[LakeStorage] Dataset '${definition.id}' append contains duplicate primary key ${primaryKey}.`);
       }
     }
   }
   rowsByPrimaryKey(rows, definition) {
     const byKey = new Map;
     for (const row of rows) {
-      const primaryKey = encodeDatasetPrimaryKey(definition, row);
+      const primaryKey = encodeDatasetPrimaryKey2(definition, row);
       if (byKey.has(primaryKey)) {
-        throw new LakeStorageError(`[LakeStorage] Dataset '${definition.id}' contains duplicate primary key ${primaryKey}.`);
+        throw new LakeStorageError2(`[LakeStorage] Dataset '${definition.id}' contains duplicate primary key ${primaryKey}.`);
       }
       byKey.set(primaryKey, row);
     }
@@ -687,6 +781,6 @@ ${details}`);
     }
   }
 }
-export { planDatasetDefinitionUpdate, mergeStrictDatasetDefinition, assertLakeDatasetDefinitionsCompatible, retryDatasetMergeCommit, datasetSequenceChange, reconcileDatasetSequences, assertUnsequencedDatasetWrite, hasDatasetInputChanges, InMemoryLakeStorage };
+export { resolveDatasetChangeColumns2, planDatasetDefinitionUpdate2, mergeStrictDatasetDefinition2, assertLakeDatasetDefinitionsCompatible2, retryDatasetMergeCommit2, datasetSequenceChange2, reconcileDatasetSequences2, assertUnsequencedDatasetWrite2, hasDatasetInputChanges2, InMemoryLakeStorage2 };
 
-//# debugId=90B9C7F3AC8BEB1A64756E2164756E21
+//# debugId=8B7567B39BAB0B9A64756E2164756E21