@sixb/ducklake 0.1.6 → 0.1.8

package/dist/index.js

@@ -158,8 +158,20 @@ function buildSetPostgresPoolSql(options) {
   return postgresPoolParameters(options.postgresPool).map(({ name, value }) => `SET pg_pool_${name} = ${value}`);
 }
 function duckLakeMetadataTableName(options, tableName) {
-  const schemaName = options.catalog.type === "postgres" ? options.catalog.metadataSchema ?? "main" : "main";
-  return `${quoteIdentifier(duckLakeMetadataCatalog(options))}.${quoteIdentifier(schemaName)}.${quoteIdentifier(tableName)}`;
+  return `${quoteIdentifier(duckLakeMetadataCatalog(options))}.${quoteIdentifier(duckLakeMetadataSchema(options))}.${quoteIdentifier(tableName)}`;
+}
+function buildDuckLakeMetadataQuery(options, build) {
+  if (options.catalog.type !== "postgres") {
+    return build((tableName) => duckLakeMetadataTableName(options, tableName));
+  }
+  const schema = options.catalog.metadataSchema;
+  const sql = build((tableName) => schema === undefined ? quoteIdentifier(tableName) : `${quoteIdentifier(schema)}.${quoteIdentifier(tableName)}`);
+  return `SELECT * FROM postgres_query(${quoteSqlString(duckLakeMetadataCatalog(options))}, ${quoteSqlString(sql)})`;
+}
+function duckLakeMetadataSchema(options) {
+  if (options.catalog.type !== "postgres")
+    return "main";
+  return options.catalog.metadataSchema ?? "public";
 }
 function quoteIdentifier(identifier) {
   if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(identifier)) {
@@ -771,7 +783,7 @@ function rowImage(row, prefix, columns) {
 }
 
 // src/internal/ducklake-connection-manager.ts
-import { LakeStorageError as LakeStorageError10 } from "@sixb/core/lake-storage";
+import { LakeStorageError as LakeStorageError11 } from "@sixb/core/lake-storage";
 
 // src/internal/catalog-key.ts
 import { resolve } from "path";
@@ -791,9 +803,14 @@ function localCatalogCoordinationKey(options) {
 }
 
 // src/internal/duckdb-runtime.ts
+import { mkdir, mkdtemp, rm } from "fs/promises";
+import { join, resolve as resolve2 } from "path";
 import {
   DuckDBInstance
 } from "@duckdb/node-api";
+import { LakeStorageError as LakeStorageError10 } from "@sixb/core/lake-storage";
+
+// src/internal/duckdb-reader.ts
 import { LakeStorageError as LakeStorageError9 } from "@sixb/core/lake-storage";
 
 // src/internal/duckdb-value-converter.ts
@@ -816,16 +833,147 @@ var sixbDuckDbValueConverter = (value, type, converter) => {
   return JSDuckDBValueConverter(value, type, converter);
 };
 
+// src/internal/duckdb-reader.ts
+class NodeDuckDbReader {
+  connection;
+  options;
+  resultPromise;
+  pending;
+  closePromise;
+  finished = false;
+  consumed = false;
+  onAbort = () => {
+    this.close().catch(() => {});
+  };
+  constructor(connection, options) {
+    this.connection = connection;
+    this.options = options;
+  }
+  async start(sql) {
+    this.options.signal?.throwIfAborted();
+    this.options.signal?.addEventListener("abort", this.onAbort, { once: true });
+    await this.track(this.connection.run("SET preserve_insertion_order = true"));
+    this.assertOpen();
+    const prepared = await this.track(this.connection.prepare(sql));
+    try {
+      this.assertOpen();
+      this.resultPromise = this.track(prepared.startStream().getResult()).finally(() => {
+        prepared.destroySync();
+      });
+      this.resultPromise.catch(() => {});
+    } catch (error) {
+      prepared.destroySync();
+      throw error;
+    }
+  }
+  async* rows() {
+    if (this.consumed)
+      throw new LakeStorageError9("[SixbDuckLake] Reader can only be consumed once.");
+    this.consumed = true;
+    try {
+      this.assertOpen();
+      const result = await this.resultPromise;
+      this.assertOpen();
+      const batches = result.yieldConvertedRowObjects(sixbDuckDbValueConverter)[Symbol.asyncIterator]();
+      while (true) {
+        this.assertOpen();
+        const batch = await this.track(batches.next());
+        this.assertOpen();
+        if (batch.done) {
+          this.finished = true;
+          return;
+        }
+        for (const row of batch.value) {
+          this.assertOpen();
+          yield row;
+        }
+      }
+    } finally {
+      await this.close();
+    }
+  }
+  close() {
+    if (!this.closePromise) {
+      this.options.signal?.removeEventListener("abort", this.onAbort);
+      if (this.pending)
+        this.connection.interrupt();
+      this.closePromise = this.finish();
+    }
+    return this.closePromise;
+  }
+  async finish() {
+    try {
+      await this.pending?.catch(() => {});
+      if (!this.finished) {
+        await this.connection.run("SELECT 1");
+      }
+    } finally {
+      this.resultPromise = undefined;
+      try {
+        this.connection.closeSync();
+      } finally {
+        await this.options.onClose?.();
+      }
+    }
+  }
+  async track(operation) {
+    this.pending = operation;
+    try {
+      return await operation;
+    } catch (error) {
+      this.assertOpen();
+      throw error;
+    } finally {
+      if (this.pending === operation)
+        this.pending = undefined;
+    }
+  }
+  assertOpen() {
+    this.options.signal?.throwIfAborted();
+    if (this.closePromise)
+      throw new LakeStorageError9("[SixbDuckLake] Reader is closed.");
+  }
+}
+
 // src/internal/duckdb-runtime.ts
 class NodeDuckDbRuntime {
   instance;
   connection;
+  temporaryDirectory;
   closing = false;
   closed = false;
   operations = Promise.resolve();
-  constructor(instance, connection) {
+  readers = new Set;
+  closePromise;
+  constructor(instance, connection, temporaryDirectory) {
     this.instance = instance;
     this.connection = connection;
+    this.temporaryDirectory = temporaryDirectory;
+  }
+  async openReader(sql, options = {}) {
+    return this.enqueue(async () => {
+      this.assertAcceptingOperations();
+      const connection = await this.instance.connect();
+      if (this.closing) {
+        connection.closeSync();
+        this.assertAcceptingOperations();
+      }
+      const reader = new NodeDuckDbReader(connection, {
+        ...options,
+        onClose: async () => {
+          this.readers.delete(reader);
+          await options.onClose?.();
+        }
+      });
+      this.readers.add(reader);
+      try {
+        await reader.start(sql);
+        return reader;
+      } catch (error) {
+        await reader.close();
+        throw error;
+      }
+    });
   }
   async run(sql, values) {
     await this.enqueue(async () => {
@@ -845,28 +993,6 @@ class NodeDuckDbRuntime {
       return reader.convertRowObjects(sixbDuckDbValueConverter);
     });
   }
-  async* streamRows(sql, values) {
-    this.assertAcceptingOperations();
-    let releaseOperation;
-    const operationFinished = new Promise((resolve) => {
-      releaseOperation = resolve;
-    });
-    const waitForTurn = this.operations.then(() => {
-      this.assertNotClosed();
-    });
-    this.operations = waitForTurn.then(() => operationFinished).then(() => {}, () => {});
-    try {
-      await waitForTurn;
-      const result = await this.connection.stream(sql, values === undefined ? undefined : [...values]);
-      for await (const batch of result.yieldConvertedRowObjects(sixbDuckDbValueConverter)) {
-        for (const row of batch) {
-          yield row;
-        }
-      }
-    } finally {
-      releaseOperation?.();
-    }
-  }
   async withAppender(tableName, useAppender) {
     return this.enqueue(async () => {
       const appender = await this.connection.createAppender(tableName);
@@ -882,15 +1008,28 @@ class NodeDuckDbRuntime {
       return useRuntime(new NodeDuckDbExclusiveRuntime(this.connection));
     });
   }
-  async close() {
-    if (this.closed) {
-      return;
-    }
+  close() {
+    this.closePromise ??= this.finish();
+    return this.closePromise;
+  }
+  async stopReaders() {
+    const results = await Promise.allSettled([...this.readers].map((reader) => reader.close()));
+    const failed = results.find((result) => result.status === "rejected");
+    if (failed?.status === "rejected")
+      throw failed.reason;
+  }
+  async finish() {
     this.closing = true;
+    const results = await Promise.allSettled([...this.readers].map((reader) => reader.close()));
     await this.operations.catch(() => {});
     this.closed = true;
     this.connection.closeSync();
     this.instance.closeSync();
+    if (this.temporaryDirectory)
+      await rm(this.temporaryDirectory, { recursive: true, force: true });
+    const failed = results.find((result) => result.status === "rejected");
+    if (failed?.status === "rejected")
+      throw failed.reason;
   }
   enqueue(operation) {
     this.assertAcceptingOperations();
@@ -903,12 +1042,12 @@ class NodeDuckDbRuntime {
   }
   assertAcceptingOperations() {
     if (this.closing || this.closed) {
-      throw new LakeStorageError9("[SixbDuckLake] DuckDB runtime is closed.");
+      throw new LakeStorageError10("[SixbDuckLake] DuckDB runtime is closed.");
     }
   }
   assertNotClosed() {
     if (this.closed) {
-      throw new LakeStorageError9("[SixbDuckLake] DuckDB runtime is closed.");
+      throw new LakeStorageError10("[SixbDuckLake] DuckDB runtime is closed.");
     }
   }
 }
@@ -968,8 +1107,27 @@ class NodeDuckDbAppenderAdapter {
   }
 }
 async function createDuckDbRuntime(options = {}) {
-  const instance = await DuckDBInstance.create(options.path ?? ":memory:", options.config ?? {});
-  return new NodeDuckDbRuntime(instance, await instance.connect());
+  const path = options.path ?? ":memory:";
+  const base = options.config?.temp_directory ?? (path === ":memory:" ? ".tmp" : `${path}.tmp`);
+  let temporaryDirectory;
+  if (base !== "") {
+    const directory = resolve2(base);
+    await mkdir(directory, { recursive: true });
+    temporaryDirectory = await mkdtemp(join(directory, "sixb-"));
+  }
+  let instance;
+  try {
+    instance = await DuckDBInstance.create(path, {
+      ...options.config,
+      ...temporaryDirectory ? { temp_directory: temporaryDirectory } : {}
+    });
+    return new NodeDuckDbRuntime(instance, await instance.connect(), temporaryDirectory);
+  } catch (error) {
+    instance?.closeSync();
+    if (temporaryDirectory)
+      await rm(temporaryDirectory, { recursive: true, force: true });
+    throw error;
+  }
 }
 async function installDuckLakeExtensions(runtime, options) {
   await runtime.run("INSTALL ducklake");
@@ -1002,6 +1160,62 @@ async function setupDuckLake(runtime, options, setupOptions = {}) {
   }
 }
 
+// src/internal/ducklake-read-gate.ts
+class DuckLakeReadGate {
+  active = 0;
+  maintenance = false;
+  waiters = new Set;
+  async acquire(signal) {
+    while (true) {
+      signal.throwIfAborted();
+      if (!this.maintenance) {
+        this.active++;
+        let released = false;
+        return () => {
+          if (released)
+            return;
+          released = true;
+          this.active--;
+          this.wake();
+        };
+      }
+      await this.wait(signal);
+    }
+  }
+  async withMaintenance(signal, run) {
+    while (this.active > 0 || this.maintenance)
+      await this.wait(signal);
+    signal.throwIfAborted();
+    this.maintenance = true;
+    try {
+      return await run();
+    } finally {
+      this.maintenance = false;
+      this.wake();
+    }
+  }
+  wait(signal) {
+    return new Promise((resolve, reject) => {
+      const wake = () => {
+        signal.removeEventListener("abort", abort);
+        this.waiters.delete(wake);
+        resolve();
+      };
+      const abort = () => {
+        this.waiters.delete(wake);
+        reject(signal.reason);
+      };
+      signal.throwIfAborted();
+      this.waiters.add(wake);
+      signal.addEventListener("abort", abort, { once: true });
+    });
+  }
+  wake() {
+    for (const wake of this.waiters)
+      wake();
+  }
+}
+
 // src/internal/ducklake-connection-manager.ts
 class DuckLakeConnectionManager {
   options;
@@ -1009,18 +1223,77 @@ class DuckLakeConnectionManager {
   installExtensionsPromise;
   attachPromise;
   refreshPromise;
-  localAttachmentLock = Promise.resolve();
+  attachmentLock = Promise.resolve();
   observedLocalCatalogGeneration;
   attached = false;
   closed = false;
+  closePromise;
   runtimePoisoned = false;
+  pinnedReaders = 0;
+  refreshRequested = false;
+  shutdown = new AbortController;
+  reads = new DuckLakeReadGate;
+  maxStreamingReads;
   constructor(options) {
     this.options = options;
     this.observedLocalCatalogGeneration = currentLocalCatalogGeneration(options);
+    this.maxStreamingReads = options.maxStreamingReads ?? 4;
+    if (!Number.isSafeInteger(this.maxStreamingReads) || this.maxStreamingReads < 1) {
+      throw new LakeStorageError11("[SixbDuckLake] maxStreamingReads must be a positive integer.");
+    }
+  }
+  async acquireRead(signal) {
+    this.assertOpen();
+    const combined = signal ? AbortSignal.any([signal, this.shutdown.signal]) : this.shutdown.signal;
+    return { signal: combined, release: await this.reads.acquire(combined) };
+  }
+  async nativeReaderLimit(runtime) {
+    if (this.options.catalog.type === "duckdb")
+      return this.maxStreamingReads;
+    if (this.options.catalog.type !== "postgres")
+      return 0;
+    const [setting] = await runtime.query("SELECT current_setting('pg_pool_max_connections') AS value");
+    const budget = Number(setting?.value);
+    return Number.isFinite(budget) ? Math.min(this.maxStreamingReads, Math.max(0, budget - 4)) : 0;
+  }
+  async openReader(runtime, sql, signal, releaseRead) {
+    const limit = await this.nativeReaderLimit(runtime);
+    signal.throwIfAborted();
+    if (this.pinnedReaders >= limit)
+      return null;
+    this.pinnedReaders++;
+    let starting = true;
+    let released = false;
+    const onClose = async () => {
+      if (released)
+        return;
+      released = true;
+      this.pinnedReaders--;
+      if (signal.aborted || this.closed || this.runtimePoisoned)
+        releaseRead();
+      if (starting || this.closed || this.runtimePoisoned)
+        return;
+      await this.withAttachmentLock(async () => {
+        if (this.pinnedReaders === 0 && this.refreshRequested)
+          await this.resetRuntimeUnlocked();
+        await this.detachDuckDbCatalogAfterLease();
+      });
+    };
+    try {
+      return await runtime.openReader(sql, { signal, onClose });
+    } catch (error) {
+      await onClose();
+      throw error;
+    } finally {
+      starting = false;
+    }
+  }
+  async withMaintenanceRuntime(run) {
+    return this.reads.withMaintenance(this.shutdown.signal, () => this.withExclusiveAttached(run));
   }
   assertOpen() {
     if (this.closed) {
-      throw new LakeStorageError10("[SixbDuckLake] DuckLakeStorage is closed.");
+      throw new LakeStorageError11("[SixbDuckLake] DuckLakeStorage is closed.");
     }
   }
   async runtime() {
@@ -1051,7 +1324,7 @@ class DuckLakeConnectionManager {
   }
   async acquireAttachedRuntime() {
     this.assertOpen();
-    const releaseLock = await this.acquireLocalAttachmentLock();
+    const releaseLock = await this.acquireAttachmentLock();
     let released = false;
     const release = async () => {
       if (released) {
@@ -1060,8 +1333,8 @@ class DuckLakeConnectionManager {
       released = true;
       try {
         if (this.runtimePoisoned) {
-          this.runtimePoisoned = false;
           await this.discardRuntimeUnlocked();
+          this.runtimePoisoned = false;
         } else {
           await this.detachDuckDbCatalogAfterLease();
         }
@@ -1110,7 +1383,7 @@ class DuckLakeConnectionManager {
     }
   }
   async resetRuntime() {
-    const releaseLock = await this.acquireLocalAttachmentLock();
+    const releaseLock = await this.acquireAttachmentLock();
     try {
       await this.resetRuntimeUnlocked();
     } finally {
@@ -1118,6 +1391,11 @@ class DuckLakeConnectionManager {
     }
   }
   async resetRuntimeUnlocked() {
+    if (this.pinnedReaders > 0) {
+      this.refreshRequested = true;
+      return;
+    }
+    this.refreshRequested = false;
     const runtimePromise = this.runtimePromise;
     if (runtimePromise === undefined) {
       return;
@@ -1158,7 +1436,7 @@ class DuckLakeConnectionManager {
     }
     if (this.refreshPromise === undefined) {
       let refreshPromise;
-      refreshPromise = this.withLocalAttachmentLock(() => this.refreshForExternalChangesUnlocked()).finally(() => {
+      refreshPromise = this.withAttachmentLock(() => this.refreshForExternalChangesUnlocked()).finally(() => {
         if (this.refreshPromise === refreshPromise) {
           this.refreshPromise = undefined;
         }
@@ -1178,8 +1456,10 @@ class DuckLakeConnectionManager {
       return;
     }
     try {
-      await runtime.run(`DETACH ${quoteIdentifier(duckLakeAlias(this.options))}`);
-      this.attached = false;
+      if (this.pinnedReaders === 0) {
+        await runtime.run(`DETACH ${quoteIdentifier(duckLakeAlias(this.options))}`);
+        this.attached = false;
+      }
     } catch {} finally {
       this.markLocalCatalogChanged();
     }
@@ -1195,11 +1475,13 @@ class DuckLakeConnectionManager {
   needsLocalCatalogRefresh() {
     return this.observedLocalCatalogGeneration !== currentLocalCatalogGeneration(this.options);
   }
-  async close() {
-    if (this.closed) {
-      return;
-    }
+  close() {
+    this.closePromise ??= this.finishClose();
+    return this.closePromise;
+  }
+  async finishClose() {
     this.closed = true;
+    this.shutdown.abort(new LakeStorageError11("[SixbDuckLake] DuckLakeStorage is closed."));
     const runtimePromise = this.runtimePromise;
     this.runtimePromise = undefined;
     await this.closeRuntimePromise(runtimePromise, {
@@ -1258,13 +1540,13 @@ class DuckLakeConnectionManager {
     ]);
   }
   async detachRuntime() {
-    await this.withLocalAttachmentLock(() => this.detachRuntimeUnlocked());
+    await this.withAttachmentLock(() => this.detachRuntimeUnlocked());
   }
   poisonRuntime() {
     this.runtimePoisoned = true;
   }
   async detachDuckDbCatalogAfterLease() {
-    if (this.options.catalog.type !== "duckdb" || !this.attached) {
+    if (this.options.catalog.type !== "duckdb" || !this.attached || this.pinnedReaders > 0) {
       return;
     }
     try {
@@ -1280,6 +1562,8 @@ class DuckLakeConnectionManager {
     await this.closeRuntimePromise(runtimePromise, { detach: false }).catch(() => {});
   }
   async detachRuntimeUnlocked() {
+    if (this.pinnedReaders > 0)
+      return;
     if (this.attachPromise !== undefined) {
       await this.attachPromise;
     }
@@ -1290,24 +1574,21 @@ class DuckLakeConnectionManager {
     await runtime.run(`DETACH ${quoteIdentifier(duckLakeAlias(this.options))}`);
     this.attached = false;
   }
-  async withLocalAttachmentLock(run) {
-    const releaseLock = await this.acquireLocalAttachmentLock();
+  async withAttachmentLock(run) {
+    const releaseLock = await this.acquireAttachmentLock();
     try {
       return await run();
     } finally {
       releaseLock();
     }
   }
-  async acquireLocalAttachmentLock() {
-    if (this.options.catalog.type === "postgres") {
-      return () => {};
-    }
-    const previous = this.localAttachmentLock.catch(() => {});
+  async acquireAttachmentLock() {
+    const previous = this.attachmentLock.catch(() => {});
     let release;
     const current = new Promise((resolve) => {
       release = resolve;
     });
-    this.localAttachmentLock = previous.then(() => current);
+    this.attachmentLock = previous.then(() => current);
     await previous;
     let released = false;
     return () => {
@@ -1331,12 +1612,16 @@ class DuckLakeConnectionManager {
     await this.closeRuntime(runtime, options);
   }
   async closeRuntime(runtime, options) {
-    if (options.detach) {
-      try {
-        await runtime.run(`DETACH ${quoteIdentifier(duckLakeAlias(this.options))}`);
-      } catch {}
+    try {
+      await runtime.stopReaders();
+      if (options.detach) {
+        try {
+          await runtime.run(`DETACH ${quoteIdentifier(duckLakeAlias(this.options))}`);
+        } catch {}
+      }
+    } finally {
+      await runtime.close();
     }
-    await runtime.close();
   }
 }
 var localCatalogGenerations = new Map;
@@ -1358,12 +1643,12 @@ function incrementLocalCatalogGeneration(options) {
 import { randomUUID as randomUUID2 } from "crypto";
 import {
   assertDatasetDefinition,
-  LakeStorageError as LakeStorageError13,
+  LakeStorageError as LakeStorageError14,
   planDatasetDefinitionUpdate
 } from "@sixb/core/lake-storage";
 
 // src/internal/ducklake-catalog-schema.ts
-import { LakeStorageError as LakeStorageError11 } from "@sixb/core/lake-storage";
+import { LakeStorageError as LakeStorageError12 } from "@sixb/core/lake-storage";
 var SIXB_PRIMARY_KEY_COMMENT_NAMESPACE = "sixb:primary-key:";
 var DATASET_SEQUENCE_COLUMN_COMMENT = "sixb.sequenceBy.v1";
 var SIXB_PRIMARY_KEY_COMMENT_PREFIX = `${SIXB_PRIMARY_KEY_COMMENT_NAMESPACE}v1:`;
@@ -1414,14 +1699,14 @@ function duckLakeCatalogColumnsToDatasetPrimaryKey(tableName, rows) {
       throwInvalidPrimaryKeyMetadata(tableName, column, comment);
     }
     if (seenOrdinals.has(ordinal)) {
-      throw new LakeStorageError11(`[SixbDuckLake] Dataset table '${tableName}' has duplicate primary-key ordinal '${ordinal}'.`);
+      throw new LakeStorageError12(`[SixbDuckLake] Dataset table '${tableName}' has duplicate primary-key ordinal '${ordinal}'.`);
     }
     seenOrdinals.add(ordinal);
     if (duckDbTypeToDatasetColumnType(column.columnType) !== "string") {
-      throw new LakeStorageError11(`[SixbDuckLake] Dataset table '${tableName}' primary-key column '${column.columnName}' must map to type 'string'.`);
+      throw new LakeStorageError12(`[SixbDuckLake] Dataset table '${tableName}' primary-key column '${column.columnName}' must map to type 'string'.`);
     }
     if (column.nullsAllowed) {
-      throw new LakeStorageError11(`[SixbDuckLake] Dataset table '${tableName}' primary-key column '${column.columnName}' must not be nullable.`);
+      throw new LakeStorageError12(`[SixbDuckLake] Dataset table '${tableName}' primary-key column '${column.columnName}' must not be nullable.`);
     }
     keyedColumns.push({ column, ordinal });
   }
@@ -1431,7 +1716,7 @@ function duckLakeCatalogColumnsToDatasetPrimaryKey(tableName, rows) {
   keyedColumns.sort((left, right) => left.ordinal - right.ordinal);
   for (const [expectedOrdinal, keyedColumn] of keyedColumns.entries()) {
     if (keyedColumn.ordinal !== expectedOrdinal) {
-      throw new LakeStorageError11(`[SixbDuckLake] Dataset table '${tableName}' primary-key ordinals must be contiguous from 0.`);
+      throw new LakeStorageError12(`[SixbDuckLake] Dataset table '${tableName}' primary-key ordinals must be contiguous from 0.`);
     }
   }
   const columnNames = keyedColumns.map(({ column }) => column.columnName);
@@ -1441,7 +1726,7 @@ function duckLakeCatalogColumnsToDatasetPrimaryKey(tableName, rows) {
   return columnNames;
 }
 function throwInvalidPrimaryKeyMetadata(tableName, column, comment) {
-  throw new LakeStorageError11(`[SixbDuckLake] Dataset table '${tableName}' has malformed primary-key metadata '${comment}' on column '${column.columnName}'.`);
+  throw new LakeStorageError12(`[SixbDuckLake] Dataset table '${tableName}' has malformed primary-key metadata '${comment}' on column '${column.columnName}'.`);
 }
 function duckLakeCatalogColumnToDefinition(tableName, column, childrenByParentId) {
   const children = [...childrenByParentId.get(column.columnId) ?? []].sort(compareDuckLakeCatalogColumnOrder);
@@ -1458,7 +1743,7 @@ function duckLakeCatalogColumnTypeToDatasetType(tableName, column, children) {
   if (isFileRefStruct(children)) {
     return "fileRef";
   }
-  throw new LakeStorageError11(`[SixbDuckLake] DuckDB column type '${formatDuckLakeCatalogColumnType(column, children)}' in dataset table '${tableName}' cannot be mapped to a Sixb dataset column type.`);
+  throw new LakeStorageError12(`[SixbDuckLake] DuckDB column type '${formatDuckLakeCatalogColumnType(column, children)}' in dataset table '${tableName}' cannot be mapped to a Sixb dataset column type.`);
 }
 function compareDuckLakeCatalogColumnOrder(left, right) {
   return Number(left.columnOrder - right.columnOrder);
@@ -1480,7 +1765,7 @@ function formatDuckLakeCatalogColumnType(column, children) {
 }
 
 // src/internal/ducklake-current-dataset-definitions.ts
-import { LakeStorageError as LakeStorageError12 } from "@sixb/core/lake-storage";
+import { LakeStorageError as LakeStorageError13 } from "@sixb/core/lake-storage";
 async function readCurrentDatasetDefinitions(input) {
   if (input.datasetIds?.length === 0) {
     return new Map;
@@ -1607,7 +1892,7 @@ async function readCurrentDatasetPartitions(input, tableNames) {
       transform: getString(row, "transform")
     };
     if (partition.transform !== "identity") {
-      throw new LakeStorageError12(`[SixbDuckLake] Dataset table '${partition.tableName}' uses unsupported DuckLake partition transform '${partition.transform}'.`);
+      throw new LakeStorageError13(`[SixbDuckLake] Dataset table '${partition.tableName}' uses unsupported DuckLake partition transform '${partition.transform}'.`);
     }
     return partition;
   });
@@ -1709,7 +1994,7 @@ class DuckLakeDatasetCatalog {
     if (failures.length > 0) {
       const details = failures.join(`
 `);
-      throw new LakeStorageError13(`[SixbLake] Lake dataset definition check failed for ${failures.length} dataset(s).
+      throw new LakeStorageError14(`[SixbLake] Lake dataset definition check failed for ${failures.length} dataset(s).
 ${details}`);
     }
   }
@@ -1745,12 +2030,12 @@ ${details}`);
     assertDuckLakeSnapshotId(snapshotId);
     const columns = await this.readDatasetColumnsAtSnapshot(runtime, tableName, tableId, snapshotId);
     if (columns.length === 0) {
-      throw new LakeStorageError13(`[SixbDuckLake] Could not reconstruct schema for dataset '${datasetId}' at DuckLake snapshot '${snapshotId}'.`);
+      throw new LakeStorageError14(`[SixbDuckLake] Could not reconstruct schema for dataset '${datasetId}' at DuckLake snapshot '${snapshotId}'.`);
     }
     return duckLakeCatalogColumnsToDatasetSchema(tableName, columns);
   }
   assertSchema(definition) {
-    assertDatasetDefinition(definition, (message) => new LakeStorageError13(`[SixbDuckLake] ${message}`));
+    assertDatasetDefinition(definition, (message) => new LakeStorageError14(`[SixbDuckLake] ${message}`));
   }
   async applyExistingDatasetUpdate(plan) {
     const tableName = encodeDatasetTableName(plan.definition.id);
@@ -1797,7 +2082,7 @@ ${details}`);
       await runtime.run(`ALTER TABLE ${qualifiedName} SET PARTITIONED BY (${definition.partitionBy.map((columnName) => quoteIdentifier(columnName)).join(", ")})`);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      throw new LakeStorageError13(`[SixbDuckLake] Dataset '${definition.id}' cannot apply partitionBy because DuckLake rejected ALTER TABLE SET PARTITIONED BY: ${message}`);
+      throw new LakeStorageError14(`[SixbDuckLake] Dataset '${definition.id}' cannot apply partitionBy because DuckLake rejected ALTER TABLE SET PARTITIONED BY: ${message}`);
     }
   }
   async applyPrimaryKey(runtime, qualifiedName, definition) {
@@ -1856,12 +2141,12 @@ ${details}`);
 }
 function assertDuckLakeSnapshotId(snapshotId) {
   if (!/^\d+$/.test(snapshotId)) {
-    throw new LakeStorageError13(`[SixbDuckLake] Invalid DuckLake snapshot id '${snapshotId}'.`);
+    throw new LakeStorageError14(`[SixbDuckLake] Invalid DuckLake snapshot id '${snapshotId}'.`);
   }
 }
 
 // src/internal/ducklake-maintenance.ts
-import { LakeStorageError as LakeStorageError14 } from "@sixb/core/lake-storage";
+import { LakeStorageError as LakeStorageError15 } from "@sixb/core/lake-storage";
 var DEFAULT_RETENTION = "7 days";
 
 class DuckLakeMaintenance {
@@ -1877,9 +2162,9 @@ class DuckLakeMaintenance {
     const deleteOlderThan = options.deleteOlderThan ?? expireOlderThan;
     const dryRun = options.dryRun ?? false;
     if (this.options.readOnly && !dryRun) {
-      throw new LakeStorageError14("[SixbDuckLake] DuckLake maintenance cannot run in read-only mode.");
+      throw new LakeStorageError15("[SixbDuckLake] DuckLake maintenance cannot run in read-only mode.");
     }
-    return this.connections.withExclusiveAttached(async (runtime) => {
+    return this.connections.withMaintenanceRuntime(async (runtime) => {
       const counts = await runMaintenanceProcedures(runtime, this.options, {
         expireOlderThan,
         deleteOlderThan
@@ -1914,7 +2199,7 @@ function maintenanceProcedureSql(procedure, aliasSql, olderThan, dryRun) {
 }
 
 // src/internal/ducklake-row-reader.ts
-import { LakeStorageError as LakeStorageError15 } from "@sixb/core/lake-storage";
+import { LakeStorageError as LakeStorageError16 } from "@sixb/core/lake-storage";
 var READ_PAGE_ROWS = 5000;
 var PHYSICAL_ROW_ID_ALIAS = "__sixb_physical_row_id";
 
@@ -1928,58 +2213,68 @@ class DuckLakeRowReader {
     this.snapshots = snapshots;
   }
   async* readRows(input) {
-    this.connections.assertOpen();
-    const lease = await this.connections.acquireAttachedRuntime();
+    const read = await this.connections.acquireRead(input.signal);
+    let reader = null;
     try {
-      const runtime = lease.runtime;
-      const tableRef = await resolveDatasetTableRef(this.options, runtime, input.datasetId);
-      if (!tableRef) {
-        throw new LakeStorageError15(`[SixbDuckLake] Unknown dataset '${input.datasetId}'.`);
-      }
-      const version = await this.resolveVersion(runtime, tableRef, input.versionId);
-      const selectedColumns = this.resolveReadColumns(tableRef.datasetId, version.schema, input.columns);
-      const snapshotId = parseVersionId(version.versionId);
-      const columnsSql = selectedColumns.map((column) => quoteIdentifier(column.name)).join(", ");
-      const tableSql = qualifiedTableName(this.options, tableRef.tableName);
-      const schemaNames = new Set(version.schema.columns.map((column) => column.name.toLowerCase()));
-      const canUsePhysicalRowId = !schemaNames.has("rowid") && !schemaNames.has(PHYSICAL_ROW_ID_ALIAS.toLowerCase());
-      const orderSql = canUsePhysicalRowId ? " ORDER BY rowid" : "";
-      const baseSql = `SELECT ${columnsSql} FROM ${tableSql} AT (VERSION => ${snapshotId})`;
-      const requestedOffset = Math.max(0, Math.trunc(input.offset ?? 0));
-      let remaining = input.limit === undefined ? undefined : Math.max(0, Math.trunc(input.limit));
-      if (remaining === 0)
+      const prepared = await this.connections.withAttachedRuntime(async (runtime) => {
+        read.signal.throwIfAborted();
+        const tableRef = await resolveDatasetTableRef(this.options, runtime, input.datasetId);
+        if (!tableRef) {
+          throw new LakeStorageError16(`[SixbDuckLake] Unknown dataset '${input.datasetId}'.`);
+        }
+        const version = await this.resolveVersion(runtime, tableRef, input.versionId);
+        const columns = this.resolveReadColumns(tableRef.datasetId, version.schema, input.columns);
+        const names = new Set(version.schema.columns.map((column) => column.name.toLowerCase()));
+        const physicalOrder = !names.has("rowid") && !names.has(PHYSICAL_ROW_ID_ALIAS);
+        const relation = `${qualifiedTableName(this.options, tableRef.tableName)} AT (VERSION => ${parseVersionId(version.versionId)})`;
+        const columnsSql = columns.map((column) => quoteIdentifier(column.name)).join(", ");
+        const offset = Math.max(0, Math.trunc(input.offset ?? 0));
+        const limit = input.limit === undefined ? undefined : Math.max(0, Math.trunc(input.limit));
+        const sql = `SELECT ${columnsSql} FROM ${relation}${physicalOrder ? " ORDER BY rowid" : ""}${limit === undefined ? "" : ` LIMIT ${limit}`}${offset > 0 ? ` OFFSET ${offset}` : ""}`;
+        const cursor = limit === undefined || limit > READ_PAGE_ROWS ? await this.connections.openReader(runtime, sql, read.signal, read.release) : null;
+        const query = { columnsSql, relation, physicalOrder };
+        const firstPage = cursor || limit === 0 ? [] : await runtime.query(pageSql(query, Math.min(limit ?? READ_PAGE_ROWS, READ_PAGE_ROWS), offset, null));
+        return { columns, ...query, offset, limit, cursor, firstPage };
+      });
+      reader = prepared.cursor;
+      if (!reader)
+        read.signal.addEventListener("abort", read.release, { once: true });
+      read.signal.throwIfAborted();
+      if (reader) {
+        yield* this.normalizeRows(reader.rows(), prepared.columns, read.signal);
         return;
-      let offset = requestedOffset;
-      let physicalCursor = null;
-      while (true) {
-        const pageRows = remaining === undefined ? READ_PAGE_ROWS : Math.min(READ_PAGE_ROWS, remaining);
-        const pageSql = canUsePhysicalRowId ? `SELECT rowid AS ${quoteIdentifier(PHYSICAL_ROW_ID_ALIAS)}, ${columnsSql}
-              FROM ${tableSql} AT (VERSION => ${snapshotId})
-              ${physicalCursor === null ? "" : `WHERE rowid > ${physicalCursor}`}
-              ORDER BY rowid LIMIT ${pageRows}
-              ${physicalCursor === null && offset > 0 ? `OFFSET ${offset}` : ""}` : `${baseSql}${orderSql} LIMIT ${pageRows} OFFSET ${offset}`;
-        const rows = await runtime.query(pageSql);
-        if (rows.length === 0)
-          return;
-        yield* this.normalizeRows(rows, selectedColumns);
-        offset += rows.length;
-        if (remaining !== undefined) {
+      }
+      let offset = prepared.offset;
+      let remaining = prepared.limit;
+      let cursor = null;
+      let page = prepared.firstPage;
+      while (remaining !== 0) {
+        read.signal.throwIfAborted();
+        const pageSize = Math.min(remaining ?? READ_PAGE_ROWS, READ_PAGE_ROWS);
+        const rows = page ?? await this.connections.withAttachedRuntime((runtime) => runtime.query(pageSql(prepared, pageSize, offset, cursor)));
+        page = undefined;
+        read.signal.throwIfAborted();
+        yield* this.normalizeRows(rows, prepared.columns, read.signal);
+        if (remaining !== undefined)
           remaining -= rows.length;
-          if (remaining === 0)
-            return;
-        }
-        if (canUsePhysicalRowId) {
-          physicalCursor = getBigIntLike(rows[rows.length - 1], PHYSICAL_ROW_ID_ALIAS);
-        }
-        if (rows.length < pageRows)
+        if (rows.length < pageSize)
           return;
+        if (prepared.physicalOrder)
+          cursor = getBigIntLike(rows[rows.length - 1], PHYSICAL_ROW_ID_ALIAS);
+        offset += rows.length;
       }
     } finally {
-      await lease.release();
+      read.signal.removeEventListener("abort", read.release);
+      try {
+        await reader?.close();
+      } finally {
+        read.release();
+      }
     }
   }
-  async* normalizeRows(rows, selectedColumns) {
+  async* normalizeRows(rows, selectedColumns, signal) {
     for await (const row of rows) {
+      signal.throwIfAborted();
       const output = {};
       for (const column of selectedColumns) {
         output[column.name] = normalizeReadValue(row[column.name], column);
@@ -2010,19 +2305,25 @@ class DuckLakeRowReader {
     return columns.map((columnName) => {
       const column = columnsByName.get(columnName);
       if (!column) {
-        throw new LakeStorageError15(`[SixbDuckLake] Dataset '${datasetId}' does not have column '${columnName}' at the requested version.`);
+        throw new LakeStorageError16(`[SixbDuckLake] Dataset '${datasetId}' does not have column '${columnName}' at the requested version.`);
       }
       return column;
     });
   }
   throwNoCommittedVersion(datasetId) {
-    throw new LakeStorageError15(`[SixbDuckLake] No committed version found for dataset '${datasetId}'.`);
+    throw new LakeStorageError16(`[SixbDuckLake] No committed version found for dataset '${datasetId}'.`);
   }
 }
+function pageSql(read, limit, offset, cursor) {
+  return read.physicalOrder ? `SELECT rowid AS ${quoteIdentifier(PHYSICAL_ROW_ID_ALIAS)}, ${read.columnsSql}
+        FROM ${read.relation} ${cursor === null ? "" : `WHERE rowid > ${cursor}`}
+        ORDER BY rowid LIMIT ${limit} ${cursor === null && offset > 0 ? `OFFSET ${offset}` : ""}` : `SELECT ${read.columnsSql} FROM ${read.relation} LIMIT ${limit} OFFSET ${offset}`;
+}
 
 // src/internal/ducklake-snapshot-reader.ts
-import { LakeStorageError as LakeStorageError16 } from "@sixb/core/lake-storage";
+import { LakeStorageError as LakeStorageError17 } from "@sixb/core/lake-storage";
 var SNAPSHOT_ROW_BATCH_SIZE = 128;
+var FEED_PAGE_SIZE = 512;
 var CATALOG_SNAPSHOT_SCAN_LIMIT = 512;
 
 class DuckLakeSnapshotReader {
@@ -2088,6 +2389,135 @@ class DuckLakeSnapshotReader {
       };
     });
   }
+  async listLatestVersionsSince(input) {
+    this.connections.assertOpen();
+    return this.connections.withAttachedRuntime(async (runtime) => {
+      if (input.cursor === null) {
+        return { cursor: await this.queryHeadSnapshotId(runtime), versions: [] };
+      }
+      if (!/^\d+$/.test(input.cursor)) {
+        return null;
+      }
+      const snapshots = await this.querySnapshotsFrom(runtime, input.cursor);
+      if (snapshots[0]?.snapshotId !== input.cursor) {
+        return null;
+      }
+      const newSnapshots = snapshots.slice(1);
+      if (newSnapshots.length === 0) {
+        return { cursor: input.cursor, versions: [] };
+      }
+      const tables = await this.resolveFeedTables(runtime, input.datasetIds);
+      const latest = await this.collectFeedPage(runtime, tables, newSnapshots);
+      return {
+        cursor: newSnapshots[newSnapshots.length - 1]?.snapshotId ?? input.cursor,
+        versions: [...latest].map(([datasetId, row]) => this.snapshotRowToSummary(datasetId, row))
+      };
+    });
+  }
+  async queryHeadSnapshotId(runtime) {
+    const [row] = await runtime.query(buildDuckLakeMetadataQuery(this.options, (table) => `SELECT max(snapshot_id) AS snapshot_id FROM ${table("ducklake_snapshot")}`));
+    if (row?.snapshot_id === null || row?.snapshot_id === undefined) {
+      throw new LakeStorageError17("[SixbDuckLake] DuckLake catalog has no snapshots.");
+    }
+    return String(getBigIntLike(row, "snapshot_id"));
+  }
+  async querySnapshotsFrom(runtime, cursor) {
+    const rows = await runtime.query(buildDuckLakeMetadataQuery(this.options, (table) => `
+          SELECT snapshot_id, snapshot_time
+          FROM ${table("ducklake_snapshot")}
+          WHERE snapshot_id >= ${cursor}
+          ORDER BY snapshot_id
+          LIMIT ${FEED_PAGE_SIZE + 1}
+        `));
+    return rows.map((row) => ({
+      snapshotId: String(getBigIntLike(row, "snapshot_id")),
+      createdAt: getDate(row, "snapshot_time")
+    }));
+  }
+  async resolveFeedTables(runtime, datasetIds) {
+    const requested = datasetIds === undefined ? null : new Set(datasetIds);
+    const rows = await runtime.query(`
+      SELECT table_id, table_name, begin_snapshot, end_snapshot
+      FROM ${duckLakeMetadataTableName(this.options, "ducklake_table")}
+    `);
+    const startByTableId = new Map;
+    const current = [];
+    for (const row of rows) {
+      const tableId = getBigIntLike(row, "table_id");
+      const begin = getBigIntLike(row, "begin_snapshot");
+      const start = startByTableId.get(tableId);
+      if (start === undefined || begin < start) {
+        startByTableId.set(tableId, begin);
+      }
+      if (row.end_snapshot !== null && row.end_snapshot !== undefined) {
+        continue;
+      }
+      const datasetId = decodeDatasetTableName(getString(row, "table_name"));
+      if (datasetId !== null && (requested === null || requested.has(datasetId))) {
+        current.push({ datasetId, tableId });
+      }
+    }
+    return current.map((table) => ({
+      ...table,
+      startSnapshotId: startByTableId.get(table.tableId) ?? 0n
+    }));
+  }
+  async collectFeedPage(runtime, tables, snapshots) {
+    const latest = new Map;
+    const first = snapshots[0]?.snapshotId;
+    const last = snapshots[snapshots.length - 1]?.snapshotId;
+    if (first === undefined || last === undefined || tables.length === 0) {
+      return latest;
+    }
+    const changeRows = await runtime.query(buildDuckLakeMetadataQuery(this.options, (table) => `
+          SELECT snapshot_id, changes_made, commit_extra_info
+          FROM ${table("ducklake_snapshot_changes")}
+          WHERE snapshot_id >= ${first} AND snapshot_id <= ${last}
+        `));
+    const fileFlags = await this.queryFileChangeFlags(runtime, snapshots.map((snapshot) => snapshot.snapshotId), tables.map((table) => table.tableId));
+    const changesBySnapshotId = new Map(changeRows.map((row) => [String(getBigIntLike(row, "snapshot_id")), row]));
+    const tablesByTableId = new Map(tables.map((table) => [table.tableId.toString(), table]));
+    const tablesByDatasetId = new Map(tables.map((table) => [table.datasetId, table]));
+    for (const snapshot of snapshots) {
+      const changes = changesBySnapshotId.get(snapshot.snapshotId);
+      if (changes === undefined) {
+        continue;
+      }
+      const changesMade = getString(changes, "changes_made");
+      const metadata = parseCommitMetadata(changes.commit_extra_info);
+      const touched = new Set;
+      for (const change of changesMade.split(",")) {
+        const table = tablesByTableId.get(change.split(":")[1] ?? "");
+        if (table)
+          touched.add(table);
+      }
+      for (const table of tables) {
+        if (fileFlags.has(fileChangeKey(snapshot.snapshotId, table.tableId)))
+          touched.add(table);
+      }
+      const tagged = metadata === undefined ? undefined : tablesByDatasetId.get(metadata.datasetId);
+      if (tagged)
+        touched.add(tagged);
+      for (const table of touched) {
+        if (BigInt(snapshot.snapshotId) < table.startSnapshotId) {
+          continue;
+        }
+        const flags = fileFlags.get(fileChangeKey(snapshot.snapshotId, table.tableId));
+        const row = this.candidateToSnapshotRow(table.datasetId, table.tableId, {
+          snapshotId: snapshot.snapshotId,
+          createdAt: snapshot.createdAt,
+          changesMade,
+          hasFileChange: flags?.hasFileChange ?? false,
+          hasFileDeleteChange: flags?.hasFileDeleteChange ?? false,
+          ...metadata !== undefined ? { metadata } : {}
+        });
+        if (row && row.mode !== "schema") {
+          latest.set(table.datasetId, row);
+        }
+      }
+    }
+    return latest;
+  }
   snapshotRowToSummary(datasetId, row) {
     return {
       datasetId,
@@ -2234,7 +2664,7 @@ class DuckLakeSnapshotReader {
   }
   assertNoMetadataConflict(snapshotId, datasetId, metadata) {
     if (metadata !== undefined && metadata.datasetId !== datasetId) {
-      throw new LakeStorageError16(`[SixbDuckLake] DuckLake snapshot '${snapshotId}' changed dataset '${datasetId}' but Sixb commit metadata references dataset '${metadata.datasetId}'.`);
+      throw new LakeStorageError17(`[SixbDuckLake] DuckLake snapshot '${snapshotId}' changed dataset '${datasetId}' but Sixb commit metadata references dataset '${metadata.datasetId}'.`);
     }
   }
   async getLatestVersionForDefinition(runtime, dataset) {
@@ -2351,6 +2781,7 @@ class DuckLakeSnapshotReader {
     let beforeSnapshotId = input.beforeSnapshotId;
     while (input.visibleRowLimit === undefined || snapshots.length < input.visibleRowLimit) {
       const candidates = await this.querySnapshotCandidates(runtime, {
+        datasetId: input.datasetId,
         tableId: input.tableId,
         exactSnapshotId: input.exactSnapshotId,
         beforeSnapshotId,
@@ -2360,6 +2791,9 @@ class DuckLakeSnapshotReader {
         break;
       }
       for (const candidate of candidates) {
+        if ("missing" in candidate) {
+          continue;
+        }
         const snapshot = this.candidateToSnapshotRow(input.datasetId, input.tableId, candidate);
         if (snapshot) {
           snapshots.push(snapshot);
@@ -2376,87 +2810,118 @@ class DuckLakeSnapshotReader {
     return snapshots;
   }
   async querySnapshotCandidates(runtime, input) {
-    if (input.limit !== undefined && input.limit <= 0) {
+    const tableId = input.tableId.toString();
+    const limit = Math.max(0, Math.trunc(input.limit));
+    if (limit === 0) {
       return [];
     }
-    const where = [];
     if (input.exactSnapshotId !== undefined) {
       assertDuckLakeSnapshotId2(input.exactSnapshotId);
-      where.push(`snapshot.snapshot_id = ${input.exactSnapshotId}`);
     }
     if (input.beforeSnapshotId !== undefined) {
       assertDuckLakeSnapshotId2(input.beforeSnapshotId);
-      where.push(`snapshot.snapshot_id < ${input.beforeSnapshotId}`);
     }
-    const whereSql = where.length === 0 ? "" : `WHERE ${where.join(" AND ")}`;
-    const limitSql = input.limit === undefined ? "" : `LIMIT ${Math.max(0, Math.trunc(input.limit))}`;
-    const ducklakeSnapshot = duckLakeMetadataTableName(this.options, "ducklake_snapshot");
-    const ducklakeSnapshotChanges = duckLakeMetadataTableName(this.options, "ducklake_snapshot_changes");
-    const ducklakeDataFile = duckLakeMetadataTableName(this.options, "ducklake_data_file");
-    const ducklakeDeleteFile = duckLakeMetadataTableName(this.options, "ducklake_delete_file");
-    const rows = await runtime.query(`
-      WITH candidate_snapshots AS (
-        -- Recent DuckLake snapshots to inspect; Sixb visibility is filtered later.
-        SELECT
-          snapshot.snapshot_id,
-          snapshot.snapshot_time,
-          changes.changes_made,
-          changes.commit_extra_info
-        FROM ${ducklakeSnapshot} snapshot
-        JOIN ${ducklakeSnapshotChanges} changes
-          ON changes.snapshot_id = snapshot.snapshot_id
-        ${whereSql}
-        ORDER BY snapshot.snapshot_id DESC
-        ${limitSql}
-      ),
-      file_changes AS (
-        -- File metadata tells whether this table changed in each candidate snapshot.
-        SELECT begin_snapshot AS snapshot_id, false AS is_delete_change
-        FROM ${ducklakeDataFile}
-        WHERE table_id = ${input.tableId}
-          AND begin_snapshot IN (SELECT snapshot_id FROM candidate_snapshots)
-        UNION ALL
-        SELECT end_snapshot AS snapshot_id, true AS is_delete_change
-        FROM ${ducklakeDataFile}
-        WHERE table_id = ${input.tableId}
-          AND end_snapshot IN (SELECT snapshot_id FROM candidate_snapshots)
-        UNION ALL
-        SELECT begin_snapshot AS snapshot_id, true AS is_delete_change
-        FROM ${ducklakeDeleteFile}
-        WHERE table_id = ${input.tableId}
-          AND begin_snapshot IN (SELECT snapshot_id FROM candidate_snapshots)
-        UNION ALL
-        SELECT end_snapshot AS snapshot_id, true AS is_delete_change
-        FROM ${ducklakeDeleteFile}
-        WHERE table_id = ${input.tableId}
-          AND end_snapshot IN (SELECT snapshot_id FROM candidate_snapshots)
-      ),
-      file_changes_by_snapshot AS (
-        -- Collapse file-level changes into one row per snapshot.
-        SELECT
-          snapshot_id,
-          count(*) > 0 AS has_file_change,
-          count(*) FILTER (WHERE is_delete_change) > 0 AS has_file_delete_change
-        FROM file_changes
-        GROUP BY snapshot_id
-      )
-      SELECT
-        -- Keep metadata-only candidates; Sixb filters them with commit_extra_info.
-        candidate.snapshot_id,
-        candidate.snapshot_time,
-        candidate.changes_made,
-        candidate.commit_extra_info,
-        coalesce(file_changes.has_file_change, false) AS has_file_change,
-        coalesce(file_changes.has_file_delete_change, false) AS has_file_delete_change
-      FROM candidate_snapshots candidate
-      LEFT JOIN file_changes_by_snapshot file_changes
-        ON file_changes.snapshot_id = candidate.snapshot_id
-      ORDER BY candidate.snapshot_id DESC
-    `);
+    const rows = await runtime.query(buildDuckLakeMetadataQuery(this.options, (table) => {
+      const tableStart = `(SELECT min(begin_snapshot) FROM ${table("ducklake_table")} WHERE table_id = ${tableId})`;
+      const candidateIds = input.exactSnapshotId !== undefined ? `SELECT CAST(${input.exactSnapshotId} AS BIGINT) AS snapshot_id
+               WHERE ${input.exactSnapshotId} >= ${tableStart}` : `SELECT DISTINCT snapshot_id
+               FROM (
+                 SELECT begin_snapshot AS snapshot_id
+                 FROM ${table("ducklake_data_file")} WHERE table_id = ${tableId}
+                 UNION ALL
+                 SELECT end_snapshot
+                 FROM ${table("ducklake_data_file")}
+                 WHERE table_id = ${tableId} AND end_snapshot IS NOT NULL
+                 UNION ALL
+                 SELECT begin_snapshot
+                 FROM ${table("ducklake_delete_file")} WHERE table_id = ${tableId}
+                 UNION ALL
+                 SELECT end_snapshot
+                 FROM ${table("ducklake_delete_file")}
+                 WHERE table_id = ${tableId} AND end_snapshot IS NOT NULL
+                 UNION ALL
+                 SELECT snapshot_id
+                 FROM ${table("ducklake_snapshot_changes")}
+                 WHERE strpos(',' || changes_made || ',', ${quoteSqlString(`:${tableId},`)}) > 0
+                   OR strpos(
+                     commit_extra_info,
+                     ${quoteSqlString(`"datasetId":${JSON.stringify(input.datasetId)}`)}
+                   ) > 0
+               ) touched
+               WHERE snapshot_id >= ${tableStart}
+                 ${input.beforeSnapshotId === undefined ? "" : `AND snapshot_id < ${input.beforeSnapshotId}`}
+               ORDER BY snapshot_id DESC
+               LIMIT ${limit}`;
+      return `
+          WITH candidate_ids AS (
+            ${candidateIds}
+          ),
+          candidate_snapshots AS (
+            SELECT
+              snapshot.snapshot_id,
+              snapshot.snapshot_time,
+              changes.changes_made,
+              changes.commit_extra_info
+            FROM ${table("ducklake_snapshot")} snapshot
+            JOIN ${table("ducklake_snapshot_changes")} changes
+              ON changes.snapshot_id = snapshot.snapshot_id
+            WHERE snapshot.snapshot_id IN (SELECT snapshot_id FROM candidate_ids)
+          ),
+          file_changes AS (
+            -- File metadata tells whether this table changed in each candidate snapshot.
+            SELECT begin_snapshot AS snapshot_id, false AS is_delete_change
+            FROM ${table("ducklake_data_file")}
+            WHERE table_id = ${tableId}
+              AND begin_snapshot IN (SELECT snapshot_id FROM candidate_ids)
+            UNION ALL
+            SELECT end_snapshot AS snapshot_id, true AS is_delete_change
+            FROM ${table("ducklake_data_file")}
+            WHERE table_id = ${tableId}
+              AND end_snapshot IN (SELECT snapshot_id FROM candidate_ids)
+            UNION ALL
+            SELECT begin_snapshot AS snapshot_id, true AS is_delete_change
+            FROM ${table("ducklake_delete_file")}
+            WHERE table_id = ${tableId}
+              AND begin_snapshot IN (SELECT snapshot_id FROM candidate_ids)
+            UNION ALL
+            SELECT end_snapshot AS snapshot_id, true AS is_delete_change
+            FROM ${table("ducklake_delete_file")}
+            WHERE table_id = ${tableId}
+              AND end_snapshot IN (SELECT snapshot_id FROM candidate_ids)
+          ),
+          file_changes_by_snapshot AS (
+            -- Collapse file-level changes into one row per snapshot.
+            SELECT
+              snapshot_id,
+              count(*) > 0 AS has_file_change,
+              count(*) FILTER (WHERE is_delete_change) > 0 AS has_file_delete_change
+            FROM file_changes
+            GROUP BY snapshot_id
+          )
+          SELECT
+            -- Keep metadata-only candidates; Sixb filters them with commit_extra_info.
+            candidate_ids.snapshot_id,
+            candidate.snapshot_time,
+            candidate.changes_made,
+            candidate.commit_extra_info,
+            coalesce(file_changes.has_file_change, false) AS has_file_change,
+            coalesce(file_changes.has_file_delete_change, false) AS has_file_delete_change
+          FROM candidate_ids
+          LEFT JOIN candidate_snapshots candidate
+            ON candidate.snapshot_id = candidate_ids.snapshot_id
+          LEFT JOIN file_changes_by_snapshot file_changes
+            ON file_changes.snapshot_id = candidate_ids.snapshot_id
+          ORDER BY candidate_ids.snapshot_id DESC
+        `;
+    }));
     return rows.map((row) => {
+      const snapshotId = String(getBigIntLike(row, "snapshot_id"));
+      if (row.snapshot_time === null || row.snapshot_time === undefined) {
+        return { snapshotId, missing: true };
+      }
       const metadata = parseCommitMetadata(row.commit_extra_info);
       return {
-        snapshotId: String(getBigIntLike(row, "snapshot_id")),
+        snapshotId,
         createdAt: getDate(row, "snapshot_time"),
         changesMade: getString(row, "changes_made"),
         hasFileChange: getBoolean(row, "has_file_change"),
@@ -2514,7 +2979,7 @@ class DuckLakeSnapshotReader {
 }
 function assertDuckLakeSnapshotId2(snapshotId) {
   if (!/^\d+$/.test(snapshotId)) {
-    throw new LakeStorageError16(`[SixbDuckLake] Invalid DuckLake snapshot id '${snapshotId}'.`);
+    throw new LakeStorageError17(`[SixbDuckLake] Invalid DuckLake snapshot id '${snapshotId}'.`);
   }
 }
 function fileChangeKey(snapshotId, tableId) {
@@ -2524,17 +2989,17 @@ function fileChangeKey(snapshotId, tableId) {
 // src/internal/ducklake-sql-executor.ts
 import { randomUUID as randomUUID4 } from "crypto";
 import {
-  LakeStorageError as LakeStorageError19
+  LakeStorageError as LakeStorageError20
 } from "@sixb/core/lake-storage";
 
 // src/internal/dataset-row-commit.ts
 import {
   getDatasetPrimaryKeyColumns,
-  LakeStorageError as LakeStorageError17
+  LakeStorageError as LakeStorageError18
 } from "@sixb/core/lake-storage";
 function assertDatasetWriteMode(mode, operation) {
   if (mode !== "snapshot" && mode !== "append") {
-    throw new LakeStorageError17(`[SixbDuckLake] Invalid ${operation} mode '${String(mode)}'. Expected 'snapshot' or 'append'.`);
+    throw new LakeStorageError18(`[SixbDuckLake] Invalid ${operation} mode '${String(mode)}'. Expected 'snapshot' or 'append'.`);
   }
 }
 async function applyDatasetRowsFromRelation(input) {
@@ -2594,7 +3059,7 @@ async function applyDatasetRowsFromRelation(input) {
 async function inspectUniqueKeyedRelation(input) {
   const primaryKeyColumns = getDatasetPrimaryKeyColumns(input.dataset);
   if (primaryKeyColumns === null) {
-    throw new LakeStorageError17(`[SixbDuckLake] Dataset '${input.dataset.id}' must define a primaryKey before rows can be keyed.`);
+    throw new LakeStorageError18(`[SixbDuckLake] Dataset '${input.dataset.id}' must define a primaryKey before rows can be keyed.`);
   }
   const keysSql = primaryKeyColumns.map((column) => quoteIdentifier(column)).join(", ");
   const [row] = await input.runtime.query(`
@@ -2609,7 +3074,7 @@ async function inspectUniqueKeyedRelation(input) {
   const rowCount = row === undefined ? 0 : Number(getBigIntLike(row, "row_count"));
   const maxKeyCount = row === undefined ? 0 : Number(getBigIntLike(row, "max_key_count"));
   if (maxKeyCount > 1) {
-    throw new LakeStorageError17(`[SixbDuckLake] Dataset '${input.dataset.id}' ${input.context} contains duplicate primary key.`);
+    throw new LakeStorageError18(`[SixbDuckLake] Dataset '${input.dataset.id}' ${input.context} contains duplicate primary key.`);
   }
   return rowCount;
 }
@@ -2626,7 +3091,7 @@ async function assertNoPrimaryKeyOverlap(input) {
     LIMIT 1
   `);
   if (collision !== undefined) {
-    throw new LakeStorageError17(`[SixbDuckLake] Dataset '${input.dataset.id}' ${input.context} contains duplicate primary key.`);
+    throw new LakeStorageError18(`[SixbDuckLake] Dataset '${input.dataset.id}' ${input.context} contains duplicate primary key.`);
   }
 }
 async function fingerprintRelation(runtime, relationSql, columnsSql) {
@@ -2660,7 +3125,7 @@ async function countRows(runtime, relationSql) {
 // src/internal/sql-transform-relations.ts
 import { randomUUID as randomUUID3 } from "crypto";
 import {
-  LakeStorageError as LakeStorageError18
+  LakeStorageError as LakeStorageError19
 } from "@sixb/core/lake-storage";
 var RELATION_PLACEHOLDER_PREFIX = "__sixb_sql_transform_relation_";
 var RELATION_PLACEHOLDER_PATTERN = /__sixb_sql_transform_relation_[0-9a-f]{32}_[0-9]+__/g;
@@ -2678,7 +3143,7 @@ function renderDuckLakeSqlTransformSql(input) {
   const context = createDuckLakeSqlTransformRelationContext(input);
   const sql = input.sql(context.relations);
   if (typeof sql !== "string") {
-    throw new LakeStorageError18("[SixbDuckLake] SQL transform body must return a SQL string.");
+    throw new LakeStorageError19("[SixbDuckLake] SQL transform body must return a SQL string.");
   }
   return context.render(sql);
 }
@@ -2716,7 +3181,7 @@ function renderDuckLakeSourceRelation(options, source) {
   return `(SELECT * FROM ${qualifiedTableName(options, tableName)} AT (VERSION => ${snapshotId}))`;
 }
 function throwUnresolvedPlaceholder() {
-  throw new LakeStorageError18("[SixbDuckLake] SQL transform contains an unresolved relation placeholder.");
+  throw new LakeStorageError19("[SixbDuckLake] SQL transform contains an unresolved relation placeholder.");
 }
 
 // src/internal/ducklake-sql-executor.ts
@@ -2810,14 +3275,14 @@ class DuckLakeSqlExecutor {
   async resolveSourceDataset(runtime, dataset) {
     const definition = await this.datasets.getDatasetOnRuntime(runtime, dataset.id);
     if (!definition) {
-      throw new LakeStorageError19(`[SixbDuckLake] Unknown SQL transform source dataset '${dataset.id}'.`);
+      throw new LakeStorageError20(`[SixbDuckLake] Unknown SQL transform source dataset '${dataset.id}'.`);
     }
     return definition;
   }
   async resolveTargetDataset(runtime, dataset) {
     const definition = await this.datasets.getDatasetOnRuntime(runtime, dataset.id);
     if (!definition) {
-      throw new LakeStorageError19(`[SixbDuckLake] Unknown SQL transform target dataset '${dataset.id}'.`);
+      throw new LakeStorageError20(`[SixbDuckLake] Unknown SQL transform target dataset '${dataset.id}'.`);
     }
     this.datasets.assertSchema(definition);
     return definition;
@@ -2938,10 +3403,10 @@ function normalizePreviewValue(value) {
   return value;
 }
 function throwNoCommittedSourceVersion(datasetId) {
-  throw new LakeStorageError19(`[SixbDuckLake] No committed version found for SQL transform source dataset '${datasetId}'.`);
+  throw new LakeStorageError20(`[SixbDuckLake] No committed version found for SQL transform source dataset '${datasetId}'.`);
 }
 function throwResultSchemaMismatch(datasetId, detail) {
-  throw new LakeStorageError19(`[SixbDuckLake] SQL transform result schema does not match target dataset '${datasetId}': ${detail}.`);
+  throw new LakeStorageError20(`[SixbDuckLake] SQL transform result schema does not match target dataset '${datasetId}': ${detail}.`);
 }
 
 // src/internal/ducklake-write-coordinator.ts
@@ -2951,20 +3416,20 @@ import {
   getDatasetPrimaryKeyColumns as getDatasetPrimaryKeyColumns4,
   hasDatasetInputChanges,
   LakeConcurrencyError,
-  LakeStorageError as LakeStorageError23,
+  LakeStorageError as LakeStorageError24,
   retryDatasetMergeCommit
 } from "@sixb/core/lake-storage";
 
 // src/internal/dataset-row-merge.ts
 import {
   getDatasetPrimaryKeyColumns as getDatasetPrimaryKeyColumns2,
-  LakeStorageError as LakeStorageError20,
+  LakeStorageError as LakeStorageError21,
   reconcileDatasetSequences
 } from "@sixb/core/lake-storage";
 async function applyDatasetMergeFromRelation(input) {
   const primaryKeyColumns = getDatasetPrimaryKeyColumns2(input.dataset);
   if (primaryKeyColumns === null) {
-    throw new LakeStorageError20(`[SixbDuckLake] Dataset '${input.dataset.id}' must define a primaryKey before it can be merged.`);
+    throw new LakeStorageError21(`[SixbDuckLake] Dataset '${input.dataset.id}' must define a primaryKey before it can be merged.`);
   }
   const stagingTable = quoteIdentifier(input.stagingTableName);
   const targetTable = qualifiedTableName(input.options, encodeDatasetTableName(input.dataset.id));
@@ -3125,7 +3590,7 @@ function finalChangesSelectSql(input, primaryKeyColumns) {
 async function countMergeEffects(input, targetTable, finalChanges, primaryKeyColumns) {
   const matchColumn = primaryKeyColumns[0];
   if (matchColumn === undefined) {
-    throw new LakeStorageError20(`[SixbDuckLake] Dataset '${input.dataset.id}' primaryKey must contain at least one column.`);
+    throw new LakeStorageError21(`[SixbDuckLake] Dataset '${input.dataset.id}' primaryKey must contain at least one column.`);
   }
   const keyMatchSql = primaryKeyMatchSql(primaryKeyColumns, "target", "source");
   const targetMatch = `target.${quoteIdentifier(matchColumn)} IS NOT NULL`;
@@ -3179,7 +3644,7 @@ import {
   cloneDatasetMergeChange,
   datasetSequenceChange,
   getDatasetMergeChangeValidationError,
-  LakeStorageError as LakeStorageError21
+  LakeStorageError as LakeStorageError22
 } from "@sixb/core/lake-storage";
 
 // src/internal/row-appender.ts
@@ -3280,7 +3745,7 @@ class DuckLakeMergeSession {
     for await (const change of changes) {
       const validationError = getDatasetMergeChangeValidationError(change, this.input.dataset);
       if (validationError) {
-        throw new LakeStorageError21(`[SixbDuckLake] ${validationError}`);
+        throw new LakeStorageError22(`[SixbDuckLake] ${validationError}`);
       }
       batch.push({
         sequence: this.nextSequence,
@@ -3343,7 +3808,7 @@ class DuckLakeMergeSession {
   }
   assertOpen() {
     if (this.closed) {
-      throw new LakeStorageError21("[SixbDuckLake] Merge session is already closed.");
+      throw new LakeStorageError22("[SixbDuckLake] Merge session is already closed.");
     }
   }
   async cleanup() {
@@ -3363,7 +3828,7 @@ import { getDatasetRowValidationError } from "@sixb/core";
 import {
   encodeDatasetPrimaryKey,
   getDatasetPrimaryKeyColumns as getDatasetPrimaryKeyColumns3,
-  LakeStorageError as LakeStorageError22
+  LakeStorageError as LakeStorageError23
 } from "@sixb/core/lake-storage";
 var WRITE_ROW_BATCH_SIZE = 1000;
 async function createDuckLakeWriteSession(input) {
@@ -3394,13 +3859,13 @@ class DuckLakeWriteSession {
     for await (const row of rows) {
       const validationError = getDatasetRowValidationError(row, this.input.dataset);
       if (validationError) {
-        throw new LakeStorageError22(`[SixbDuckLake] ${validationError}`);
+        throw new LakeStorageError23(`[SixbDuckLake] ${validationError}`);
       }
       const clonedRow = structuredClone(row);
       if (getDatasetPrimaryKeyColumns3(this.input.dataset) !== null) {
         const primaryKey = encodeDatasetPrimaryKey(this.input.dataset, clonedRow);
         if (this.stagedPrimaryKeys.has(primaryKey) || batchPrimaryKeys.has(primaryKey)) {
-          throw new LakeStorageError22(`[SixbDuckLake] Dataset '${this.input.dataset.id}' ${this.input.mode ?? "snapshot"} source contains duplicate primary key.`);
+          throw new LakeStorageError23(`[SixbDuckLake] Dataset '${this.input.dataset.id}' ${this.input.mode ?? "snapshot"} source contains duplicate primary key.`);
         }
         batchPrimaryKeys.add(primaryKey);
       }
@@ -3457,7 +3922,7 @@ class DuckLakeWriteSession {
   }
   assertOpen() {
     if (this.closed) {
-      throw new LakeStorageError22("[SixbDuckLake] Write session is already closed.");
+      throw new LakeStorageError23("[SixbDuckLake] Write session is already closed.");
     }
   }
   async cleanup() {
@@ -3465,6 +3930,7 @@ class DuckLakeWriteSession {
       return;
     }
     this.cleanedUp = true;
+    this.stagedPrimaryKeys.clear();
     await this.dropStagingTable();
   }
   async dropStagingTable() {
@@ -3490,7 +3956,7 @@ class DuckLakeWriteCoordinator {
     this.connections.assertOpen();
     const definition = await this.datasets.getDataset(input.dataset.id);
     if (!definition) {
-      throw new LakeStorageError23(`[SixbDuckLake] Unknown dataset '${input.dataset.id}'.`);
+      throw new LakeStorageError24(`[SixbDuckLake] Unknown dataset '${input.dataset.id}'.`);
     }
     this.datasets.assertSchema(definition);
     assertUnsequencedDatasetWrite(definition);
@@ -3511,10 +3977,10 @@ class DuckLakeWriteCoordinator {
     this.connections.assertOpen();
     const definition = await this.datasets.getDataset(input.dataset.id);
     if (!definition) {
-      throw new LakeStorageError23(`[SixbDuckLake] Unknown dataset '${input.dataset.id}'.`);
+      throw new LakeStorageError24(`[SixbDuckLake] Unknown dataset '${input.dataset.id}'.`);
     }
     if (getDatasetPrimaryKeyColumns4(definition) === null) {
-      throw new LakeStorageError23(`[SixbDuckLake] Dataset '${definition.id}' must define a primaryKey before it can be merged.`);
+      throw new LakeStorageError24(`[SixbDuckLake] Dataset '${definition.id}' must define a primaryKey before it can be merged.`);
     }
     this.datasets.assertSchema(definition);
     const latestVersion = await this.connections.withAttachedRuntime((runtime) => this.snapshots.getLatestVersionForDefinition(runtime, definition));
@@ -3532,7 +3998,7 @@ class DuckLakeWriteCoordinator {
   async commitWrite(input) {
     const definition = await this.datasets.getDataset(input.write.dataset.id);
     if (!definition) {
-      throw new LakeStorageError23(`[SixbDuckLake] Unknown dataset '${input.write.dataset.id}'.`);
+      throw new LakeStorageError24(`[SixbDuckLake] Unknown dataset '${input.write.dataset.id}'.`);
     }
     const mode = input.write.mode ?? "snapshot";
     assertDatasetWriteMode(mode, "write");
@@ -3553,10 +4019,10 @@ class DuckLakeWriteCoordinator {
   async commitMerge(input) {
     const definition = await this.datasets.getDataset(input.merge.dataset.id);
     if (!definition) {
-      throw new LakeStorageError23(`[SixbDuckLake] Unknown dataset '${input.merge.dataset.id}'.`);
+      throw new LakeStorageError24(`[SixbDuckLake] Unknown dataset '${input.merge.dataset.id}'.`);
     }
     if (getDatasetPrimaryKeyColumns4(definition) === null) {
-      throw new LakeStorageError23(`[SixbDuckLake] Dataset '${definition.id}' must define a primaryKey before it can be merged.`);
+      throw new LakeStorageError24(`[SixbDuckLake] Dataset '${definition.id}' must define a primaryKey before it can be merged.`);
     }
     return retryDatasetMergeCommit(input.merge, input.commit, (rebase) => this.withCommitRuntime(async (runtime) => {
       input.commit?.signal?.throwIfAborted();
@@ -3584,7 +4050,7 @@ class DuckLakeWriteCoordinator {
             validatedPrimaryKeyColumns: context.validatedPrimaryKeyColumns
           });
           if (result.sourceRowCount !== input.changesWritten) {
-            throw new LakeStorageError23(`[SixbDuckLake] Staged merge for dataset '${definition.id}' accepted ${input.changesWritten} change(s), but DuckLake saw ${result.sourceRowCount} source change(s) at commit time.`);
+            throw new LakeStorageError24(`[SixbDuckLake] Staged merge for dataset '${definition.id}' accepted ${input.changesWritten} change(s), but DuckLake saw ${result.sourceRowCount} source change(s) at commit time.`);
           }
           return result;
         }
@@ -3606,7 +4072,7 @@ class DuckLakeWriteCoordinator {
       disableRetries: input.mode === "append" && getDatasetPrimaryKeyColumns4(input.dataset) !== null
     });
     if (result.version === null) {
-      throw new LakeStorageError23(`[SixbDuckLake] No DuckLake changes were committed for dataset '${input.dataset.id}', and no previous version exists.`);
+      throw new LakeStorageError24(`[SixbDuckLake] No DuckLake changes were committed for dataset '${input.dataset.id}', and no previous version exists.`);
     }
     return { ...result.version, outcome: result.outcome };
   }
@@ -3637,10 +4103,9 @@ class DuckLakeWriteCoordinator {
   }
   async commitDatasetVersionUnlocked(input) {
     const previousWriteSnapshotId = await this.lastCommittedSnapshotId(input.runtime);
-    await input.runtime.run("BEGIN TRANSACTION");
     let committed = false;
     try {
-      const latestVersion = await this.latestVersionForCommit(input);
+      const latestVersion = await this.beginVersionTransaction(input);
       if (input.expectedLatestVersionId !== undefined) {
         this.assertExpectedLatestVersion({
           datasetId: input.dataset.id,
@@ -3688,7 +4153,7 @@ class DuckLakeWriteCoordinator {
       if (version) {
         return { outcome: "created", version };
       }
-      throw new LakeStorageError23(`[SixbDuckLake] DuckLake committed snapshot '${ownSnapshotId}' for dataset '${input.dataset.id}', but Sixb could not hydrate it as a dataset version.`);
+      throw new LakeStorageError24(`[SixbDuckLake] DuckLake committed snapshot '${ownSnapshotId}' for dataset '${input.dataset.id}', but Sixb could not hydrate it as a dataset version.`);
     }
     if (!input.changeResult.dataChangeExpected) {
       const version = await this.versionForNoOpCommit(input.runtime, input.dataset, input.allowInitialNoOp ?? false);
@@ -3706,9 +4171,9 @@ class DuckLakeWriteCoordinator {
       };
     }
     if (input.committedWriteSnapshotId === input.previousWriteSnapshotId) {
-      throw new LakeStorageError23(`[SixbDuckLake] DuckLake commit for dataset '${input.dataset.id}' completed without producing a snapshot for this non-empty write.`);
+      throw new LakeStorageError24(`[SixbDuckLake] DuckLake commit for dataset '${input.dataset.id}' completed without producing a snapshot for this non-empty write.`);
     }
-    throw new LakeStorageError23(`[SixbDuckLake] DuckLake commit for dataset '${input.dataset.id}' completed, but Sixb could not find a matching snapshot for this write.`);
+    throw new LakeStorageError24(`[SixbDuckLake] DuckLake commit for dataset '${input.dataset.id}' completed, but Sixb could not find a matching snapshot for this write.`);
   }
   async applyStagedRows(input) {
     const mode = input.write.mode ?? "snapshot";
@@ -3721,7 +4186,7 @@ class DuckLakeWriteCoordinator {
       previousRowCount: input.previousRowCount
     });
     if (result.sourceRowCount !== input.rowsWritten) {
-      throw new LakeStorageError23(`[SixbDuckLake] Staged write for dataset '${input.write.dataset.id}' accepted ${input.rowsWritten} row(s), but DuckLake saw ${result.sourceRowCount} source row(s) at commit time.`);
+      throw new LakeStorageError24(`[SixbDuckLake] Staged write for dataset '${input.write.dataset.id}' accepted ${input.rowsWritten} row(s), but DuckLake saw ${result.sourceRowCount} source row(s) at commit time.`);
     }
     return result;
   }
@@ -3743,7 +4208,7 @@ class DuckLakeWriteCoordinator {
     if (changeResult.dataChangeExpected) {
       return;
     }
-    const latestVersion = knownLatestVersion ?? await this.snapshots.getLatestVersionSummaryForDefinition(input.runtime, input.dataset);
+    const latestVersion = knownLatestVersion === undefined ? await this.snapshots.getLatestVersionSummaryForDefinition(input.runtime, input.dataset) : knownLatestVersion;
     if (latestVersion ? input.mode === "merge" || !hasDatasetInputChanges(latestVersion.inputs, input.inputs) : input.allowInitialNoOp) {
       return;
     }
@@ -3759,18 +4224,39 @@ class DuckLakeWriteCoordinator {
     if (allowInitialNoOp) {
       return null;
     }
-    throw new LakeStorageError23(`[SixbDuckLake] No DuckLake changes were committed for dataset '${definition.id}', and no previous version exists.`);
+    throw new LakeStorageError24(`[SixbDuckLake] No DuckLake changes were committed for dataset '${definition.id}', and no previous version exists.`);
   }
   async rollbackTransaction(runtime) {
     try {
       await runtime.run("ROLLBACK");
     } catch {}
   }
-  async latestVersionForCommit(input) {
-    if (input.expectedLatestVersionId === undefined && input.mode !== "append") {
-      return null;
+  async beginVersionTransaction(input) {
+    if (!isSqliteCatalog(this.options.catalog)) {
+      await input.runtime.run("BEGIN TRANSACTION");
+      if (input.expectedLatestVersionId === undefined && input.mode !== "append") {
+        return;
+      }
+      return this.snapshots.getLatestVersionSummaryForDefinition(input.runtime, input.dataset);
+    }
+    for (let attempt = 0;attempt < 3; attempt++) {
+      input.signal?.throwIfAborted();
+      const snapshotId = await this.currentSnapshotId(input.runtime);
+      const latestVersion = await this.snapshots.getLatestVersionSummaryForDefinition(input.runtime, input.dataset);
+      await input.runtime.run("BEGIN TRANSACTION");
+      if (await this.currentSnapshotId(input.runtime) === snapshotId) {
+        return latestVersion;
+      }
+      await input.runtime.run("ROLLBACK");
     }
-    return this.snapshots.getLatestVersionSummaryForDefinition(input.runtime, input.dataset);
+    throw new LakeConcurrencyError(`[SixbDuckLake] Catalog changed during three write preparations for dataset '${input.dataset.id}'. Retry the write.`);
+  }
+  async currentSnapshotId(runtime) {
+    const [row] = await runtime.query(`SELECT id FROM ${quoteIdentifier(duckLakeAlias(this.options))}.current_snapshot()`);
+    if (row === undefined) {
+      throw new LakeStorageError24("[SixbDuckLake] DuckLake did not return a current snapshot.");
+    }
+    return String(getBigIntLike(row, "id"));
   }
   async lastCommittedSnapshotId(runtime) {
     const [row] = await runtime.query(`SELECT id FROM ${quoteIdentifier(duckLakeAlias(this.options))}.last_committed_snapshot()`);
@@ -3819,6 +4305,9 @@ class DuckLakeWriteCoordinator {
     }
   }
 }
+function isSqliteCatalog(catalog) {
+  return catalog.type === "sqlite" || catalog.type === "custom" && catalog.uri.toLowerCase().startsWith("sqlite:");
+}
 function commitRowCount(input, changeResult, latestVersion) {
   if (input.mode === "append" && input.expectedLatestVersionId === undefined) {
     return { kind: "unknown" };
@@ -3833,7 +4322,7 @@ function commitRowCount(input, changeResult, latestVersion) {
 }
 function assertDuckLakeSnapshotId3(snapshotId) {
   if (!/^\d+$/.test(snapshotId)) {
-    throw new LakeStorageError23(`[SixbDuckLake] Invalid DuckLake snapshot id '${snapshotId}'.`);
+    throw new LakeStorageError24(`[SixbDuckLake] Invalid DuckLake snapshot id '${snapshotId}'.`);
   }
 }
 var localCatalogCommitLocks = new Map;
@@ -3922,6 +4411,9 @@ class DuckLakeStorage {
   async getVersion(datasetId, versionId) {
     return this.snapshotReader.getVersion(datasetId, versionId);
   }
+  async listLatestVersionsSince(input) {
+    return this.snapshotReader.listLatestVersionsSince(input);
+  }
   readRows(input) {
     return this.rows.readRows(input);
   }
@@ -3939,4 +4431,4 @@ export {
   DuckLakeStorage
 };
 
-//# debugId=555594FFA13F16F264756E2164756E21
+//# debugId=99E61447F4C74C9E64756E2164756E21