@sixb/core 0.1.7 → 0.1.9

package/dist/{chunk-wjgm6jjt.js → chunk-qhcpj9wc.js}

@@ -1,20 +1,31 @@
 // @bun
 import {
-  getDatasetRowValidationError
-} from "./chunk-tn7xcs2n.js";
+  datasetSequenceValue,
+  assertDatasetDefinition2,
+  getDatasetRowValidationError2
+} from "./chunk-860dwwy0.js";
 import {
-  isPlainRecord
-} from "./chunk-n6jxh8sw.js";
-
-// src/lake-storage/errors.ts
-class LakeStorageError extends Error {
-  name = "LakeStorageError";
-}
-
+  LakeStorageError2,
+  LakeConcurrencyError2,
+  getDatasetPrimaryKeyColumns2,
+  encodeDatasetPrimaryKey2,
+  getDatasetMergeChangeValidationError2,
+  cloneDatasetMergeChange2
+} from "./chunk-9qsh3p5y.js";
+import {
+  normalizeDecimalValue2
+} from "./chunk-3bh94gbw.js";
+import {
+  stableJsonStringify2
+} from "./chunk-wy0qdqfm.js";
 // 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);
+  assertDatasetDefinition2(requested, (message) => new LakeStorageError2(`[SixbLake] ${message}`));
+  if (existing.sequenceBy !== requested.sequenceBy) {
+    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);
   assertAddedColumnsAreNullable(requested.id, addedColumns);
@@ -33,22 +44,23 @@ function planDatasetDefinitionUpdate(existing, requested) {
     changed: schema.kind !== "none" || metadata.descriptionChanged || metadata.partitionByChanged
   };
 }
-function mergeStrictDatasetDefinition(options) {
+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) {
@@ -56,7 +68,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) {
@@ -108,6 +120,7 @@ function mergeDatasetDefinition(existing, requested, addedColumns) {
     id: requested.id,
     schema: { columns },
     ...primaryKey !== undefined ? { primaryKey: structuredClone(primaryKey) } : {},
+    ...existing.sequenceBy !== undefined ? { sequenceBy: existing.sequenceBy } : {},
     ...partitionBy !== undefined ? { partitionBy: [...partitionBy] } : {},
     ...description !== undefined ? { description } : {}
   };
@@ -116,7 +129,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) {
@@ -137,90 +150,98 @@ 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";
 
-// src/lake-storage/merge-validation.ts
-function getDatasetPrimaryKeyColumns(dataset) {
-  if (dataset.primaryKey === undefined) {
-    return null;
-  }
-  return typeof dataset.primaryKey === "string" ? [dataset.primaryKey] : [...dataset.primaryKey];
-}
-function encodeDatasetPrimaryKey(dataset, value) {
-  const columns = getDatasetPrimaryKeyColumns(dataset);
-  if (columns === null) {
-    throw new LakeStorageError(`[SixbLake] Dataset '${dataset.id}' must define a primaryKey before rows can be keyed.`);
-  }
-  const values = columns.map((columnName) => {
-    const columnValue = value[columnName];
-    if (typeof columnValue !== "string") {
-      throw new LakeStorageError(`[SixbLake] Dataset '${dataset.id}' primary-key column '${columnName}' must be a string.`);
-    }
-    return columnValue;
-  });
-  return JSON.stringify(values);
-}
-function getDatasetMergeChangeValidationError(change, dataset) {
-  const primaryKeyColumns = getDatasetPrimaryKeyColumns(dataset);
-  if (primaryKeyColumns === null) {
-    return `Dataset '${dataset.id}' must define a primaryKey before it can be merged.`;
-  }
-  if (!isPlainRecord(change)) {
-    return `Dataset '${dataset.id}' merge changes must be plain objects.`;
-  }
-  if (change.kind === "upsert") {
-    const shapeError = getChangeShapeError(change, dataset, "row");
-    if (shapeError) {
-      return shapeError;
-    }
-    return getDatasetRowValidationError(change.row, dataset);
-  }
-  if (change.kind === "delete") {
-    const shapeError = getChangeShapeError(change, dataset, "key");
-    if (shapeError) {
-      return shapeError;
+// src/lake-storage/merge.ts
+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 LakeConcurrencyError2) || attempts === 1)
+        throw error;
+      if (attempt + 1 === attempts) {
+        throw new LakeConcurrencyError2(`[SixbLake] Dataset '${merge.dataset.id}' merge exhausted ${attempts} concurrency attempts. No changes from this operation were committed.`, { cause: error });
+      }
     }
-    return getDeleteKeyValidationError(change.key, dataset, primaryKeyColumns);
   }
-  return `Dataset '${dataset.id}' merge change kind must be 'upsert' or 'delete'.`;
 }
-function cloneDatasetMergeChange(change) {
-  return change.kind === "upsert" ? { kind: "upsert", row: structuredClone(change.row) } : { kind: "delete", key: structuredClone(change.key) };
+
+// src/lake-storage/source-ordering.ts
+import { createHash } from "crypto";
+function datasetSequenceChange2(dataset, change) {
+  const value = change.kind === "upsert" ? change.row[dataset.sequenceBy ?? ""] : change.sequence;
+  return {
+    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 getChangeShapeError(change, dataset, payloadField) {
-  const allowedFields = new Set(["kind", payloadField]);
-  for (const field of Object.keys(change)) {
-    if (!allowedFields.has(field)) {
-      return `Dataset '${dataset.id}' ${change.kind} change contains unknown field '${field}'.`;
+function reconcileDatasetSequences2(dataset, previous, changes) {
+  const states = new Map(previous);
+  const accepted = new Map;
+  for (const [index, change] of changes.entries()) {
+    const current = states.get(change.key);
+    if (current) {
+      const difference = BigInt(change.sequence) - BigInt(current.sequence);
+      if (difference < 0n)
+        continue;
+      if (difference === 0n) {
+        if (current.content !== change.content) {
+          throw new LakeStorageError2(`[SixbLake] Dataset '${dataset.id}' has conflicting content at source sequence '${change.sequence}' for key ${change.key}.`);
+        }
+        continue;
+      }
     }
+    states.set(change.key, { sequence: change.sequence, content: change.content });
+    accepted.set(change.key, index);
+  }
+  return { states, accepted };
+}
+function rowDigest(dataset, row) {
+  const content = Object.create(null);
+  for (const column of dataset.schema.columns) {
+    const value = row[column.name];
+    if (value == null)
+      continue;
+    switch (column.type) {
+      case "int64":
+        content[column.name] = BigInt(value).toString();
+        break;
+      case "timestamp":
+        content[column.name] = new Date(value).toISOString();
+        break;
+      case "date":
+        content[column.name] = new Date(value).toISOString().slice(0, 10);
+        break;
+      case "decimal":
+        content[column.name] = normalizeDecimalValue2(value);
+        break;
+      default:
+        content[column.name] = value;
+    }
+  }
+  return createHash("sha256").update(stableJsonStringify2(JSON.parse(JSON.stringify(content)))).digest("hex");
+}
+function assertUnsequencedDatasetWrite2(dataset) {
+  if (dataset.sequenceBy !== undefined) {
+    throw new LakeStorageError2(`[SixbLake] Dataset '${dataset.id}' declares sequenceBy; use beginMerge with source-ordered changes.`);
   }
-  if (!Object.hasOwn(change, payloadField)) {
-    return `Dataset '${dataset.id}' ${change.kind} change is missing '${payloadField}'.`;
-  }
-  return null;
 }
-function getDeleteKeyValidationError(key, dataset, primaryKeyColumns) {
-  if (!isPlainRecord(key)) {
-    return `Dataset '${dataset.id}' delete keys must be plain objects.`;
-  }
-  const expectedColumns = new Set(primaryKeyColumns);
-  for (const columnName of Object.keys(key)) {
-    if (!expectedColumns.has(columnName)) {
-      return `Dataset '${dataset.id}' delete key contains unknown column '${columnName}'.`;
-    }
-  }
-  for (const columnName of primaryKeyColumns) {
-    if (!Object.hasOwn(key, columnName)) {
-      return `Dataset '${dataset.id}' delete key is missing primary-key column '${columnName}'.`;
-    }
-    if (typeof key[columnName] !== "string") {
-      return `Dataset '${dataset.id}' delete key column '${columnName}' must be a string.`;
-    }
-  }
-  return null;
+
+// src/lake-storage/version-inputs.ts
+function hasDatasetInputChanges2(previous, next) {
+  if (next === undefined)
+    return false;
+  const keys = (refs) => new Set(refs.map((ref) => JSON.stringify([ref.datasetId, ref.versionId])));
+  const before = keys(previous ?? []);
+  const after = keys(next);
+  return before.size !== after.size || [...after].some((key) => !before.has(key));
 }
 
 // src/lake-storage/in-memory.ts
@@ -259,7 +280,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) {
@@ -281,14 +302,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);
       }
@@ -314,7 +335,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");
     }
   }
 }
@@ -334,23 +355,23 @@ 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 this.storage.commitMerge({
+    return retryDatasetMergeCommit2(this.input, input, async (rebase) => this.storage.commitMerge({
       merge: this.input,
-      baseVersionId: this.baseVersionId,
+      baseVersionId: rebase ? (await this.storage.getLatestVersion(this.input.dataset.id))?.versionId ?? null : this.baseVersionId,
       changes: this.changes,
       commit: input
-    });
+    }));
   }
   async abort() {
     this.closed = true;
@@ -358,21 +379,22 @@ 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;
+  sequencesByVersionId = new Map;
   latestVersionIdByDataset = new Map;
   commitLocks = new Map;
   async createDataset(definition) {
     assertDatasetId(definition.id);
     const existing = this.datasets.get(definition.id);
-    const stored = mergeStrictDatasetDefinition({
+    const stored = mergeStrictDatasetDefinition2({
       existing,
       next: definition
     });
@@ -388,7 +410,7 @@ class InMemoryLakeStorage {
         if (!existing) {
           continue;
         }
-        mergeStrictDatasetDefinition({
+        mergeStrictDatasetDefinition2({
           existing,
           next: definition
         });
@@ -399,7 +421,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}`);
     }
   }
@@ -436,8 +458,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}'`);
     }
+    assertUnsequencedDatasetWrite2(definition);
     return new InMemoryLakeWriteSession(this, {
       ...input,
       dataset: definition,
@@ -447,14 +470,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 LakeStorageError(`[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,
@@ -476,11 +499,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);
@@ -496,19 +519,26 @@ ${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 LakeStorageError(`[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;
-      for (const change of options.changes) {
-        const value = change.kind === "upsert" ? change.row : change.key;
-        finalChanges.set(encodeDatasetPrimaryKey(definition, value), 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(encodeDatasetPrimaryKey2(definition, value), change);
+        }
       }
       const nextByKey = new Map(previousByKey);
       for (const [primaryKey, change] of finalChanges) {
@@ -518,7 +548,8 @@ ${details}`);
           nextByKey.delete(primaryKey);
         }
       }
-      if (this.sameKeyedRowContent(previousByKey, nextByKey, definition.schema)) {
+      const createInitialVersion = options.commit?.createInitialVersion && latestVersion === null;
+      if (!createInitialVersion && (ordered ? ordered.accepted.size === 0 : this.sameKeyedRowContent(previousByKey, nextByKey, definition.schema))) {
         return {
           outcome: "unchanged",
           version: latestVersion ? cloneDatasetVersion(latestVersion) : null
@@ -544,24 +575,27 @@ ${details}`);
       this.versionsByDataset.set(options.merge.dataset.id, versions);
       this.rowsByVersionId.set(versionId, visibleRows.map((row) => cloneRow(row)));
       this.latestVersionIdByDataset.set(options.merge.dataset.id, versionId);
+      if (ordered)
+        this.sequencesByVersionId.set(versionId, ordered.states);
       return { outcome: "created", version: cloneDatasetVersion(version) };
     });
   }
   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";
+    assertUnsequencedDatasetWrite2(definition);
     const latestVersion = await this.getLatestVersion(options.write.dataset.id);
     if (options.commit?.expectedLatestVersionId !== undefined) {
-      const actual = latestVersion?.versionId;
+      const actual = latestVersion?.versionId ?? null;
       if (actual !== options.commit.expectedLatestVersionId) {
-        throw new LakeStorageError(`[LakeStorage] Optimistic commit failed for dataset '${options.write.dataset.id}': expected latest version '${options.commit.expectedLatestVersionId}', 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 && 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()}`;
@@ -595,7 +629,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);
@@ -606,16 +640,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);
     }
@@ -653,6 +687,6 @@ ${details}`);
     }
   }
 }
-export { LakeStorageError, planDatasetDefinitionUpdate, mergeStrictDatasetDefinition, assertLakeDatasetDefinitionsCompatible, getDatasetPrimaryKeyColumns, encodeDatasetPrimaryKey, getDatasetMergeChangeValidationError, cloneDatasetMergeChange, InMemoryLakeStorage };
+export { planDatasetDefinitionUpdate2, mergeStrictDatasetDefinition2, assertLakeDatasetDefinitionsCompatible2, retryDatasetMergeCommit2, datasetSequenceChange2, reconcileDatasetSequences2, assertUnsequencedDatasetWrite2, hasDatasetInputChanges2, InMemoryLakeStorage2 };
 
-//# debugId=E501E7BE29735B3664756E2164756E21
+//# debugId=27F2E83DF00F5AF164756E2164756E21