@sixb/ducklake 0.0.1

package/dist/index.js

@@ -0,0 +1,3112 @@
+// @bun
+// src/internal/ducklake-connection-manager.ts
+import { LakeStorageError as LakeStorageError4 } from "@sixb/core/lake-storage";
+
+// src/internal/catalog-key.ts
+import { resolve } from "path";
+function localCatalogCoordinationKey(options) {
+  switch (options.catalog.type) {
+    case "duckdb":
+    case "sqlite":
+      if (options.catalog.path === ":memory:") {
+        return;
+      }
+      return `${options.catalog.type}:${resolve(options.catalog.path)}`;
+    case "custom":
+      return `custom:${options.catalog.uri}`;
+    case "postgres":
+      return;
+  }
+}
+
+// src/internal/duckdb-runtime.ts
+import {
+  DuckDBInstance
+} from "@duckdb/node-api";
+import { LakeStorageError as LakeStorageError3 } from "@sixb/core/lake-storage";
+
+// src/internal/duckdb-value-converter.ts
+import {
+  DuckDBDecimalValue,
+  DuckDBTypeId,
+  JSDuckDBValueConverter
+} from "@duckdb/node-api";
+import { LakeStorageError } from "@sixb/core/lake-storage";
+var sixbDuckDbValueConverter = (value, type, converter) => {
+  if (value === null) {
+    return null;
+  }
+  if (type.typeId === DuckDBTypeId.DECIMAL) {
+    if (!(value instanceof DuckDBDecimalValue)) {
+      throw new LakeStorageError("[SixbDuckLake] DuckDB returned an invalid DECIMAL value.");
+    }
+    return value.toString();
+  }
+  return JSDuckDBValueConverter(value, type, converter);
+};
+
+// src/internal/sql.ts
+import { LakeStorageError as LakeStorageError2 } from "@sixb/core/lake-storage";
+var DEFAULT_ALIAS = "sixb_lake";
+function duckLakeAlias(options) {
+  return options.alias ?? DEFAULT_ALIAS;
+}
+function duckLakeMetadataCatalog(options) {
+  return `__ducklake_metadata_${duckLakeAlias(options)}`;
+}
+function buildConfigurePostgresMetadataPoolSql(options) {
+  const parameters = [
+    `catalog_name=${quoteSqlString(duckLakeMetadataCatalog(options))}`,
+    ...postgresPoolParameters(options.postgresPool).map(({ name, value }) => `${name}=${value}`)
+  ];
+  return `FROM postgres_configure_pool(${parameters.join(", ")})`;
+}
+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)}`;
+}
+function quoteIdentifier(identifier) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(identifier)) {
+    throw new LakeStorageError2(`[SixbDuckLake] Invalid SQL identifier '${identifier}'.`);
+  }
+  return `"${identifier}"`;
+}
+function quoteSqlString(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+function quoteSqlStringList(values) {
+  return values.map((value) => quoteSqlString(value)).join(", ");
+}
+function qualifiedTableName(options, tableName) {
+  return `${quoteIdentifier(duckLakeAlias(options))}.main.${quoteIdentifier(tableName)}`;
+}
+function catalogUri(catalog) {
+  switch (catalog.type) {
+    case "duckdb":
+      return `ducklake:${catalog.path}`;
+    case "sqlite":
+      return `ducklake:sqlite:${catalog.path}`;
+    case "postgres":
+      return `ducklake:postgres:${postgresConnectionString(catalog)}`;
+    case "custom":
+      return `ducklake:${catalog.uri}`;
+  }
+}
+function postgresConnectionString(catalog) {
+  const parameters = [];
+  const names = new Set;
+  appendPostgresConnectionParameter(parameters, names, "dbname", catalog.database);
+  appendPostgresConnectionParameter(parameters, names, "host", catalog.host);
+  appendPostgresConnectionParameter(parameters, names, "port", catalog.port);
+  appendPostgresConnectionParameter(parameters, names, "user", catalog.user);
+  appendPostgresConnectionParameter(parameters, names, "password", catalog.password);
+  appendPostgresConnectionParameter(parameters, names, "sslmode", catalog.sslMode);
+  appendPostgresConnectionParameter(parameters, names, "application_name", catalog.applicationName);
+  appendPostgresConnectionParameter(parameters, names, "connect_timeout", catalog.connectTimeoutSeconds);
+  for (const [name, value] of Object.entries(catalog.parameters ?? {})) {
+    appendPostgresConnectionParameter(parameters, names, name, value);
+  }
+  return parameters.join(" ");
+}
+function catalogExtensions(catalog) {
+  switch (catalog.type) {
+    case "duckdb":
+      return [];
+    case "sqlite":
+      return ["sqlite"];
+    case "postgres":
+      return ["postgres"];
+    case "custom":
+      return catalog.extensions ?? [];
+  }
+}
+function requiredExtensions(options) {
+  const extensions = new Set(catalogExtensions(options.catalog));
+  for (const extension of storageExtensions(options.dataPath)) {
+    extensions.add(extension);
+  }
+  for (const secret of options.secrets ?? []) {
+    for (const extension of secretExtensions(secret)) {
+      extensions.add(extension);
+    }
+  }
+  return [...extensions];
+}
+function buildCreateSecretSql(secret) {
+  const persistence = secret.persistent ? "PERSISTENT " : "TEMPORARY ";
+  const nameSql = secret.name === undefined ? "" : `${quoteIdentifier(secret.name)} `;
+  return `CREATE OR REPLACE ${persistence}SECRET ${nameSql}(${secretParameters(secret).join(", ")})`;
+}
+function buildAttachSql(options) {
+  const parameters = [];
+  if (options.dataPath !== undefined) {
+    parameters.push(`DATA_PATH ${quoteSqlString(options.dataPath)}`);
+  }
+  parameters.push(`CREATE_IF_NOT_EXISTS ${options.createIfNotExists ?? true}`);
+  if (options.readOnly) {
+    parameters.push("READ_ONLY");
+  }
+  if (options.catalog.type === "postgres" && options.catalog.metadataSchema !== undefined) {
+    parameters.push(`METADATA_SCHEMA ${quoteSqlString(options.catalog.metadataSchema)}`);
+  }
+  if (options.catalog.type === "custom" && options.catalog.metadataParameters !== undefined && Object.keys(options.catalog.metadataParameters).length > 0) {
+    const entries = Object.entries(options.catalog.metadataParameters).map(([key, value]) => `${quoteSqlString(key)}: ${quoteSqlString(value)}`);
+    parameters.push(`METADATA_PARAMETERS MAP {${entries.join(", ")}}`);
+  }
+  return `ATTACH ${quoteSqlString(catalogUri(options.catalog))} AS ${quoteIdentifier(duckLakeAlias(options))} (${parameters.join(", ")})`;
+}
+function storageExtensions(path) {
+  if (path === undefined) {
+    return [];
+  }
+  switch (pathScheme(path)) {
+    case "s3":
+    case "r2":
+    case "gcs":
+    case "gs":
+      return ["httpfs"];
+    case "az":
+    case "azure":
+    case "abfss":
+      return ["azure"];
+    default:
+      return [];
+  }
+}
+function postgresPoolParameters(pool) {
+  const parameters = [
+    { name: "enable_thread_local_cache", value: String(pool?.enableThreadLocalCache ?? false) }
+  ];
+  appendPoolNumber(parameters, "max_connections", pool?.maxConnections);
+  appendPoolNumber(parameters, "wait_timeout_millis", pool?.waitTimeoutMillis);
+  appendPoolNumber(parameters, "max_lifetime_millis", pool?.maxLifetimeMillis);
+  appendPoolNumber(parameters, "idle_timeout_millis", pool?.idleTimeoutMillis);
+  if (pool?.enableReaperThread !== undefined) {
+    parameters.push({ name: "enable_reaper_thread", value: String(pool.enableReaperThread) });
+  }
+  if (pool?.healthCheckQuery !== undefined) {
+    parameters.push({ name: "health_check_query", value: quoteSqlString(pool.healthCheckQuery) });
+  }
+  return parameters;
+}
+function appendPoolNumber(parameters, name, value) {
+  if (value === undefined) {
+    return;
+  }
+  parameters.push({ name, value: String(value) });
+}
+function secretExtensions(secret) {
+  switch (secret.type) {
+    case "s3":
+    case "r2":
+    case "gcs":
+      return ["httpfs"];
+    case "azure":
+      return ["azure"];
+  }
+}
+function secretParameters(secret) {
+  switch (secret.type) {
+    case "s3":
+      return withCommonSecretParameters(secret, [
+        "TYPE s3",
+        ...s3ApiSecretParameters(secret),
+        ...optionalStringParameter("KMS_KEY_ID", secret.kmsKeyId),
+        ...optionalBooleanParameter("REQUESTER_PAYS", secret.requesterPays)
+      ]);
+    case "r2":
+      return withCommonSecretParameters(secret, [
+        "TYPE r2",
+        ...s3ApiSecretParameters(secret),
+        ...optionalStringParameter("ACCOUNT_ID", secret.accountId)
+      ]);
+    case "gcs":
+      return withCommonSecretParameters(secret, ["TYPE gcs", ...s3ApiSecretParameters(secret)]);
+    case "azure":
+      return withCommonSecretParameters(secret, azureSecretParameters(secret));
+  }
+}
+function s3ApiSecretParameters(secret) {
+  return [
+    ...optionalIdentifierParameter("PROVIDER", secret.provider),
+    ...optionalStringParameter("KEY_ID", secret.keyId),
+    ...optionalStringParameter("SECRET", secret.secret),
+    ...optionalStringParameter("SESSION_TOKEN", secret.sessionToken),
+    ...optionalStringParameter("REGION", secret.region),
+    ...optionalStringParameter("ENDPOINT", secret.endpoint),
+    ...optionalStringParameter("URL_STYLE", secret.urlStyle),
+    ...optionalBooleanParameter("USE_SSL", secret.useSsl),
+    ...optionalBooleanParameter("VERIFY_SSL", secret.verifySsl),
+    ...optionalStringParameter("CHAIN", secret.chain),
+    ...optionalStringParameter("PROFILE", secret.profile)
+  ];
+}
+function azureSecretParameters(secret) {
+  if (secret.tenantId !== undefined || secret.clientId !== undefined || secret.clientSecret !== undefined) {
+    return [
+      "TYPE azure",
+      "PROVIDER service_principal",
+      ...optionalStringParameter("TENANT_ID", secret.tenantId),
+      ...optionalStringParameter("CLIENT_ID", secret.clientId),
+      ...optionalStringParameter("CLIENT_SECRET", secret.clientSecret),
+      ...optionalStringParameter("ACCOUNT_NAME", secret.accountName)
+    ];
+  }
+  const connectionString = secret.connectionString ?? (secret.accountName !== undefined && secret.accountKey !== undefined ? `DefaultEndpointsProtocol=https;AccountName=${secret.accountName};AccountKey=${secret.accountKey};EndpointSuffix=core.windows.net` : undefined);
+  if (connectionString !== undefined) {
+    return ["TYPE azure", ...optionalStringParameter("CONNECTION_STRING", connectionString)];
+  }
+  return [
+    "TYPE azure",
+    "PROVIDER credential_chain",
+    ...optionalStringParameter("ACCOUNT_NAME", secret.accountName)
+  ];
+}
+function withCommonSecretParameters(secret, parameters) {
+  return [...parameters, ...optionalStringParameter("SCOPE", secret.scope)];
+}
+function optionalStringParameter(name, value) {
+  return value === undefined ? [] : [`${name} ${quoteSqlString(value)}`];
+}
+function optionalBooleanParameter(name, value) {
+  return value === undefined ? [] : [`${name} ${value}`];
+}
+function optionalIdentifierParameter(name, value) {
+  if (value === undefined) {
+    return [];
+  }
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value)) {
+    throw new LakeStorageError2(`[SixbDuckLake] Invalid SQL identifier '${value}'.`);
+  }
+  return [`${name} ${value}`];
+}
+function appendPostgresConnectionParameter(parameters, names, name, value) {
+  if (value === undefined) {
+    return;
+  }
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+    throw new LakeStorageError2(`[SixbDuckLake] Invalid PostgreSQL catalog parameter '${name}'.`);
+  }
+  const normalizedName = name.toLowerCase();
+  if (names.has(normalizedName)) {
+    throw new LakeStorageError2(`[SixbDuckLake] Duplicate PostgreSQL catalog parameter '${name}'.`);
+  }
+  names.add(normalizedName);
+  parameters.push(`${name}=${quotePostgresConnectionValue(String(value))}`);
+}
+function quotePostgresConnectionValue(value) {
+  return `'${value.replaceAll("\\", "\\\\").replaceAll("'", "\\'")}'`;
+}
+function pathScheme(path) {
+  const match = /^([a-z][a-z0-9+.-]*):\/\//i.exec(path);
+  return match ? match[1].toLowerCase() : null;
+}
+
+// src/internal/duckdb-runtime.ts
+class NodeDuckDbRuntime {
+  instance;
+  connection;
+  closing = false;
+  closed = false;
+  operations = Promise.resolve();
+  constructor(instance, connection) {
+    this.instance = instance;
+    this.connection = connection;
+  }
+  async run(sql, values) {
+    await this.enqueue(async () => {
+      await this.connection.run(sql, values === undefined ? undefined : [...values]);
+    });
+  }
+  async runStatements(statements) {
+    await this.enqueue(async () => {
+      for (const sql of statements) {
+        await this.connection.run(sql);
+      }
+    });
+  }
+  async query(sql, values) {
+    return this.enqueue(async () => {
+      const reader = await this.connection.runAndReadAll(sql, values === undefined ? undefined : [...values]);
+      return reader.convertRowObjects(sixbDuckDbValueConverter);
+    });
+  }
+  async* streamRows(sql, values) {
+    this.assertAcceptingOperations();
+    let releaseOperation;
+    const operationFinished = new Promise((resolve2) => {
+      releaseOperation = resolve2;
+    });
+    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);
+      try {
+        return await useAppender(new NodeDuckDbAppenderAdapter(appender));
+      } finally {
+        appender.closeSync();
+      }
+    });
+  }
+  async withExclusive(useRuntime) {
+    return this.enqueue(async () => {
+      return useRuntime(new NodeDuckDbExclusiveRuntime(this.connection));
+    });
+  }
+  async close() {
+    if (this.closed) {
+      return;
+    }
+    this.closing = true;
+    await this.operations.catch(() => {});
+    this.closed = true;
+    this.connection.closeSync();
+    this.instance.closeSync();
+  }
+  enqueue(operation) {
+    this.assertAcceptingOperations();
+    const result = this.operations.then(async () => {
+      this.assertNotClosed();
+      return operation();
+    });
+    this.operations = result.then(() => {}, () => {});
+    return result;
+  }
+  assertAcceptingOperations() {
+    if (this.closing || this.closed) {
+      throw new LakeStorageError3("[SixbDuckLake] DuckDB runtime is closed.");
+    }
+  }
+  assertNotClosed() {
+    if (this.closed) {
+      throw new LakeStorageError3("[SixbDuckLake] DuckDB runtime is closed.");
+    }
+  }
+}
+
+class NodeDuckDbExclusiveRuntime {
+  connection;
+  constructor(connection) {
+    this.connection = connection;
+  }
+  async run(sql, values) {
+    await this.connection.run(sql, values === undefined ? undefined : [...values]);
+  }
+  async runStatements(statements) {
+    for (const sql of statements) {
+      await this.connection.run(sql);
+    }
+  }
+  async query(sql, values) {
+    const reader = await this.connection.runAndReadAll(sql, values === undefined ? undefined : [...values]);
+    return reader.convertRowObjects(sixbDuckDbValueConverter);
+  }
+  async withAppender(tableName, useAppender) {
+    const appender = await this.connection.createAppender(tableName);
+    try {
+      return await useAppender(new NodeDuckDbAppenderAdapter(appender));
+    } finally {
+      appender.closeSync();
+    }
+  }
+}
+
+class NodeDuckDbAppenderAdapter {
+  appender;
+  constructor(appender) {
+    this.appender = appender;
+  }
+  appendNull() {
+    this.appender.appendNull();
+  }
+  appendBoolean(value) {
+    this.appender.appendBoolean(value);
+  }
+  appendVarchar(value) {
+    this.appender.appendVarchar(value);
+  }
+  appendBigInt(value) {
+    this.appender.appendBigInt(value);
+  }
+  appendDouble(value) {
+    this.appender.appendDouble(value);
+  }
+  appendStruct(value) {
+    this.appender.appendStruct(value);
+  }
+  endRow() {
+    this.appender.endRow();
+  }
+}
+async function createDuckDbRuntime(options = {}) {
+  const instance = await DuckDBInstance.create(options.path ?? ":memory:", options.config ?? {});
+  return new NodeDuckDbRuntime(instance, await instance.connect());
+}
+async function installDuckLakeExtensions(runtime, options) {
+  await runtime.run("INSTALL ducklake");
+  for (const extension of requiredExtensions(options)) {
+    await runtime.run(`INSTALL ${quoteIdentifier(extension)}`);
+  }
+}
+async function setupDuckLake(runtime, options, setupOptions = {}) {
+  if (setupOptions.installExtensions ?? true) {
+    await installDuckLakeExtensions(runtime, options);
+  }
+  await runtime.run("LOAD ducklake");
+  for (const extension of requiredExtensions(options)) {
+    await runtime.run(`LOAD ${quoteIdentifier(extension)}`);
+  }
+  for (const sql of options.setupSql ?? []) {
+    await runtime.run(sql);
+  }
+  if (options.catalog.type === "postgres") {
+    await runtime.runStatements(buildSetPostgresPoolSql(options));
+  }
+  for (const secret of options.secrets ?? []) {
+    await runtime.run(buildCreateSecretSql(secret));
+  }
+  if (setupOptions.attach ?? true) {
+    await runtime.run(buildAttachSql(options));
+    if (options.catalog.type === "postgres") {
+      await runtime.run(buildConfigurePostgresMetadataPoolSql(options));
+    }
+  }
+}
+
+// src/internal/ducklake-connection-manager.ts
+class DuckLakeConnectionManager {
+  options;
+  runtimePromise;
+  installExtensionsPromise;
+  attachPromise;
+  refreshPromise;
+  localAttachmentLock = Promise.resolve();
+  observedLocalCatalogGeneration;
+  attached = false;
+  closed = false;
+  runtimePoisoned = false;
+  constructor(options) {
+    this.options = options;
+    this.observedLocalCatalogGeneration = currentLocalCatalogGeneration(options);
+  }
+  assertOpen() {
+    if (this.closed) {
+      throw new LakeStorageError4("[SixbDuckLake] DuckLakeStorage is closed.");
+    }
+  }
+  async runtime() {
+    this.assertOpen();
+    if (this.runtimePromise === undefined) {
+      const runtimePromise = this.createRuntime().catch((error) => {
+        if (this.runtimePromise === runtimePromise) {
+          this.runtimePromise = undefined;
+        }
+        throw error;
+      });
+      this.runtimePromise = runtimePromise;
+    }
+    return this.runtimePromise;
+  }
+  async attachedRuntime() {
+    const runtime = await this.runtime();
+    await this.ensureAttached(runtime);
+    return runtime;
+  }
+  async withAttachedRuntime(run) {
+    const lease = await this.acquireAttachedRuntime();
+    try {
+      return await run(lease.runtime);
+    } finally {
+      await lease.release();
+    }
+  }
+  async acquireAttachedRuntime() {
+    this.assertOpen();
+    const releaseLock = await this.acquireLocalAttachmentLock();
+    let released = false;
+    const release = async () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      try {
+        if (this.runtimePoisoned) {
+          this.runtimePoisoned = false;
+          await this.discardRuntimeUnlocked();
+        } else {
+          await this.detachDuckDbCatalogAfterLease();
+        }
+      } finally {
+        releaseLock();
+      }
+    };
+    try {
+      await this.refreshForExternalChangesUnlocked();
+      const runtime = await this.attachedRuntime();
+      return { runtime, release };
+    } catch (error) {
+      await release();
+      throw error;
+    }
+  }
+  async withExclusiveAttached(run) {
+    const lease = await this.acquireAttachedRuntime();
+    try {
+      return await lease.runtime.withExclusive(run);
+    } finally {
+      await lease.release();
+    }
+  }
+  async stagingRuntime() {
+    const runtime = await this.runtime();
+    if (this.options.catalog.type !== "postgres") {
+      await this.detachRuntime();
+    }
+    return runtime;
+  }
+  async createRuntime() {
+    this.assertOpen();
+    const runtime = await createDuckDbRuntime(this.options.duckdb);
+    try {
+      await this.ensureExtensionsInstalled(runtime);
+      await setupDuckLake(runtime, this.options, {
+        attach: false,
+        installExtensions: false
+      });
+      await runtime.run("SET preserve_insertion_order = true");
+      return runtime;
+    } catch (error) {
+      await this.closeRuntime(runtime, { detach: false });
+      throw error;
+    }
+  }
+  async resetRuntime() {
+    const releaseLock = await this.acquireLocalAttachmentLock();
+    try {
+      await this.resetRuntimeUnlocked();
+    } finally {
+      releaseLock();
+    }
+  }
+  async resetRuntimeUnlocked() {
+    const runtimePromise = this.runtimePromise;
+    if (runtimePromise === undefined) {
+      return;
+    }
+    if (this.attachPromise !== undefined) {
+      await this.attachPromise;
+    }
+    if (!this.attached) {
+      return;
+    }
+    let refreshedPromise;
+    refreshedPromise = runtimePromise.then(async (runtime) => {
+      try {
+        await this.refreshAttachedRuntime(runtime);
+        this.attached = true;
+        return runtime;
+      } catch (error) {
+        this.attached = false;
+        await this.closeRuntime(runtime, { detach: false });
+        throw error;
+      }
+    }).catch((error) => {
+      if (this.runtimePromise === refreshedPromise) {
+        this.runtimePromise = undefined;
+      }
+      throw error;
+    });
+    this.attached = false;
+    this.runtimePromise = refreshedPromise;
+    await refreshedPromise;
+  }
+  async refreshForExternalChanges() {
+    if (this.options.catalog.type === "postgres") {
+      return;
+    }
+    if (!this.needsLocalCatalogRefresh()) {
+      return;
+    }
+    if (this.refreshPromise === undefined) {
+      let refreshPromise;
+      refreshPromise = this.withLocalAttachmentLock(() => this.refreshForExternalChangesUnlocked()).finally(() => {
+        if (this.refreshPromise === refreshPromise) {
+          this.refreshPromise = undefined;
+        }
+      });
+      this.refreshPromise = refreshPromise;
+    }
+    await this.refreshPromise;
+  }
+  markLocalCatalogChanged() {
+    if (this.options.catalog.type === "postgres") {
+      return;
+    }
+    this.observedLocalCatalogGeneration = incrementLocalCatalogGeneration(this.options);
+  }
+  async detachLocalCatalogAfterCommit(runtime) {
+    if (this.options.catalog.type === "postgres") {
+      return;
+    }
+    try {
+      await runtime.run(`DETACH ${quoteIdentifier(duckLakeAlias(this.options))}`);
+      this.attached = false;
+    } catch {} finally {
+      this.markLocalCatalogChanged();
+    }
+  }
+  async refreshForExternalChangesUnlocked() {
+    const generation = currentLocalCatalogGeneration(this.options);
+    if (this.observedLocalCatalogGeneration === generation) {
+      return;
+    }
+    await this.resetRuntimeUnlocked();
+    this.observedLocalCatalogGeneration = generation;
+  }
+  needsLocalCatalogRefresh() {
+    return this.observedLocalCatalogGeneration !== currentLocalCatalogGeneration(this.options);
+  }
+  async close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    const runtimePromise = this.runtimePromise;
+    this.runtimePromise = undefined;
+    await this.closeRuntimePromise(runtimePromise, {
+      detach: this.attached && this.options.catalog.type !== "postgres"
+    });
+    this.attached = false;
+  }
+  async ensureAttached(runtime) {
+    this.assertOpen();
+    if (this.attached) {
+      return;
+    }
+    if (this.attachPromise === undefined) {
+      let attachPromise;
+      attachPromise = this.attachRuntime(runtime).then(() => {
+        this.attached = true;
+      }).catch(async (error) => {
+        if (this.attachPromise === attachPromise) {
+          this.runtimePromise = undefined;
+          this.attached = false;
+        }
+        await this.closeRuntime(runtime, { detach: false });
+        throw error;
+      }).finally(() => {
+        if (this.attachPromise === attachPromise) {
+          this.attachPromise = undefined;
+        }
+      });
+      this.attachPromise = attachPromise;
+    }
+    await this.attachPromise;
+  }
+  async ensureExtensionsInstalled(runtime) {
+    if (this.installExtensionsPromise === undefined) {
+      const installExtensionsPromise = installDuckLakeExtensions(runtime, this.options).catch((error) => {
+        if (this.installExtensionsPromise === installExtensionsPromise) {
+          this.installExtensionsPromise = undefined;
+        }
+        throw error;
+      });
+      this.installExtensionsPromise = installExtensionsPromise;
+    }
+    await this.installExtensionsPromise;
+  }
+  async attachRuntime(runtime) {
+    await runtime.runStatements([
+      buildAttachSql(this.options),
+      ...this.options.catalog.type === "postgres" ? [buildConfigurePostgresMetadataPoolSql(this.options)] : []
+    ]);
+  }
+  async refreshAttachedRuntime(runtime) {
+    await runtime.runStatements([
+      `DETACH ${quoteIdentifier(duckLakeAlias(this.options))}`,
+      buildAttachSql(this.options),
+      ...this.options.catalog.type === "postgres" ? [buildConfigurePostgresMetadataPoolSql(this.options)] : []
+    ]);
+  }
+  async detachRuntime() {
+    await this.withLocalAttachmentLock(() => this.detachRuntimeUnlocked());
+  }
+  poisonRuntime() {
+    this.runtimePoisoned = true;
+  }
+  async detachDuckDbCatalogAfterLease() {
+    if (this.options.catalog.type !== "duckdb" || !this.attached) {
+      return;
+    }
+    try {
+      await this.detachRuntimeUnlocked();
+    } catch {
+      await this.discardRuntimeUnlocked();
+    }
+  }
+  async discardRuntimeUnlocked() {
+    const runtimePromise = this.runtimePromise;
+    this.runtimePromise = undefined;
+    this.attached = false;
+    await this.closeRuntimePromise(runtimePromise, { detach: false }).catch(() => {});
+  }
+  async detachRuntimeUnlocked() {
+    if (this.attachPromise !== undefined) {
+      await this.attachPromise;
+    }
+    if (!this.attached) {
+      return;
+    }
+    const runtime = await this.runtime();
+    await runtime.run(`DETACH ${quoteIdentifier(duckLakeAlias(this.options))}`);
+    this.attached = false;
+  }
+  async withLocalAttachmentLock(run) {
+    const releaseLock = await this.acquireLocalAttachmentLock();
+    try {
+      return await run();
+    } finally {
+      releaseLock();
+    }
+  }
+  async acquireLocalAttachmentLock() {
+    if (this.options.catalog.type === "postgres") {
+      return () => {};
+    }
+    const previous = this.localAttachmentLock.catch(() => {});
+    let release;
+    const current = new Promise((resolve2) => {
+      release = resolve2;
+    });
+    this.localAttachmentLock = previous.then(() => current);
+    await previous;
+    let released = false;
+    return () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      release();
+    };
+  }
+  async closeRuntimePromise(runtimePromise, options) {
+    if (runtimePromise === undefined) {
+      return;
+    }
+    let runtime;
+    try {
+      runtime = await runtimePromise;
+    } catch {
+      return;
+    }
+    await this.closeRuntime(runtime, options);
+  }
+  async closeRuntime(runtime, options) {
+    if (options.detach) {
+      try {
+        await runtime.run(`DETACH ${quoteIdentifier(duckLakeAlias(this.options))}`);
+      } catch {}
+    }
+    await runtime.close();
+  }
+}
+var localCatalogGenerations = new Map;
+function currentLocalCatalogGeneration(options) {
+  const key = localCatalogCoordinationKey(options);
+  return key === undefined ? 0 : localCatalogGenerations.get(key) ?? 0;
+}
+function incrementLocalCatalogGeneration(options) {
+  const key = localCatalogCoordinationKey(options);
+  if (key === undefined) {
+    return 0;
+  }
+  const nextGeneration = (localCatalogGenerations.get(key) ?? 0) + 1;
+  localCatalogGenerations.set(key, nextGeneration);
+  return nextGeneration;
+}
+
+// src/internal/ducklake-dataset-catalog.ts
+import { randomUUID } from "crypto";
+import { LakeStorageError as LakeStorageError11, planDatasetDefinitionUpdate } from "@sixb/core/lake-storage";
+
+// src/internal/duckdb-row.ts
+import { LakeStorageError as LakeStorageError5 } from "@sixb/core/lake-storage";
+function getString(row, key) {
+  const value = row[key];
+  if (typeof value !== "string") {
+    throw new LakeStorageError5(`[SixbDuckLake] Expected DuckDB column '${key}' to be a string, got ${typeof value}.`);
+  }
+  return value;
+}
+function getOptionalString(row, key) {
+  const value = row[key];
+  if (value === null || value === undefined) {
+    return;
+  }
+  if (typeof value !== "string") {
+    throw new LakeStorageError5(`[SixbDuckLake] Expected DuckDB column '${key}' to be a string, got ${typeof value}.`);
+  }
+  return value;
+}
+function getBoolean(row, key) {
+  const value = row[key];
+  if (typeof value !== "boolean") {
+    throw new LakeStorageError5(`[SixbDuckLake] Expected DuckDB column '${key}' to be a boolean, got ${typeof value}.`);
+  }
+  return value;
+}
+function getBigIntLike(row, key) {
+  const value = row[key];
+  if (typeof value === "bigint") {
+    return value;
+  }
+  if (typeof value === "number" && Number.isInteger(value)) {
+    return BigInt(value);
+  }
+  if (typeof value === "string" && /^-?\d+$/.test(value)) {
+    return BigInt(value);
+  }
+  throw new LakeStorageError5(`[SixbDuckLake] Expected DuckDB column '${key}' to be an integer, got ${typeof value}.`);
+}
+function getOptionalBigIntLike(row, key) {
+  const value = row[key];
+  if (value === null || value === undefined) {
+    return;
+  }
+  return getBigIntLike(row, key);
+}
+function getDate(row, key) {
+  const value = row[key];
+  if (value instanceof Date) {
+    return value;
+  }
+  if (typeof value === "string") {
+    return new Date(value);
+  }
+  throw new LakeStorageError5(`[SixbDuckLake] Expected DuckDB column '${key}' to be a date, got ${typeof value}.`);
+}
+
+// src/internal/ducklake-catalog-schema.ts
+import { LakeStorageError as LakeStorageError8 } from "@sixb/core/lake-storage";
+
+// src/internal/schema.ts
+import { LakeStorageError as LakeStorageError7 } from "@sixb/core/lake-storage";
+
+// src/internal/duckdb-column-types.ts
+function normalizeDuckDbTypeSql(typeSql) {
+  return typeSql.trim().toUpperCase().replace(/\s+/g, " ").replace(/\s*([(),])\s*/g, "$1");
+}
+function defineDuckDbColumnType(sql, aliases = []) {
+  const acceptedTypes = new Set([sql, ...aliases].map(normalizeDuckDbTypeSql));
+  return {
+    sql,
+    matches: (typeSql) => acceptedTypes.has(normalizeDuckDbTypeSql(typeSql))
+  };
+}
+function defineDuckDbDecimalType(precision, scale) {
+  return {
+    ...defineDuckDbColumnType(`DECIMAL(${precision}, ${scale})`),
+    precision,
+    scale
+  };
+}
+var DUCKDB_COLUMN_TYPES = {
+  string: defineDuckDbColumnType("VARCHAR"),
+  boolean: defineDuckDbColumnType("BOOLEAN"),
+  int64: defineDuckDbColumnType("BIGINT", ["INT64"]),
+  float64: defineDuckDbColumnType("DOUBLE", ["FLOAT64"]),
+  decimal: defineDuckDbDecimalType(38, 9),
+  date: defineDuckDbColumnType("DATE"),
+  timestamp: defineDuckDbColumnType("TIMESTAMPTZ", ["TIMESTAMP WITH TIME ZONE"]),
+  json: defineDuckDbColumnType("JSON"),
+  fileRef: defineDuckDbColumnType("STRUCT(blobId VARCHAR, digest VARCHAR, sizeBytes BIGINT, fileName VARCHAR, mediaType VARCHAR, logicalPath VARCHAR)")
+};
+function findDatasetColumnTypeForDuckDbSql(typeSql) {
+  for (const type of Object.keys(DUCKDB_COLUMN_TYPES)) {
+    if (DUCKDB_COLUMN_TYPES[type].matches(typeSql)) {
+      return type;
+    }
+  }
+  return;
+}
+
+// src/internal/duckdb-decimal.ts
+import { normalizeDecimalValue } from "@sixb/core";
+import { LakeStorageError as LakeStorageError6 } from "@sixb/core/lake-storage";
+var decimalType = DUCKDB_COLUMN_TYPES.decimal;
+var maxIntegerDigits = decimalType.precision - decimalType.scale;
+function normalizeDuckDbDecimalValue(value, columnName) {
+  if (typeof value !== "string") {
+    throw new LakeStorageError6(`[SixbDuckLake] Decimal column '${columnName}' must be an exact decimal string.`);
+  }
+  let normalized;
+  try {
+    normalized = normalizeDecimalValue(value);
+  } catch {
+    throw new LakeStorageError6(`[SixbDuckLake] Decimal column '${columnName}' must be an exact decimal string.`);
+  }
+  const unsigned = normalized.startsWith("-") ? normalized.slice(1) : normalized;
+  const [integer, fraction = ""] = unsigned.split(".");
+  if (integer.length > maxIntegerDigits || fraction.length > decimalType.scale) {
+    throw new LakeStorageError6(`[SixbDuckLake] Decimal column '${columnName}' cannot be represented exactly as ${decimalType.sql}; expected at most ${maxIntegerDigits} integer digits and ${decimalType.scale} fractional digits.`);
+  }
+  return normalized;
+}
+
+// src/internal/schema.ts
+function datasetColumnTypeToDuckDbSql(type) {
+  return DUCKDB_COLUMN_TYPES[type].sql;
+}
+function duckDbTypeToDatasetColumnType(typeSql) {
+  const type = findDatasetColumnTypeForDuckDbSql(typeSql);
+  if (type) {
+    return type;
+  }
+  throw new LakeStorageError7(`[SixbDuckLake] DuckDB column type '${typeSql}' cannot be mapped to a Sixb dataset column type.`);
+}
+function datasetColumnToDuckDbSql(column) {
+  const nullableSql = column.nullable ? "" : " NOT NULL";
+  return `${quoteIdentifier(column.name)} ${datasetColumnTypeToDuckDbSql(column.type)}${nullableSql}`;
+}
+function datasetSchemaToDuckDbColumnsSql(schema) {
+  return schema.columns.map((column) => datasetColumnToDuckDbSql(column)).join(", ");
+}
+function datasetSchemaColumnNamesSql(schema) {
+  return schema.columns.map((column) => quoteIdentifier(column.name)).join(", ");
+}
+function normalizeReadValue(value, column) {
+  if (value === null || value === undefined) {
+    return null;
+  }
+  switch (column.type) {
+    case "int64":
+      return typeof value === "bigint" ? value.toString() : value;
+    case "decimal":
+      return normalizeDuckDbDecimalValue(value, column.name);
+    case "date":
+      return value instanceof Date ? value.toISOString().slice(0, 10) : String(value);
+    case "timestamp":
+      return value instanceof Date ? value.toISOString() : String(value);
+    case "json":
+      return typeof value === "string" ? JSON.parse(value) : value;
+    case "fileRef":
+      return normalizeFileRef(value);
+    default:
+      return value;
+  }
+}
+function normalizeFileRef(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new LakeStorageError7("[SixbDuckLake] DuckDB fileRef value must be a struct.");
+  }
+  const record = value;
+  return {
+    blobId: getStringField(record, "blobId"),
+    digest: getStringField(record, "digest"),
+    sizeBytes: getIntegerField(record, "sizeBytes"),
+    fileName: getOptionalStringField(record, "fileName"),
+    mediaType: getOptionalStringField(record, "mediaType"),
+    logicalPath: getOptionalStringField(record, "logicalPath")
+  };
+}
+function getStringField(record, key) {
+  const value = record[key];
+  if (typeof value !== "string") {
+    throw new LakeStorageError7(`[SixbDuckLake] DuckDB fileRef field '${key}' must be a string.`);
+  }
+  return value;
+}
+function getOptionalStringField(record, key) {
+  const value = record[key];
+  if (value === null || value === undefined) {
+    return;
+  }
+  if (typeof value !== "string") {
+    throw new LakeStorageError7(`[SixbDuckLake] DuckDB fileRef field '${key}' must be a string.`);
+  }
+  return value;
+}
+function getIntegerField(record, key) {
+  const value = record[key];
+  if (typeof value === "number" && Number.isInteger(value)) {
+    return value;
+  }
+  if (typeof value === "bigint") {
+    return Number(value);
+  }
+  throw new LakeStorageError7(`[SixbDuckLake] DuckDB fileRef field '${key}' must be an integer.`);
+}
+
+// src/internal/ducklake-catalog-schema.ts
+var FILE_REF_STRUCT_CHILDREN = [
+  { name: "blobId", type: "string" },
+  { name: "digest", type: "string" },
+  { name: "sizeBytes", type: "int64" },
+  { name: "fileName", type: "string" },
+  { name: "mediaType", type: "string" },
+  { name: "logicalPath", type: "string" }
+];
+function duckLakeCatalogColumnsToDatasetSchema(tableName, rows) {
+  const childrenByParentId = new Map;
+  const topLevelColumns = [];
+  for (const row of rows) {
+    if (row.parentColumnId === undefined) {
+      topLevelColumns.push(row);
+      continue;
+    }
+    const children = childrenByParentId.get(row.parentColumnId) ?? [];
+    children.push(row);
+    childrenByParentId.set(row.parentColumnId, children);
+  }
+  return {
+    columns: topLevelColumns.sort(compareDuckLakeCatalogColumnOrder).map((column) => duckLakeCatalogColumnToDefinition(tableName, column, childrenByParentId))
+  };
+}
+function duckLakeCatalogColumnToDefinition(tableName, column, childrenByParentId) {
+  const children = [...childrenByParentId.get(column.columnId) ?? []].sort(compareDuckLakeCatalogColumnOrder);
+  return {
+    name: column.columnName,
+    type: duckLakeCatalogColumnTypeToDatasetType(tableName, column, children),
+    ...column.nullsAllowed ? { nullable: true } : {}
+  };
+}
+function duckLakeCatalogColumnTypeToDatasetType(tableName, column, children) {
+  if (children.length === 0 && column.columnType.toLowerCase() !== "struct") {
+    return duckDbTypeToDatasetColumnType(column.columnType);
+  }
+  if (isFileRefStruct(children)) {
+    return "fileRef";
+  }
+  throw new LakeStorageError8(`[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);
+}
+function isFileRefStruct(children) {
+  if (children.length !== FILE_REF_STRUCT_CHILDREN.length) {
+    return false;
+  }
+  return FILE_REF_STRUCT_CHILDREN.every((expected, index) => {
+    const child = children[index];
+    return child !== undefined && child.columnName === expected.name && duckDbTypeToDatasetColumnType(child.columnType) === expected.type;
+  });
+}
+function formatDuckLakeCatalogColumnType(column, children) {
+  if (children.length === 0) {
+    return column.columnType;
+  }
+  return `STRUCT(${children.map((child) => `${child.columnName} ${child.columnType}`).join(", ")})`;
+}
+
+// src/internal/ducklake-current-dataset-definitions.ts
+import { LakeStorageError as LakeStorageError10 } from "@sixb/core/lake-storage";
+
+// src/internal/names.ts
+import { LakeStorageError as LakeStorageError9 } from "@sixb/core/lake-storage";
+var DATASET_TABLE_PREFIX = "sixb__ds__";
+var textEncoder = new TextEncoder;
+var textDecoder = new TextDecoder("utf-8", { fatal: true });
+function isInlineByte(byte) {
+  return byte >= 97 && byte <= 122 || byte >= 48 && byte <= 57;
+}
+function isHexPair(value) {
+  return /^[0-9a-f]{2}$/.test(value);
+}
+function encodeDatasetId(datasetId) {
+  if (datasetId.trim().length === 0) {
+    throw new LakeStorageError9("[SixbDuckLake] Dataset id must not be empty.");
+  }
+  let encoded = "";
+  for (const byte of textEncoder.encode(datasetId)) {
+    if (isInlineByte(byte)) {
+      encoded += String.fromCharCode(byte);
+    } else if (byte === 46) {
+      encoded += "__";
+    } else {
+      encoded += `_${byte.toString(16).padStart(2, "0")}`;
+    }
+  }
+  return encoded;
+}
+function decodeDatasetId(encoded) {
+  if (encoded.length === 0) {
+    return null;
+  }
+  const bytes = [];
+  let index = 0;
+  while (index < encoded.length) {
+    const char = encoded[index];
+    const byte = char.charCodeAt(0);
+    if (isInlineByte(byte)) {
+      bytes.push(byte);
+      index += 1;
+      continue;
+    }
+    if (char !== "_") {
+      return null;
+    }
+    if (encoded[index + 1] === "_") {
+      bytes.push(46);
+      index += 2;
+      continue;
+    }
+    const hex = encoded.slice(index + 1, index + 3);
+    if (!isHexPair(hex)) {
+      return null;
+    }
+    bytes.push(Number.parseInt(hex, 16));
+    index += 3;
+  }
+  try {
+    return textDecoder.decode(new Uint8Array(bytes));
+  } catch {
+    return null;
+  }
+}
+function encodeDatasetTableName(datasetId) {
+  return `${DATASET_TABLE_PREFIX}${encodeDatasetId(datasetId)}`;
+}
+function decodeDatasetTableName(tableName) {
+  if (!tableName.startsWith(DATASET_TABLE_PREFIX)) {
+    return null;
+  }
+  return decodeDatasetId(tableName.slice(DATASET_TABLE_PREFIX.length));
+}
+
+// src/internal/ducklake-current-dataset-definitions.ts
+async function readCurrentDatasetDefinitions(input) {
+  if (input.datasetIds?.length === 0) {
+    return new Map;
+  }
+  const tables = await readCurrentDatasetTables(input, input.datasetIds);
+  if (tables.length === 0) {
+    return new Map;
+  }
+  const tableNames = tables.map((table) => table.tableName);
+  const columnsByTableName = groupColumnsByTableName(await readCurrentDatasetColumns(input, tableNames));
+  const partitionByTableName = groupPartitionsByTableName(await readCurrentDatasetPartitions(input, tableNames));
+  const definitions = new Map;
+  for (const table of tables) {
+    const partitionBy = partitionByTableName.get(table.tableName) ?? [];
+    definitions.set(table.datasetId, {
+      kind: "dataset",
+      id: table.datasetId,
+      schema: duckLakeCatalogColumnsToDatasetSchema(table.tableName, columnsByTableName.get(table.tableName) ?? []),
+      ...partitionBy.length > 0 ? { partitionBy } : {},
+      ...table.comment !== undefined ? { description: table.comment } : {}
+    });
+  }
+  return definitions;
+}
+async function readCurrentDatasetTables(input, datasetIds) {
+  if (datasetIds !== undefined && datasetIds.length === 0) {
+    return [];
+  }
+  const tableNameFilter = datasetIds === undefined ? "" : `AND table_name IN (${quoteSqlStringList([...new Set(datasetIds)].map((datasetId) => encodeDatasetTableName(datasetId)))})`;
+  const rows = await input.runtime.query(`SELECT table_name, comment FROM duckdb_tables() WHERE database_name = ${quoteSqlString(duckLakeAlias(input.options))} AND schema_name = 'main' ${tableNameFilter} AND NOT internal ORDER BY table_name`);
+  const tables = [];
+  for (const row of rows) {
+    const tableName = getString(row, "table_name");
+    const datasetId = decodeDatasetTableName(tableName);
+    if (datasetId === null) {
+      continue;
+    }
+    tables.push({
+      datasetId,
+      tableName,
+      comment: getOptionalString(row, "comment")
+    });
+  }
+  return tables;
+}
+async function readCurrentDatasetColumns(input, tableNames) {
+  if (tableNames.length === 0) {
+    return [];
+  }
+  const ducklakeTable = duckLakeMetadataTableName(input.options, "ducklake_table");
+  const ducklakeColumn = duckLakeMetadataTableName(input.options, "ducklake_column");
+  const rows = await input.runtime.query(`
+    SELECT
+      table_meta.table_name,
+      column_meta.column_id,
+      column_meta.column_order,
+      column_meta.column_name,
+      column_meta.column_type,
+      CAST(column_meta.nulls_allowed AS BOOLEAN) AS nulls_allowed,
+      column_meta.parent_column
+    FROM ${ducklakeTable} table_meta
+    JOIN ${ducklakeColumn} column_meta
+      ON column_meta.table_id = table_meta.table_id
+      AND column_meta.end_snapshot IS NULL
+    WHERE table_meta.end_snapshot IS NULL
+      AND table_meta.table_name IN (${quoteSqlStringList(tableNames)})
+    ORDER BY table_meta.table_name, column_meta.column_order
+  `);
+  return rows.map((row) => ({
+    tableName: getString(row, "table_name"),
+    columnId: getBigIntLike(row, "column_id"),
+    columnOrder: getBigIntLike(row, "column_order"),
+    columnName: getString(row, "column_name"),
+    columnType: getString(row, "column_type"),
+    nullsAllowed: getBoolean(row, "nulls_allowed"),
+    parentColumnId: getOptionalBigIntLike(row, "parent_column")
+  }));
+}
+async function readCurrentDatasetPartitions(input, tableNames) {
+  if (tableNames.length === 0) {
+    return [];
+  }
+  const ducklakeTable = duckLakeMetadataTableName(input.options, "ducklake_table");
+  const ducklakePartitionInfo = duckLakeMetadataTableName(input.options, "ducklake_partition_info");
+  const ducklakePartitionColumn = duckLakeMetadataTableName(input.options, "ducklake_partition_column");
+  const ducklakeColumn = duckLakeMetadataTableName(input.options, "ducklake_column");
+  const rows = await input.runtime.query(`
+    SELECT
+      table_meta.table_name,
+      column_meta.column_name,
+      partition_column.transform
+    FROM ${ducklakeTable} table_meta
+    JOIN ${ducklakePartitionInfo} partition_info
+      ON partition_info.table_id = table_meta.table_id
+      AND partition_info.end_snapshot IS NULL
+    JOIN ${ducklakePartitionColumn} partition_column
+      ON partition_column.table_id = table_meta.table_id
+      AND partition_column.partition_id = partition_info.partition_id
+    JOIN ${ducklakeColumn} column_meta
+      ON column_meta.table_id = table_meta.table_id
+      AND column_meta.column_id = partition_column.column_id
+      AND column_meta.end_snapshot IS NULL
+    WHERE table_meta.end_snapshot IS NULL
+      AND table_meta.table_name IN (${quoteSqlStringList(tableNames)})
+    ORDER BY table_meta.table_name, partition_column.partition_key_index
+  `);
+  return rows.map((row) => {
+    const partition = {
+      tableName: getString(row, "table_name"),
+      columnName: getString(row, "column_name"),
+      transform: getString(row, "transform")
+    };
+    if (partition.transform !== "identity") {
+      throw new LakeStorageError10(`[SixbDuckLake] Dataset table '${partition.tableName}' uses unsupported DuckLake partition transform '${partition.transform}'.`);
+    }
+    return partition;
+  });
+}
+function groupColumnsByTableName(rows) {
+  const result = new Map;
+  for (const row of rows) {
+    const tableRows = result.get(row.tableName) ?? [];
+    tableRows.push(row);
+    result.set(row.tableName, tableRows);
+  }
+  return result;
+}
+function groupPartitionsByTableName(rows) {
+  const result = new Map;
+  for (const row of rows) {
+    const tablePartitions = result.get(row.tableName) ?? [];
+    tablePartitions.push(row.columnName);
+    result.set(row.tableName, tablePartitions);
+  }
+  return result;
+}
+
+// src/internal/ducklake-dataset-catalog.ts
+class DuckLakeDatasetCatalog {
+  options;
+  connections;
+  constructor(options, connections) {
+    this.options = options;
+    this.connections = connections;
+  }
+  async createDataset(definition) {
+    this.assertSchema(definition);
+    const existing = await this.getDataset(definition.id);
+    if (existing) {
+      const plan = planDatasetDefinitionUpdate(existing, definition);
+      if (plan.changed) {
+        await this.applyExistingDatasetUpdate(plan);
+        this.connections.markLocalCatalogChanged();
+        await this.connections.resetRuntime();
+      }
+      return await this.getDataset(definition.id) ?? plan.definition;
+    }
+    const tableName = encodeDatasetTableName(definition.id);
+    const qualifiedName = qualifiedTableName(this.options, tableName);
+    await this.connections.withExclusiveAttached(async (runtime) => {
+      await runtime.run(`CREATE TABLE ${qualifiedName} (${datasetSchemaToDuckDbColumnsSql(definition.schema)})`);
+      if (definition.description !== undefined) {
+        await runtime.run(`COMMENT ON TABLE ${qualifiedName} IS ${quoteSqlString(definition.description)}`);
+      }
+      await this.applyPartitionBy(runtime, qualifiedName, definition);
+    });
+    this.connections.markLocalCatalogChanged();
+    return structuredClone(definition);
+  }
+  async assertDatasetDefinitionsCompatible(definitions) {
+    const failures = [];
+    const checkedDefinitions = [];
+    for (const definition of definitions) {
+      try {
+        this.assertSchema(definition);
+        checkedDefinitions.push(definition);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        failures.push(`- ${definition.id}: ${message}`);
+      }
+    }
+    const existingById = await this.readCurrentDatasetDefinitions({
+      datasetIds: checkedDefinitions.map((definition) => definition.id)
+    });
+    for (const definition of checkedDefinitions) {
+      const existing = existingById.get(definition.id);
+      if (!existing) {
+        continue;
+      }
+      try {
+        planDatasetDefinitionUpdate(existing, definition);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        failures.push(`- ${definition.id}: ${message}`);
+      }
+    }
+    if (failures.length > 0) {
+      const details = failures.join(`
+`);
+      throw new LakeStorageError11(`[SixbLake] Lake dataset definition check failed for ${failures.length} dataset(s).
+${details}`);
+    }
+  }
+  async getDataset(datasetId) {
+    this.connections.assertOpen();
+    return this.connections.withAttachedRuntime((runtime) => this.getDatasetOnRuntime(runtime, datasetId));
+  }
+  async getDatasetOnRuntime(runtime, datasetId) {
+    return (await this.readCurrentDatasetDefinitionsOnRuntime(runtime, {
+      datasetIds: [datasetId]
+    })).get(datasetId) ?? null;
+  }
+  async listDatasets() {
+    this.connections.assertOpen();
+    return this.connections.withAttachedRuntime(async (runtime) => {
+      return [...(await this.readCurrentDatasetDefinitionsOnRuntime(runtime)).values()].sort((left, right) => left.id.localeCompare(right.id));
+    });
+  }
+  async readCurrentDatasetDefinitions(options) {
+    if (options?.datasetIds?.length === 0) {
+      return new Map;
+    }
+    return this.connections.withAttachedRuntime((runtime) => this.readCurrentDatasetDefinitionsOnRuntime(runtime, options));
+  }
+  async readCurrentDatasetDefinitionsOnRuntime(runtime, options) {
+    return readCurrentDatasetDefinitions({
+      options: this.options,
+      runtime,
+      datasetIds: options?.datasetIds
+    });
+  }
+  async getDatasetSchemaAtSnapshot(runtime, datasetId, tableName, tableId, snapshotId) {
+    assertDuckLakeSnapshotId(snapshotId);
+    const columns = await this.readDatasetColumnsAtSnapshot(runtime, tableName, tableId, snapshotId);
+    if (columns.length === 0) {
+      throw new LakeStorageError11(`[SixbDuckLake] Could not reconstruct schema for dataset '${datasetId}' at DuckLake snapshot '${snapshotId}'.`);
+    }
+    return duckLakeCatalogColumnsToDatasetSchema(tableName, columns);
+  }
+  assertSchema(definition) {
+    if (!definition.schema) {
+      throw new LakeStorageError11(`[SixbDuckLake] Dataset '${definition.id}' requires a schema for DuckLake storage.`);
+    }
+  }
+  async applyExistingDatasetUpdate(plan) {
+    const tableName = encodeDatasetTableName(plan.definition.id);
+    const qualifiedName = qualifiedTableName(this.options, tableName);
+    await this.connections.withExclusiveAttached(async (runtime) => {
+      if (plan.schema.kind === "none") {
+        await this.applyMetadataDelta(runtime, qualifiedName, plan);
+        return;
+      }
+      await runtime.run("BEGIN TRANSACTION");
+      let committed = false;
+      try {
+        await this.applySchemaEvolutionDdl(runtime, qualifiedName, plan.schema);
+        await this.applyMetadataDelta(runtime, qualifiedName, plan);
+        await this.setSchemaEvolutionCommitMetadata(runtime, plan.definition.id, plan.schema);
+        await runtime.run("COMMIT");
+        committed = true;
+      } catch (error) {
+        if (!committed) {
+          await this.rollbackTransaction(runtime);
+        }
+        throw error;
+      }
+    });
+  }
+  async applySchemaEvolutionDdl(runtime, qualifiedName, plan) {
+    for (const column of plan.columns) {
+      await runtime.run(`ALTER TABLE ${qualifiedName} ADD COLUMN ${datasetColumnToDuckDbSql(column)}`);
+    }
+  }
+  async applyMetadataDelta(runtime, qualifiedName, plan) {
+    if (plan.metadata.descriptionChanged && plan.definition.description !== undefined) {
+      await runtime.run(`COMMENT ON TABLE ${qualifiedName} IS ${quoteSqlString(plan.definition.description)}`);
+    }
+    if (plan.metadata.partitionByChanged) {
+      await this.applyPartitionBy(runtime, qualifiedName, plan.definition);
+    }
+  }
+  async applyPartitionBy(runtime, qualifiedName, definition) {
+    if (definition.partitionBy === undefined || definition.partitionBy.length === 0) {
+      return;
+    }
+    try {
+      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 LakeStorageError11(`[SixbDuckLake] Dataset '${definition.id}' cannot apply partitionBy because DuckLake rejected ALTER TABLE SET PARTITIONED BY: ${message}`);
+    }
+  }
+  async setSchemaEvolutionCommitMetadata(runtime, datasetId, plan) {
+    await runtime.run(`CALL ${quoteIdentifier(duckLakeAlias(this.options))}.set_commit_message(${quoteSqlString("Sixb")}, ${quoteSqlString(`evolve dataset ${datasetId} schema`)}, extra_info => ${quoteSqlString(JSON.stringify({
+      sixb: {
+        kind: "datasetVersion",
+        datasetId,
+        commitId: randomUUID(),
+        mode: "schema",
+        schemaChange: {
+          addColumns: plan.columns.map((column) => column.name)
+        }
+      }
+    }))})`);
+  }
+  async rollbackTransaction(runtime) {
+    try {
+      await runtime.run("ROLLBACK");
+    } catch {}
+  }
+  async readDatasetColumnsAtSnapshot(runtime, tableName, tableId, snapshotId) {
+    const ducklakeColumn = duckLakeMetadataTableName(this.options, "ducklake_column");
+    const rows = await runtime.query(`
+      SELECT
+        column_id,
+        column_order,
+        column_name,
+        column_type,
+        CAST(nulls_allowed AS BOOLEAN) AS nulls_allowed,
+        parent_column
+      FROM ${ducklakeColumn}
+      WHERE table_id = ${tableId}
+        AND begin_snapshot <= ${snapshotId}
+        AND (end_snapshot IS NULL OR end_snapshot > ${snapshotId})
+      ORDER BY column_order
+    `);
+    return rows.map((row) => ({
+      tableName,
+      columnId: getBigIntLike(row, "column_id"),
+      columnOrder: getBigIntLike(row, "column_order"),
+      columnName: getString(row, "column_name"),
+      columnType: getString(row, "column_type"),
+      nullsAllowed: getBoolean(row, "nulls_allowed"),
+      parentColumnId: getOptionalBigIntLike(row, "parent_column")
+    }));
+  }
+}
+function assertDuckLakeSnapshotId(snapshotId) {
+  if (!/^\d+$/.test(snapshotId)) {
+    throw new LakeStorageError11(`[SixbDuckLake] Invalid DuckLake snapshot id '${snapshotId}'.`);
+  }
+}
+
+// src/internal/ducklake-maintenance.ts
+import { LakeStorageError as LakeStorageError12 } from "@sixb/core/lake-storage";
+var DEFAULT_RETENTION = "7 days";
+
+class DuckLakeMaintenance {
+  options;
+  connections;
+  constructor(options, connections) {
+    this.options = options;
+    this.connections = connections;
+  }
+  async runMaintenance(options = {}) {
+    this.connections.assertOpen();
+    const expireOlderThan = options.expireOlderThan ?? DEFAULT_RETENTION;
+    const deleteOlderThan = options.deleteOlderThan ?? expireOlderThan;
+    const dryRun = options.dryRun ?? false;
+    if (this.options.readOnly && !dryRun) {
+      throw new LakeStorageError12("[SixbDuckLake] DuckLake maintenance cannot run in read-only mode.");
+    }
+    return this.connections.withExclusiveAttached(async (runtime) => {
+      const counts = await runMaintenanceProcedures(runtime, this.options, {
+        expireOlderThan,
+        deleteOlderThan
+      }, dryRun);
+      if (!dryRun) {
+        this.connections.markLocalCatalogChanged();
+      }
+      return {
+        dryRun,
+        expireOlderThan,
+        deleteOlderThan,
+        ...counts
+      };
+    });
+  }
+}
+async function runMaintenanceProcedures(runtime, options, retention, dryRun) {
+  const aliasSql = quoteSqlString(duckLakeAlias(options));
+  const snapshots = await runtime.query(maintenanceProcedureSql("ducklake_expire_snapshots", aliasSql, retention.expireOlderThan, dryRun));
+  const oldFiles = await runtime.query(maintenanceProcedureSql("ducklake_cleanup_old_files", aliasSql, retention.deleteOlderThan, dryRun));
+  const orphanedFiles = await runtime.query(maintenanceProcedureSql("ducklake_delete_orphaned_files", aliasSql, retention.deleteOlderThan, dryRun));
+  return {
+    snapshots: snapshots.length,
+    oldFiles: oldFiles.length,
+    orphanedFiles: orphanedFiles.length
+  };
+}
+function maintenanceProcedureSql(procedure, aliasSql, olderThan, dryRun) {
+  const olderThanSql = quoteSqlString(olderThan);
+  const dryRunSql = dryRun ? "dry_run => true, " : "";
+  return `CALL ${procedure}(${aliasSql}, ${dryRunSql}` + `older_than => now() - INTERVAL ${olderThanSql})`;
+}
+
+// src/internal/ducklake-row-reader.ts
+import { LakeStorageError as LakeStorageError14 } from "@sixb/core/lake-storage";
+
+// src/internal/ducklake-dataset-table-ref.ts
+async function resolveDatasetTableRef(options, runtime, datasetId) {
+  const tableName = encodeDatasetTableName(datasetId);
+  const ducklakeTable = duckLakeMetadataTableName(options, "ducklake_table");
+  const [row] = await runtime.query(`
+    SELECT table_id
+    FROM ${ducklakeTable}
+    WHERE table_name = ${quoteSqlString(tableName)}
+      AND end_snapshot IS NULL
+    LIMIT 1
+  `);
+  return row === undefined ? null : {
+    datasetId,
+    tableName,
+    tableId: getBigIntLike(row, "table_id")
+  };
+}
+
+// src/internal/versions.ts
+import { LakeStorageError as LakeStorageError13 } from "@sixb/core/lake-storage";
+function parseVersionId(versionId) {
+  if (!versionId.startsWith("ducklake:")) {
+    throw new LakeStorageError13(`[SixbDuckLake] Invalid DuckLake version id '${versionId}'.`);
+  }
+  const snapshotId = versionId.slice("ducklake:".length);
+  if (!/^\d+$/.test(snapshotId)) {
+    throw new LakeStorageError13(`[SixbDuckLake] Invalid DuckLake version id '${versionId}'.`);
+  }
+  return snapshotId;
+}
+function toVersionId(snapshotId) {
+  return `ducklake:${snapshotId}`;
+}
+function parseCommitMetadata(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    return;
+  }
+  if (!isRecord(parsed) || !isRecord(parsed.sixb) || parsed.sixb.kind !== "datasetVersion" || typeof parsed.sixb.datasetId !== "string") {
+    return;
+  }
+  const mode = parsed.sixb.mode;
+  const commitId = parsed.sixb.commitId;
+  const rowCount = parsed.sixb.rowCount;
+  return {
+    kind: "datasetVersion",
+    datasetId: parsed.sixb.datasetId,
+    ...typeof commitId === "string" ? { commitId } : {},
+    ...mode === "snapshot" || mode === "append" || mode === "schema" ? { mode } : {},
+    ...isDatasetProducer(parsed.sixb.producer) ? { producer: parsed.sixb.producer } : {},
+    ...isDatasetVersionRefs(parsed.sixb.inputs) ? { inputs: parsed.sixb.inputs } : {},
+    ...typeof commitId === "string" && isRowCount(rowCount) ? { rowCount } : {},
+    ...isSchemaChangeMetadata(parsed.sixb.schemaChange) ? { schemaChange: parsed.sixb.schemaChange } : {}
+  };
+}
+function parseInlineDataChange(changesMade, tableId) {
+  const tableIdText = tableId.toString();
+  let hasDataChange = false;
+  let hasDeleteChange = false;
+  for (const change of changesMade.split(",")) {
+    const [kind, changedTableId] = change.split(":");
+    if (changedTableId !== tableIdText) {
+      continue;
+    }
+    const normalizedKind = kind.toLowerCase();
+    if (normalizedKind.includes("insert") || normalizedKind.includes("delete")) {
+      hasDataChange = true;
+    }
+    if (normalizedKind.includes("delete")) {
+      hasDeleteChange = true;
+    }
+  }
+  return { hasDataChange, hasDeleteChange };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isDatasetProducer(value) {
+  return isRecord(value) && (value.kind === "sync" || value.kind === "pipeline") && optionalString(value.id) && optionalString(value.runId);
+}
+function isDatasetVersionRefs(value) {
+  return Array.isArray(value) && value.every((item) => isRecord(item) && typeof item.datasetId === "string" && typeof item.versionId === "string");
+}
+function isSchemaChangeMetadata(value) {
+  return isRecord(value) && (value.addColumns === undefined || Array.isArray(value.addColumns) && value.addColumns.every((columnName) => typeof columnName === "string"));
+}
+function optionalString(value) {
+  return value === undefined || typeof value === "string";
+}
+function isRowCount(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+
+// src/internal/ducklake-row-reader.ts
+class DuckLakeRowReader {
+  options;
+  connections;
+  snapshots;
+  constructor(options, connections, snapshots) {
+    this.options = options;
+    this.connections = connections;
+    this.snapshots = snapshots;
+  }
+  async* readRows(input) {
+    this.connections.assertOpen();
+    const lease = await this.connections.acquireAttachedRuntime();
+    try {
+      const runtime = lease.runtime;
+      const tableRef = await resolveDatasetTableRef(this.options, runtime, input.datasetId);
+      if (!tableRef) {
+        throw new LakeStorageError14(`[SixbDuckLake] Unknown dataset '${input.datasetId}'.`);
+      }
+      const version = await this.resolveVersion(runtime, tableRef, input.versionId);
+      const snapshotId = parseVersionId(version.versionId);
+      const selectedColumns = this.resolveReadColumns(tableRef.datasetId, version.schema, input.columns);
+      const columnsSql = selectedColumns.map((column) => quoteIdentifier(column.name)).join(", ");
+      const tableSql = qualifiedTableName(this.options, tableRef.tableName);
+      const orderSql = version.schema.columns.some((column) => column.name.toLowerCase() === "rowid") ? "" : " ORDER BY rowid";
+      const limitSql = input.limit === undefined ? "" : ` LIMIT ${Math.max(0, Math.trunc(input.limit))}`;
+      const offsetSql = input.offset === undefined ? "" : ` OFFSET ${Math.max(0, Math.trunc(input.offset))}`;
+      const sql = `SELECT ${columnsSql} FROM ${tableSql} AT (VERSION => ${snapshotId})${orderSql}${limitSql}${offsetSql}`;
+      const rows = input.limit === undefined ? runtime.streamRows(sql) : await runtime.query(sql);
+      yield* this.normalizeRows(rows, selectedColumns);
+    } finally {
+      await lease.release();
+    }
+  }
+  async* normalizeRows(rows, selectedColumns) {
+    for await (const row of rows) {
+      const output = {};
+      for (const column of selectedColumns) {
+        output[column.name] = normalizeReadValue(row[column.name], column);
+      }
+      yield output;
+    }
+  }
+  async resolveVersion(runtime, tableRef, versionId) {
+    if (versionId !== undefined) {
+      const snapshotId = parseVersionId(versionId);
+      const version = await this.snapshots.getVersionForTableRef(runtime, tableRef, snapshotId);
+      if (!version) {
+        this.throwNoCommittedVersion(tableRef.datasetId);
+      }
+      return version;
+    }
+    const latestVersion = await this.snapshots.getLatestVersionForTableRef(runtime, tableRef);
+    if (!latestVersion) {
+      this.throwNoCommittedVersion(tableRef.datasetId);
+    }
+    return latestVersion;
+  }
+  resolveReadColumns(datasetId, schema, columns) {
+    if (columns === undefined || columns.length === 0) {
+      return schema.columns;
+    }
+    const columnsByName = new Map(schema.columns.map((column) => [column.name, column]));
+    return columns.map((columnName) => {
+      const column = columnsByName.get(columnName);
+      if (!column) {
+        throw new LakeStorageError14(`[SixbDuckLake] Dataset '${datasetId}' does not have column '${columnName}' at the requested version.`);
+      }
+      return column;
+    });
+  }
+  throwNoCommittedVersion(datasetId) {
+    throw new LakeStorageError14(`[SixbDuckLake] No committed version found for dataset '${datasetId}'.`);
+  }
+}
+
+// src/internal/ducklake-snapshot-reader.ts
+import { LakeStorageError as LakeStorageError15 } from "@sixb/core/lake-storage";
+var SNAPSHOT_ROW_BATCH_SIZE = 128;
+var CATALOG_SNAPSHOT_SCAN_LIMIT = 512;
+
+class DuckLakeSnapshotReader {
+  options;
+  connections;
+  datasets;
+  constructor(options, connections, datasets) {
+    this.options = options;
+    this.connections = connections;
+    this.datasets = datasets;
+  }
+  async listVersions(datasetId, limit) {
+    this.connections.assertOpen();
+    return this.connections.withAttachedRuntime(async (runtime) => {
+      const tableRef = await resolveDatasetTableRef(this.options, runtime, datasetId);
+      if (!tableRef) {
+        return [];
+      }
+      return this.listVersionsForTableRef(runtime, tableRef, limit);
+    });
+  }
+  async getLatestVersion(datasetId) {
+    this.connections.assertOpen();
+    return this.connections.withAttachedRuntime(async (runtime) => {
+      const tableRef = await resolveDatasetTableRef(this.options, runtime, datasetId);
+      if (!tableRef) {
+        return null;
+      }
+      return this.getLatestVersionForTableRef(runtime, tableRef);
+    });
+  }
+  async getVersion(datasetId, versionId) {
+    const snapshotId = parseVersionId(versionId);
+    this.connections.assertOpen();
+    return this.connections.withAttachedRuntime(async (runtime) => {
+      const tableRef = await resolveDatasetTableRef(this.options, runtime, datasetId);
+      if (!tableRef) {
+        return null;
+      }
+      return this.getVersionForTableRef(runtime, tableRef, snapshotId);
+    });
+  }
+  async listDatasetCatalogState(datasetIds) {
+    this.connections.assertOpen();
+    if (datasetIds.length === 0) {
+      return [];
+    }
+    return this.connections.withAttachedRuntime((runtime) => this.collectDatasetCatalogState(runtime, datasetIds));
+  }
+  async collectDatasetCatalogState(runtime, datasetIds) {
+    const uniqueIds = [...new Set(datasetIds)];
+    const tableIdsByDatasetId = await this.resolveDatasetTableIds(runtime, uniqueIds);
+    const latestRowByDatasetId = await this.resolveLatestSnapshotRows(runtime, tableIdsByDatasetId);
+    return uniqueIds.map((datasetId) => {
+      if (!tableIdsByDatasetId.has(datasetId)) {
+        return { datasetId, materialized: false, latestVersion: null };
+      }
+      const row = latestRowByDatasetId.get(datasetId);
+      return {
+        datasetId,
+        materialized: true,
+        latestVersion: row ? this.snapshotRowToSummary(datasetId, row) : null
+      };
+    });
+  }
+  snapshotRowToSummary(datasetId, row) {
+    return {
+      datasetId,
+      versionId: toVersionId(row.snapshotId),
+      mode: row.mode,
+      createdAt: row.createdAt,
+      ...row.metadata?.rowCount !== undefined ? { rowCount: row.metadata.rowCount } : {}
+    };
+  }
+  async resolveDatasetTableIds(runtime, datasetIds) {
+    const datasetIdByTableName = new Map;
+    for (const datasetId of datasetIds) {
+      datasetIdByTableName.set(encodeDatasetTableName(datasetId), datasetId);
+    }
+    const ducklakeTable = duckLakeMetadataTableName(this.options, "ducklake_table");
+    const tableNameList = [...datasetIdByTableName.keys()].map((name) => quoteSqlString(name)).join(", ");
+    const rows = await runtime.query(`
+      SELECT table_id, table_name
+      FROM ${ducklakeTable}
+      WHERE table_name IN (${tableNameList})
+        AND end_snapshot IS NULL
+    `);
+    const tableIdsByDatasetId = new Map;
+    for (const row of rows) {
+      const datasetId = datasetIdByTableName.get(getString(row, "table_name"));
+      if (datasetId !== undefined) {
+        tableIdsByDatasetId.set(datasetId, getBigIntLike(row, "table_id"));
+      }
+    }
+    return tableIdsByDatasetId;
+  }
+  async resolveLatestSnapshotRows(runtime, tableIdsByDatasetId) {
+    const result = new Map;
+    if (tableIdsByDatasetId.size === 0) {
+      return result;
+    }
+    const unresolved = new Map(tableIdsByDatasetId);
+    const tableIds = [...new Set(tableIdsByDatasetId.values())];
+    let beforeSnapshotId;
+    let scanned = 0;
+    while (unresolved.size > 0 && scanned < CATALOG_SNAPSHOT_SCAN_LIMIT) {
+      const candidates = await this.queryCatalogSnapshotBatch(runtime, beforeSnapshotId, SNAPSHOT_ROW_BATCH_SIZE);
+      if (candidates.length === 0) {
+        break;
+      }
+      const fileFlags = await this.queryFileChangeFlags(runtime, candidates.map((candidate) => candidate.snapshotId), tableIds);
+      for (const candidate of candidates) {
+        scanned += 1;
+        for (const [datasetId, tableId] of [...unresolved]) {
+          const flags = fileFlags.get(fileChangeKey(candidate.snapshotId, tableId));
+          const row = this.candidateToSnapshotRow(datasetId, tableId, {
+            snapshotId: candidate.snapshotId,
+            createdAt: candidate.createdAt,
+            changesMade: candidate.changesMade,
+            hasFileChange: flags?.hasFileChange ?? false,
+            hasFileDeleteChange: flags?.hasFileDeleteChange ?? false,
+            ...candidate.metadata !== undefined ? { metadata: candidate.metadata } : {}
+          });
+          if (row) {
+            result.set(datasetId, row);
+            unresolved.delete(datasetId);
+          }
+        }
+        if (unresolved.size === 0) {
+          break;
+        }
+      }
+      if (candidates.length < SNAPSHOT_ROW_BATCH_SIZE) {
+        break;
+      }
+      beforeSnapshotId = candidates[candidates.length - 1]?.snapshotId;
+    }
+    return result;
+  }
+  async queryCatalogSnapshotBatch(runtime, beforeSnapshotId, limit) {
+    const ducklakeSnapshot = duckLakeMetadataTableName(this.options, "ducklake_snapshot");
+    const ducklakeSnapshotChanges = duckLakeMetadataTableName(this.options, "ducklake_snapshot_changes");
+    let whereSql = "";
+    if (beforeSnapshotId !== undefined) {
+      assertDuckLakeSnapshotId2(beforeSnapshotId);
+      whereSql = `WHERE snapshot.snapshot_id < ${beforeSnapshotId}`;
+    }
+    const rows = await runtime.query(`
+      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
+      LIMIT ${Math.max(0, Math.trunc(limit))}
+    `);
+    return rows.map((row) => {
+      const metadata = parseCommitMetadata(getOptionalString(row, "commit_extra_info"));
+      return {
+        snapshotId: String(getBigIntLike(row, "snapshot_id")),
+        createdAt: getDate(row, "snapshot_time"),
+        changesMade: getString(row, "changes_made"),
+        ...metadata !== undefined ? { metadata } : {}
+      };
+    });
+  }
+  async queryFileChangeFlags(runtime, snapshotIds, tableIds) {
+    const flags = new Map;
+    if (snapshotIds.length === 0 || tableIds.length === 0) {
+      return flags;
+    }
+    for (const snapshotId of snapshotIds) {
+      assertDuckLakeSnapshotId2(snapshotId);
+    }
+    const snapshotIdList = snapshotIds.join(", ");
+    const tableIdList = tableIds.map((tableId) => tableId.toString()).join(", ");
+    const ducklakeDataFile = duckLakeMetadataTableName(this.options, "ducklake_data_file");
+    const ducklakeDeleteFile = duckLakeMetadataTableName(this.options, "ducklake_delete_file");
+    const rows = await runtime.query(`
+      WITH file_changes AS (
+        SELECT begin_snapshot AS snapshot_id, table_id, false AS is_delete
+        FROM ${ducklakeDataFile}
+        WHERE table_id IN (${tableIdList}) AND begin_snapshot IN (${snapshotIdList})
+        UNION ALL
+        SELECT end_snapshot, table_id, true
+        FROM ${ducklakeDataFile}
+        WHERE table_id IN (${tableIdList}) AND end_snapshot IN (${snapshotIdList})
+        UNION ALL
+        SELECT begin_snapshot, table_id, true
+        FROM ${ducklakeDeleteFile}
+        WHERE table_id IN (${tableIdList}) AND begin_snapshot IN (${snapshotIdList})
+        UNION ALL
+        SELECT end_snapshot, table_id, true
+        FROM ${ducklakeDeleteFile}
+        WHERE table_id IN (${tableIdList}) AND end_snapshot IN (${snapshotIdList})
+      )
+      SELECT snapshot_id, table_id, bool_or(is_delete) AS has_delete
+      FROM file_changes
+      GROUP BY snapshot_id, table_id
+    `);
+    for (const row of rows) {
+      const key = fileChangeKey(String(getBigIntLike(row, "snapshot_id")), getBigIntLike(row, "table_id"));
+      flags.set(key, { hasFileChange: true, hasFileDeleteChange: getBoolean(row, "has_delete") });
+    }
+    return flags;
+  }
+  assertNoMetadataConflict(snapshotId, datasetId, metadata) {
+    if (metadata !== undefined && metadata.datasetId !== datasetId) {
+      throw new LakeStorageError15(`[SixbDuckLake] DuckLake snapshot '${snapshotId}' changed dataset '${datasetId}' but Sixb commit metadata references dataset '${metadata.datasetId}'.`);
+    }
+  }
+  async getLatestVersionForDefinition(runtime, dataset) {
+    const tableRef = await resolveDatasetTableRef(this.options, runtime, dataset.id);
+    return tableRef ? this.getLatestVersionForTableRef(runtime, tableRef) : null;
+  }
+  async getLatestVersionRefForDefinition(runtime, dataset) {
+    const summary = await this.getLatestVersionSummaryForDefinition(runtime, dataset);
+    return summary ? { datasetId: summary.datasetId, versionId: summary.versionId } : null;
+  }
+  async getLatestVersionSummaryForDefinition(runtime, dataset) {
+    const tableRef = await resolveDatasetTableRef(this.options, runtime, dataset.id);
+    if (!tableRef) {
+      return null;
+    }
+    const row = await this.getLatestSnapshotRowForTableRef(runtime, tableRef);
+    if (!row) {
+      return null;
+    }
+    return {
+      datasetId: tableRef.datasetId,
+      versionId: toVersionId(row.snapshotId),
+      ...row.metadata?.rowCount !== undefined ? { rowCount: row.metadata.rowCount } : {}
+    };
+  }
+  async getVersionForSnapshot(runtime, dataset, snapshotId) {
+    assertDuckLakeSnapshotId2(snapshotId);
+    const tableRef = await resolveDatasetTableRef(this.options, runtime, dataset.id);
+    return tableRef ? this.getVersionForTableRef(runtime, tableRef, snapshotId) : null;
+  }
+  async getVersionForTableRef(runtime, tableRef, snapshotId) {
+    const match = await this.getSnapshotRowForTableRef(runtime, tableRef, snapshotId, {
+      includeParent: true
+    });
+    return match ? this.snapshotToVersion(runtime, tableRef, match) : null;
+  }
+  async getVersionRefForSnapshot(runtime, dataset, snapshotId) {
+    assertDuckLakeSnapshotId2(snapshotId);
+    const tableRef = await resolveDatasetTableRef(this.options, runtime, dataset.id);
+    if (!tableRef) {
+      return null;
+    }
+    const row = await this.getSnapshotRowForTableRef(runtime, tableRef, snapshotId, {
+      includeParent: false
+    });
+    return row ? { datasetId: tableRef.datasetId, versionId: toVersionId(row.snapshotId) } : null;
+  }
+  async listVersionsForDefinition(runtime, dataset, limit) {
+    const tableRef = await resolveDatasetTableRef(this.options, runtime, dataset.id);
+    return tableRef ? this.listVersionsForTableRef(runtime, tableRef, limit) : [];
+  }
+  async listVersionsForTableRef(runtime, tableRef, limit) {
+    const limitedRows = await this.getSnapshotRowsForTableRef(runtime, tableRef, limit);
+    const versions = [];
+    for (const row of limitedRows) {
+      versions.push(await this.snapshotToVersion(runtime, tableRef, row));
+    }
+    return versions;
+  }
+  async getLatestVersionForTableRef(runtime, tableRef) {
+    const [latest] = await this.listVersionsForTableRef(runtime, tableRef, 1);
+    return latest ?? null;
+  }
+  async getLatestSnapshotRowForTableRef(runtime, tableRef) {
+    const [row] = await this.collectVisibleSnapshotRows(runtime, {
+      datasetId: tableRef.datasetId,
+      tableId: tableRef.tableId,
+      visibleRowLimit: 1
+    });
+    return row ?? null;
+  }
+  async getSnapshotRowForTableRef(runtime, tableRef, snapshotId, options) {
+    assertDuckLakeSnapshotId2(snapshotId);
+    const [row] = await this.collectVisibleSnapshotRows(runtime, {
+      datasetId: tableRef.datasetId,
+      tableId: tableRef.tableId,
+      exactSnapshotId: snapshotId,
+      visibleRowLimit: 1
+    });
+    if (!row) {
+      return null;
+    }
+    if (!options.includeParent || row.mode !== "append" && row.mode !== "schema") {
+      return row;
+    }
+    const [parent] = await this.collectVisibleSnapshotRows(runtime, {
+      datasetId: tableRef.datasetId,
+      tableId: tableRef.tableId,
+      beforeSnapshotId: snapshotId,
+      visibleRowLimit: 1
+    });
+    return parent ? { ...row, parentSnapshotId: parent.snapshotId } : row;
+  }
+  async getSnapshotRowsForTableRef(runtime, tableRef, limit) {
+    const visibleLimit = limit === undefined ? undefined : Math.max(0, limit);
+    if (visibleLimit === 0) {
+      return [];
+    }
+    const rows = await this.collectVisibleSnapshotRows(runtime, {
+      datasetId: tableRef.datasetId,
+      tableId: tableRef.tableId,
+      visibleRowLimit: visibleLimit === undefined ? undefined : visibleLimit + 1
+    });
+    const rowsWithParents = this.withParentSnapshotIds(rows);
+    return visibleLimit === undefined ? rowsWithParents : rowsWithParents.slice(0, visibleLimit);
+  }
+  async collectVisibleSnapshotRows(runtime, input) {
+    if (input.visibleRowLimit !== undefined && input.visibleRowLimit <= 0) {
+      return [];
+    }
+    const snapshots = [];
+    let beforeSnapshotId = input.beforeSnapshotId;
+    while (input.visibleRowLimit === undefined || snapshots.length < input.visibleRowLimit) {
+      const candidates = await this.querySnapshotCandidates(runtime, {
+        tableId: input.tableId,
+        exactSnapshotId: input.exactSnapshotId,
+        beforeSnapshotId,
+        limit: input.exactSnapshotId === undefined ? SNAPSHOT_ROW_BATCH_SIZE : 1
+      });
+      if (candidates.length === 0) {
+        break;
+      }
+      for (const candidate of candidates) {
+        const snapshot = this.candidateToSnapshotRow(input.datasetId, input.tableId, candidate);
+        if (snapshot) {
+          snapshots.push(snapshot);
+        }
+        if (input.visibleRowLimit !== undefined && snapshots.length >= input.visibleRowLimit) {
+          break;
+        }
+      }
+      if (input.exactSnapshotId !== undefined || candidates.length < SNAPSHOT_ROW_BATCH_SIZE) {
+        break;
+      }
+      beforeSnapshotId = candidates[candidates.length - 1]?.snapshotId;
+    }
+    return snapshots;
+  }
+  async querySnapshotCandidates(runtime, input) {
+    if (input.limit !== undefined && input.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
+    `);
+    return rows.map((row) => {
+      const metadata = parseCommitMetadata(row.commit_extra_info);
+      return {
+        snapshotId: String(getBigIntLike(row, "snapshot_id")),
+        createdAt: getDate(row, "snapshot_time"),
+        changesMade: getString(row, "changes_made"),
+        hasFileChange: getBoolean(row, "has_file_change"),
+        hasFileDeleteChange: getBoolean(row, "has_file_delete_change"),
+        ...metadata !== undefined ? { metadata } : {}
+      };
+    });
+  }
+  candidateToSnapshotRow(datasetId, tableId, candidate) {
+    const inlineChange = parseInlineDataChange(candidate.changesMade, tableId);
+    const hasDataChange = inlineChange.hasDataChange || candidate.hasFileChange;
+    const hasDeleteChange = inlineChange.hasDeleteChange || candidate.hasFileDeleteChange;
+    if (!hasDataChange) {
+      const metadata = candidate.metadata;
+      if (!metadata || metadata.datasetId !== datasetId) {
+        return null;
+      }
+      return {
+        snapshotId: candidate.snapshotId,
+        tableId,
+        createdAt: candidate.createdAt,
+        mode: metadata.mode ?? "schema",
+        metadata
+      };
+    }
+    this.assertNoMetadataConflict(candidate.snapshotId, datasetId, candidate.metadata);
+    return {
+      snapshotId: candidate.snapshotId,
+      tableId,
+      createdAt: candidate.createdAt,
+      mode: candidate.metadata?.mode ?? (hasDeleteChange ? "snapshot" : "append"),
+      ...candidate.metadata !== undefined ? { metadata: candidate.metadata } : {}
+    };
+  }
+  async snapshotToVersion(runtime, tableRef, row) {
+    const schemaAtSnapshot = await this.datasets.getDatasetSchemaAtSnapshot(runtime, tableRef.datasetId, tableRef.tableName, tableRef.tableId, row.snapshotId);
+    return {
+      datasetId: tableRef.datasetId,
+      versionId: toVersionId(row.snapshotId),
+      parentVersionId: row.parentSnapshotId === undefined ? undefined : toVersionId(row.parentSnapshotId),
+      mode: row.mode,
+      createdAt: row.createdAt,
+      schema: schemaAtSnapshot,
+      producer: row.metadata?.producer,
+      inputs: row.metadata?.inputs,
+      ...row.metadata?.rowCount !== undefined ? { rowCount: row.metadata.rowCount } : {}
+    };
+  }
+  withParentSnapshotIds(snapshots) {
+    return snapshots.map((snapshot, index) => {
+      const parentSnapshotId = snapshot.mode === "append" || snapshot.mode === "schema" ? snapshots[index + 1]?.snapshotId : undefined;
+      return parentSnapshotId === undefined ? snapshot : { ...snapshot, parentSnapshotId };
+    });
+  }
+}
+function assertDuckLakeSnapshotId2(snapshotId) {
+  if (!/^\d+$/.test(snapshotId)) {
+    throw new LakeStorageError15(`[SixbDuckLake] Invalid DuckLake snapshot id '${snapshotId}'.`);
+  }
+}
+function fileChangeKey(snapshotId, tableId) {
+  return `${snapshotId}|${tableId}`;
+}
+
+// src/internal/ducklake-sql-executor.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import {
+  LakeStorageError as LakeStorageError18
+} from "@sixb/core/lake-storage";
+
+// src/internal/dataset-row-commit.ts
+import { LakeStorageError as LakeStorageError16 } from "@sixb/core/lake-storage";
+function assertDatasetWriteMode(mode, operation) {
+  if (mode !== "snapshot" && mode !== "append") {
+    throw new LakeStorageError16(`[SixbDuckLake] Invalid ${operation} mode '${String(mode)}'. Expected 'snapshot' or 'append'.`);
+  }
+}
+async function applyDatasetRowsFromRelation(input) {
+  const tableName = encodeDatasetTableName(input.dataset.id);
+  const table = qualifiedTableName(input.options, tableName);
+  const columnsSql = datasetSchemaColumnNamesSql(input.dataset.schema);
+  if (input.mode === "snapshot") {
+    const source = await fingerprintRelation(input.runtime, input.sourceRelationSql, columnsSql);
+    const target = await fingerprintRelation(input.runtime, table, columnsSql);
+    if (sameFingerprint(source, target)) {
+      return {
+        dataChangeExpected: false,
+        sourceRowCount: source.rowCount,
+        resultingRowCount: { kind: "exact", value: target.rowCount }
+      };
+    }
+    await input.runtime.run(`DELETE FROM ${table}`);
+    await input.runtime.run(`INSERT INTO ${table} (${columnsSql}) SELECT ${columnsSql} FROM ${input.sourceRelationSql}`);
+    return {
+      dataChangeExpected: source.rowCount > 0 || target.rowCount > 0,
+      sourceRowCount: source.rowCount,
+      resultingRowCount: { kind: "exact", value: source.rowCount }
+    };
+  }
+  const sourceRowCount = await countRows(input.runtime, input.sourceRelationSql);
+  await input.runtime.run(`INSERT INTO ${table} (${columnsSql}) SELECT ${columnsSql} FROM ${input.sourceRelationSql}`);
+  return {
+    dataChangeExpected: sourceRowCount > 0,
+    sourceRowCount,
+    resultingRowCount: input.previousRowCount === undefined ? { kind: "unknown" } : { kind: "exact", value: input.previousRowCount + sourceRowCount }
+  };
+}
+async function fingerprintRelation(runtime, relationSql, columnsSql) {
+  const [row] = await runtime.query(`
+    SELECT
+      count(*) AS row_count,
+      coalesce(sum(hash(${columnsSql})::HUGEINT), 0::HUGEINT) AS hash_sum,
+      coalesce(bit_xor(hash('sixb:snapshot:v1', ${columnsSql})), 0::UBIGINT) AS hash_xor
+    FROM ${relationSql}
+  `);
+  if (row === undefined) {
+    return { rowCount: 0, hashSum: "0", hashXor: "0" };
+  }
+  return {
+    rowCount: Number(getBigIntLike(row, "row_count")),
+    hashSum: getBigIntLike(row, "hash_sum").toString(),
+    hashXor: getBigIntLike(row, "hash_xor").toString()
+  };
+}
+function sameFingerprint(left, right) {
+  return left.rowCount === right.rowCount && left.hashSum === right.hashSum && left.hashXor === right.hashXor;
+}
+async function countRows(runtime, relationSql) {
+  const [row] = await runtime.query(`SELECT count(*) AS row_count FROM ${relationSql}`);
+  if (row === undefined) {
+    return 0;
+  }
+  return Number(getBigIntLike(row, "row_count"));
+}
+
+// src/internal/sql-transform-relations.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import {
+  LakeStorageError as LakeStorageError17
+} 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;
+
+class DuckLakeSqlTransformRelation {
+  placeholder;
+  constructor(placeholder) {
+    this.placeholder = placeholder;
+  }
+  toString() {
+    return this.placeholder;
+  }
+}
+function renderDuckLakeSqlTransformSql(input) {
+  const context = createDuckLakeSqlTransformRelationContext(input);
+  const sql = input.sql(context.relations);
+  if (typeof sql !== "string") {
+    throw new LakeStorageError17("[SixbDuckLake] SQL transform body must return a SQL string.");
+  }
+  return context.render(sql);
+}
+function createDuckLakeSqlTransformRelationContext(input) {
+  const token = randomUUID2().replaceAll("-", "");
+  const relations = Object.create(null);
+  const replacements = new Map;
+  let index = 0;
+  for (const [sourceName, source] of Object.entries(input.sources)) {
+    const placeholder = `${RELATION_PLACEHOLDER_PREFIX}${token}_${index}__`;
+    relations[sourceName] = Object.freeze(new DuckLakeSqlTransformRelation(placeholder));
+    replacements.set(placeholder, renderDuckLakeSourceRelation(input.options, source));
+    index += 1;
+  }
+  return {
+    relations: Object.freeze(relations),
+    render(sql) {
+      const rendered = sql.replace(RELATION_PLACEHOLDER_PATTERN, (placeholder) => {
+        const replacement = replacements.get(placeholder);
+        if (replacement === undefined) {
+          throwUnresolvedPlaceholder();
+        }
+        return replacement;
+      });
+      if (rendered.includes(RELATION_PLACEHOLDER_PREFIX)) {
+        throwUnresolvedPlaceholder();
+      }
+      return rendered;
+    }
+  };
+}
+function renderDuckLakeSourceRelation(options, source) {
+  const snapshotId = parseVersionId(source.versionId);
+  const tableName = encodeDatasetTableName(source.datasetId);
+  return `(SELECT * FROM ${qualifiedTableName(options, tableName)} AT (VERSION => ${snapshotId}))`;
+}
+function throwUnresolvedPlaceholder() {
+  throw new LakeStorageError17("[SixbDuckLake] SQL transform contains an unresolved relation placeholder.");
+}
+
+// src/internal/ducklake-sql-executor.ts
+var DEFAULT_PREVIEW_LIMIT = 100;
+var MAX_PREVIEW_LIMIT = 1000;
+
+class DuckLakeSqlExecutor {
+  options;
+  connections;
+  datasets;
+  snapshots;
+  writes;
+  dialect = "duckdb";
+  capabilities = {
+    preview: true,
+    supportsAppend: true,
+    supportsSnapshot: true
+  };
+  constructor(options, connections, datasets, snapshots, writes) {
+    this.options = options;
+    this.connections = connections;
+    this.datasets = datasets;
+    this.snapshots = snapshots;
+    this.writes = writes;
+  }
+  async* preview(input) {
+    this.connections.assertOpen();
+    const rows = await this.connections.withAttachedRuntime(async (runtime) => {
+      const sources = await this.resolveSources(runtime, input.sources);
+      const sql = renderDuckLakeSqlTransformSql({
+        options: this.options,
+        sources: sources.relations,
+        sql: input.sql
+      });
+      return runtime.query(buildPreviewSql(sql, previewLimit(input.limit)));
+    });
+    for (const row of rows) {
+      yield normalizePreviewRow(row);
+    }
+  }
+  async execute(input) {
+    this.connections.assertOpen();
+    assertDatasetWriteMode(input.mode, "SQL transform");
+    return this.writes.withCommitRuntime(async (runtime) => {
+      const target = await this.resolveTargetDataset(runtime, input.target);
+      const sources = await this.resolveSources(runtime, input.sources);
+      const sql = renderDuckLakeSqlTransformSql({
+        options: this.options,
+        sources: sources.relations,
+        sql: input.sql
+      });
+      await this.assertResultSchemaMatchesTarget(runtime, target, sql);
+      return this.writes.commitDatasetVersionOnExclusiveRuntime(runtime, {
+        dataset: target,
+        mode: input.mode,
+        expectedLatestVersionId: input.expectedLatestVersionId,
+        commitMessage: input.commitMessage ?? `execute SQL transform for dataset ${target.id}`,
+        producer: input.producer,
+        inputs: sources.inputs,
+        applyChanges: (runtime2, context) => this.applySqlTransform({
+          runtime: runtime2,
+          target,
+          mode: input.mode,
+          sql,
+          previousRowCount: context.previousRowCount
+        })
+      });
+    });
+  }
+  async resolveSources(runtime, sources) {
+    const relations = Object.create(null);
+    const inputs = [];
+    for (const [sourceName, source] of Object.entries(sources)) {
+      const definition = await this.resolveSourceDataset(runtime, source.dataset);
+      const versionRef = await this.resolveSourceVersion(runtime, definition, source.versionId);
+      relations[sourceName] = {
+        datasetId: definition.id,
+        versionId: versionRef.versionId
+      };
+      inputs.push({
+        datasetId: definition.id,
+        versionId: versionRef.versionId
+      });
+    }
+    return {
+      relations: Object.freeze(relations),
+      inputs: Object.freeze(inputs)
+    };
+  }
+  async resolveSourceDataset(runtime, dataset) {
+    const definition = await this.datasets.getDatasetOnRuntime(runtime, dataset.id);
+    if (!definition) {
+      throw new LakeStorageError18(`[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 LakeStorageError18(`[SixbDuckLake] Unknown SQL transform target dataset '${dataset.id}'.`);
+    }
+    this.datasets.assertSchema(definition);
+    return definition;
+  }
+  async resolveSourceVersion(runtime, dataset, versionId) {
+    if (versionId !== undefined) {
+      const snapshotId = parseVersionId(versionId);
+      const versionRef = await this.snapshots.getVersionRefForSnapshot(runtime, dataset, snapshotId);
+      if (versionRef) {
+        return versionRef;
+      }
+      throwNoCommittedSourceVersion(dataset.id);
+    }
+    const latestVersionRef = await this.snapshots.getLatestVersionRefForDefinition(runtime, dataset);
+    if (latestVersionRef) {
+      return latestVersionRef;
+    }
+    throwNoCommittedSourceVersion(dataset.id);
+  }
+  async assertResultSchemaMatchesTarget(runtime, target, sql) {
+    const rows = await runtime.query(`DESCRIBE SELECT * FROM (${sql}) AS sixb_sql_transform_result_schema`);
+    const actualColumns = rows.map((row) => resultColumnFromDescribeRow(row));
+    const expectedColumns = target.schema.columns;
+    if (actualColumns.length !== expectedColumns.length) {
+      throwResultSchemaMismatch(target.id, `expected ${expectedColumns.length} columns, got ${actualColumns.length}`);
+    }
+    for (let index = 0;index < expectedColumns.length; index += 1) {
+      const expected = expectedColumns[index];
+      const actual = actualColumns[index];
+      if (actual.name !== expected.name) {
+        throwResultSchemaMismatch(target.id, `column ${index + 1} should be '${expected.name}', got '${actual.name}'`);
+      }
+      if (actual.type !== expected.type) {
+        throwResultSchemaMismatch(target.id, `column '${expected.name}' should have type '${expected.type}', got '${actual.type}'`);
+      }
+    }
+  }
+  async applySqlTransform(input) {
+    const tempTableName = `sixb_sql_transform_${randomUUID3().replaceAll("-", "")}`;
+    const tempTable = quoteIdentifier(tempTableName);
+    await input.runtime.run(`CREATE TEMP TABLE ${tempTable} AS SELECT * FROM (${input.sql}) AS sixb_sql_transform_result`);
+    let result;
+    try {
+      result = await applyDatasetRowsFromRelation({
+        options: this.options,
+        runtime: input.runtime,
+        dataset: input.target,
+        mode: input.mode,
+        sourceRelationSql: tempTable,
+        previousRowCount: input.previousRowCount
+      });
+    } catch (error) {
+      try {
+        await input.runtime.run(`DROP TABLE IF EXISTS ${tempTable}`);
+      } catch {}
+      throw error;
+    }
+    await input.runtime.run(`DROP TABLE IF EXISTS ${tempTable}`);
+    return result;
+  }
+}
+function previewLimit(limit) {
+  if (limit === undefined || !Number.isFinite(limit)) {
+    return DEFAULT_PREVIEW_LIMIT;
+  }
+  return Math.min(Math.max(0, Math.trunc(limit)), MAX_PREVIEW_LIMIT);
+}
+function buildPreviewSql(sql, limit) {
+  return `SELECT * FROM (${sql}) AS sixb_sql_transform_preview LIMIT ${limit}`;
+}
+function resultColumnFromDescribeRow(row) {
+  const name = getString(row, "column_name");
+  const type = duckDbTypeToDatasetColumnType(getString(row, "column_type"));
+  return { name, type };
+}
+function normalizePreviewRow(row) {
+  const normalized = {};
+  for (const [key, value] of Object.entries(row)) {
+    normalized[key] = normalizePreviewValue(value);
+  }
+  return normalized;
+}
+function normalizePreviewValue(value) {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => normalizePreviewValue(item));
+  }
+  if (typeof value === "object" && value !== null) {
+    const normalized = {};
+    for (const [key, child] of Object.entries(value)) {
+      normalized[key] = normalizePreviewValue(child);
+    }
+    return normalized;
+  }
+  return value;
+}
+function throwNoCommittedSourceVersion(datasetId) {
+  throw new LakeStorageError18(`[SixbDuckLake] No committed version found for SQL transform source dataset '${datasetId}'.`);
+}
+function throwResultSchemaMismatch(datasetId, detail) {
+  throw new LakeStorageError18(`[SixbDuckLake] SQL transform result schema does not match target dataset '${datasetId}': ${detail}.`);
+}
+
+// src/internal/ducklake-write-coordinator.ts
+import { randomUUID as randomUUID5 } from "crypto";
+import { LakeStorageError as LakeStorageError20 } from "@sixb/core/lake-storage";
+
+// src/internal/ducklake-write-session.ts
+import { randomUUID as randomUUID4 } from "crypto";
+import { getDatasetRowValidationError } from "@sixb/core";
+import { LakeStorageError as LakeStorageError19 } from "@sixb/core/lake-storage";
+
+// src/internal/row-appender.ts
+function appendDatasetRow(appender, schema, row) {
+  for (const column of schema.columns) {
+    appendColumnValue(appender, column, row[column.name] ?? null);
+  }
+  appender.endRow();
+}
+function appendColumnValue(appender, column, value) {
+  if (value === null || value === undefined) {
+    appender.appendNull();
+    return;
+  }
+  switch (column.type) {
+    case "string":
+      appender.appendVarchar(value);
+      return;
+    case "boolean":
+      appender.appendBoolean(value);
+      return;
+    case "int64":
+      appender.appendBigInt(typeof value === "bigint" ? value : BigInt(value));
+      return;
+    case "float64":
+      appender.appendDouble(value);
+      return;
+    case "decimal":
+      appender.appendVarchar(normalizeDuckDbDecimalValue(value, column.name));
+      return;
+    case "date":
+      appender.appendVarchar(value instanceof Date ? value.toISOString().slice(0, 10) : String(value));
+      return;
+    case "timestamp":
+      appender.appendVarchar(value instanceof Date ? value.toISOString() : String(value));
+      return;
+    case "json":
+      appender.appendVarchar(JSON.stringify(value));
+      return;
+    case "fileRef":
+      appender.appendStruct(fileRefToDuckDbStruct(value));
+      return;
+  }
+}
+function fileRefToDuckDbStruct(fileRef) {
+  return {
+    blobId: fileRef.blobId,
+    digest: fileRef.digest,
+    sizeBytes: BigInt(fileRef.sizeBytes),
+    fileName: fileRef.fileName ?? null,
+    mediaType: fileRef.mediaType ?? null,
+    logicalPath: fileRef.logicalPath ?? null
+  };
+}
+
+// src/internal/ducklake-write-session.ts
+var WRITE_ROW_BATCH_SIZE = 1000;
+async function createDuckLakeWriteSession(input) {
+  const stagingTableName = `sixb_write_${randomUUID4().replaceAll("-", "")}`;
+  await input.runtime.run(`CREATE TEMP TABLE ${quoteIdentifier(stagingTableName)} (${datasetSchemaToDuckDbColumnsSql(input.write.dataset.schema)})`);
+  return new DuckLakeWriteSession(input.commitWrite, input.runtime, input.write, stagingTableName);
+}
+
+class DuckLakeWriteSession {
+  commitWrite;
+  runtime;
+  input;
+  stagingTableName;
+  closed = false;
+  cleanedUp = false;
+  rowsWritten = 0;
+  constructor(commitWrite, runtime, input, stagingTableName) {
+    this.commitWrite = commitWrite;
+    this.runtime = runtime;
+    this.input = input;
+    this.stagingTableName = stagingTableName;
+  }
+  async writeRows(rows) {
+    this.assertOpen();
+    let batch = [];
+    for await (const row of rows) {
+      const validationError = getDatasetRowValidationError(row, this.input.dataset);
+      if (validationError) {
+        throw new LakeStorageError19(`[SixbDuckLake] ${validationError}`);
+      }
+      batch.push(structuredClone(row));
+      if (batch.length >= WRITE_ROW_BATCH_SIZE) {
+        await this.appendBatchToStagingTable(batch);
+        batch = [];
+      }
+    }
+    if (batch.length > 0) {
+      await this.appendBatchToStagingTable(batch);
+    }
+  }
+  async appendBatchToStagingTable(batch) {
+    await this.runtime.withAppender(this.stagingTableName, (appender) => {
+      for (const row of batch) {
+        appendDatasetRow(appender, this.input.dataset.schema, row);
+      }
+    });
+    this.rowsWritten += batch.length;
+  }
+  async commit(input) {
+    this.assertOpen();
+    this.closed = true;
+    let committed = false;
+    try {
+      const result = await this.commitWrite({
+        write: this.input,
+        commit: input,
+        rowsWritten: this.rowsWritten,
+        stagingTableName: this.stagingTableName
+      });
+      committed = true;
+      await this.cleanup();
+      return result;
+    } catch (error) {
+      if (!committed) {
+        await this.cleanup();
+      }
+      throw error;
+    }
+  }
+  async abort() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    await this.cleanup();
+  }
+  assertOpen() {
+    if (this.closed) {
+      throw new LakeStorageError19("[SixbDuckLake] Write session is already closed.");
+    }
+  }
+  async cleanup() {
+    if (this.cleanedUp) {
+      return;
+    }
+    this.cleanedUp = true;
+    await this.dropStagingTable();
+  }
+  async dropStagingTable() {
+    try {
+      await this.runtime.run(`DROP TABLE IF EXISTS ${quoteIdentifier(this.stagingTableName)}`);
+    } catch {}
+  }
+}
+
+// src/internal/ducklake-write-coordinator.ts
+class DuckLakeWriteCoordinator {
+  options;
+  connections;
+  datasets;
+  snapshots;
+  constructor(options, connections, datasets, snapshots) {
+    this.options = options;
+    this.connections = connections;
+    this.datasets = datasets;
+    this.snapshots = snapshots;
+  }
+  async beginWrite(input) {
+    this.connections.assertOpen();
+    const definition = await this.datasets.getDataset(input.dataset.id);
+    if (!definition) {
+      throw new LakeStorageError20(`[SixbDuckLake] Unknown dataset '${input.dataset.id}'.`);
+    }
+    this.datasets.assertSchema(definition);
+    const mode = input.mode ?? "snapshot";
+    assertDatasetWriteMode(mode, "write");
+    const runtime = await this.connections.stagingRuntime();
+    return createDuckLakeWriteSession({
+      commitWrite: (options) => this.commitWrite(options),
+      runtime,
+      write: {
+        ...input,
+        dataset: definition,
+        mode
+      }
+    });
+  }
+  async commitWrite(input) {
+    const definition = await this.datasets.getDataset(input.write.dataset.id);
+    if (!definition) {
+      throw new LakeStorageError20(`[SixbDuckLake] Unknown dataset '${input.write.dataset.id}'.`);
+    }
+    const mode = input.write.mode ?? "snapshot";
+    assertDatasetWriteMode(mode, "write");
+    return this.commitDatasetVersion({
+      dataset: definition,
+      mode,
+      expectedLatestVersionId: input.commit?.expectedLatestVersionId,
+      commitMessage: input.commit?.commitMessage ?? `write dataset ${input.write.dataset.id}`,
+      producer: input.write.producer,
+      inputs: input.write.inputs,
+      applyChanges: (runtime, context) => this.applyStagedRows({
+        ...input,
+        runtime,
+        previousRowCount: context.previousRowCount
+      })
+    });
+  }
+  async commitDatasetVersion(input) {
+    return this.withCommitRuntime((runtime) => this.commitDatasetVersionOnExclusiveRuntime(runtime, input));
+  }
+  async withCommitRuntime(run) {
+    return withCatalogCommitLock(this.options, async () => {
+      return this.connections.withExclusiveAttached(run);
+    });
+  }
+  async commitDatasetVersionOnExclusiveRuntime(runtime, input) {
+    const runtimeInput = { ...input, runtime };
+    return this.withGuardedRetrySetting(runtimeInput, () => this.commitDatasetVersionUnlocked(runtimeInput));
+  }
+  async withGuardedRetrySetting(input, run) {
+    if (input.expectedLatestVersionId === undefined) {
+      return run();
+    }
+    await input.runtime.run("SET ducklake_max_retry_count = 0");
+    let outcome;
+    try {
+      outcome = { kind: "success", value: await run() };
+    } catch (error) {
+      outcome = { kind: "error", error };
+    }
+    try {
+      await input.runtime.run("RESET ducklake_max_retry_count");
+    } catch {
+      this.connections.poisonRuntime();
+    }
+    if (outcome.kind === "error") {
+      throw outcome.error;
+    }
+    return outcome.value;
+  }
+  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);
+      if (input.expectedLatestVersionId !== undefined) {
+        this.assertExpectedLatestVersion({
+          datasetId: input.dataset.id,
+          expectedLatestVersionId: input.expectedLatestVersionId,
+          actualLatestVersionId: latestVersion?.versionId ?? null
+        });
+      }
+      const changeResult = await input.applyChanges(input.runtime, {
+        previousRowCount: latestVersion?.rowCount
+      });
+      const commitId = randomUUID5();
+      await this.setCommitMetadata(input, commitId, commitRowCount(input, changeResult, latestVersion));
+      await input.runtime.run("COMMIT");
+      committed = true;
+      const committedWriteSnapshotId = await this.lastCommittedSnapshotId(input.runtime);
+      try {
+        return await this.versionForCommittedWrite({
+          ...input,
+          commitId,
+          previousWriteSnapshotId,
+          committedWriteSnapshotId,
+          changeResult
+        });
+      } finally {
+        await this.connections.detachLocalCatalogAfterCommit(input.runtime);
+      }
+    } catch (error) {
+      if (!committed) {
+        await this.rollbackTransaction(input.runtime);
+      }
+      throw error;
+    }
+  }
+  async versionForCommittedWrite(input) {
+    const ownSnapshotId = await this.findOwnSnapshotId(input.runtime, input.dataset.id, input.commitId, input.previousWriteSnapshotId, input.committedWriteSnapshotId);
+    if (ownSnapshotId !== null) {
+      const version = await this.snapshots.getVersionForSnapshot(input.runtime, input.dataset, ownSnapshotId);
+      if (version) {
+        return { ...version, outcome: "created" };
+      }
+      throw new LakeStorageError20(`[SixbDuckLake] DuckLake committed snapshot '${ownSnapshotId}' for dataset '${input.dataset.id}', but Sixb could not hydrate it as a dataset version.`);
+    }
+    if (!input.changeResult.dataChangeExpected) {
+      return {
+        ...await this.versionForNoOpCommit(input.runtime, input.dataset),
+        outcome: "unchanged"
+      };
+    }
+    if (input.committedWriteSnapshotId === input.previousWriteSnapshotId) {
+      throw new LakeStorageError20(`[SixbDuckLake] DuckLake commit for dataset '${input.dataset.id}' completed without producing a snapshot for this non-empty write.`);
+    }
+    throw new LakeStorageError20(`[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";
+    const result = await applyDatasetRowsFromRelation({
+      options: this.options,
+      runtime: input.runtime,
+      dataset: input.write.dataset,
+      mode,
+      sourceRelationSql: quoteIdentifier(input.stagingTableName),
+      previousRowCount: input.previousRowCount
+    });
+    if (result.sourceRowCount !== input.rowsWritten) {
+      throw new LakeStorageError20(`[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;
+  }
+  async setCommitMetadata(input, commitId, rowCount) {
+    const metadata = {
+      kind: "datasetVersion",
+      datasetId: input.dataset.id,
+      commitId,
+      mode: input.mode,
+      producer: input.producer ? structuredClone(input.producer) : undefined,
+      inputs: input.inputs ? structuredClone(input.inputs) : undefined,
+      ...rowCount.kind === "exact" ? { rowCount: rowCount.value } : {}
+    };
+    await input.runtime.run(`CALL ${quoteIdentifier(duckLakeAlias(this.options))}.set_commit_message(${quoteSqlString("Sixb")}, ${quoteSqlString(input.commitMessage)}, extra_info => ${quoteSqlString(JSON.stringify({ sixb: metadata }))})`);
+  }
+  async versionForNoOpCommit(runtime, definition) {
+    const latestVersion = await this.snapshots.getLatestVersionForDefinition(runtime, definition);
+    if (latestVersion) {
+      return latestVersion;
+    }
+    throw new LakeStorageError20(`[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;
+    }
+    return this.snapshots.getLatestVersionSummaryForDefinition(input.runtime, input.dataset);
+  }
+  async lastCommittedSnapshotId(runtime) {
+    const [row] = await runtime.query(`SELECT id FROM ${quoteIdentifier(duckLakeAlias(this.options))}.last_committed_snapshot()`);
+    if (row === undefined || row.id === null || row.id === undefined) {
+      return null;
+    }
+    return String(getBigIntLike(row, "id"));
+  }
+  async findSnapshotIdByCommitId(runtime, datasetId, commitId, snapshotId) {
+    if (snapshotId !== undefined) {
+      assertDuckLakeSnapshotId3(snapshotId);
+    }
+    const ducklakeSnapshotChanges = duckLakeMetadataTableName(this.options, "ducklake_snapshot_changes");
+    const whereSql = snapshotId === undefined ? "" : `WHERE snapshot_id = ${snapshotId}`;
+    const orderSql = snapshotId === undefined ? "ORDER BY snapshot_id DESC" : "";
+    const rows = await runtime.query(`
+      SELECT snapshot_id, commit_extra_info
+      FROM ${ducklakeSnapshotChanges}
+      ${whereSql}
+      ${orderSql}
+    `);
+    for (const row of rows) {
+      const metadata = parseCommitMetadata(row.commit_extra_info);
+      if (metadata?.datasetId === datasetId && metadata.commitId === commitId) {
+        return String(getBigIntLike(row, "snapshot_id"));
+      }
+    }
+    return null;
+  }
+  async findOwnSnapshotId(runtime, datasetId, commitId, previousWriteSnapshotId, committedWriteSnapshotId) {
+    if (committedWriteSnapshotId === null || committedWriteSnapshotId === previousWriteSnapshotId) {
+      return null;
+    }
+    const exactMatch = await this.findSnapshotIdByCommitId(runtime, datasetId, commitId, committedWriteSnapshotId);
+    if (exactMatch !== null) {
+      return exactMatch;
+    }
+    return this.findSnapshotIdByCommitId(runtime, datasetId, commitId);
+  }
+  assertExpectedLatestVersion(input) {
+    if (input.expectedLatestVersionId === undefined) {
+      return;
+    }
+    if (input.actualLatestVersionId !== input.expectedLatestVersionId) {
+      throw new LakeStorageError20(`[SixbDuckLake] Optimistic commit failed for dataset '${input.datasetId}': expected latest version '${input.expectedLatestVersionId}', found '${input.actualLatestVersionId ?? "none"}'.`);
+    }
+  }
+}
+function commitRowCount(input, changeResult, latestVersion) {
+  if (input.mode === "append" && input.expectedLatestVersionId === undefined) {
+    return { kind: "unknown" };
+  }
+  if (changeResult.resultingRowCount.kind === "exact") {
+    return changeResult.resultingRowCount;
+  }
+  if (input.mode === "append" && latestVersion === null) {
+    return { kind: "exact", value: changeResult.sourceRowCount };
+  }
+  return { kind: "unknown" };
+}
+function assertDuckLakeSnapshotId3(snapshotId) {
+  if (!/^\d+$/.test(snapshotId)) {
+    throw new LakeStorageError20(`[SixbDuckLake] Invalid DuckLake snapshot id '${snapshotId}'.`);
+  }
+}
+var localCatalogCommitLocks = new Map;
+async function withCatalogCommitLock(options, run) {
+  const key = localCatalogCoordinationKey(options);
+  if (key === undefined) {
+    return run();
+  }
+  const previous = localCatalogCommitLocks.get(key) ?? Promise.resolve();
+  const ready = previous.catch(() => {});
+  let release;
+  const next = new Promise((resolve2) => {
+    release = resolve2;
+  });
+  const current = ready.then(() => next);
+  localCatalogCommitLocks.set(key, current);
+  await ready;
+  try {
+    return await run();
+  } finally {
+    release();
+    if (localCatalogCommitLocks.get(key) === current) {
+      localCatalogCommitLocks.delete(key);
+    }
+  }
+}
+
+// src/ducklake-storage.ts
+class DuckLakeStorage {
+  standard = { id: "ducklake", version: "1.0" };
+  sql;
+  connections;
+  datasets;
+  maintenance;
+  rows;
+  snapshotReader;
+  writes;
+  constructor(options) {
+    const normalizedOptions = {
+      ...options,
+      alias: options.alias ?? "sixb_lake",
+      createIfNotExists: options.createIfNotExists ?? true,
+      readOnly: options.readOnly ?? false,
+      duckdb: {
+        ...options.duckdb,
+        path: options.duckdb?.path ?? ":memory:"
+      }
+    };
+    this.connections = new DuckLakeConnectionManager(normalizedOptions);
+    this.datasets = new DuckLakeDatasetCatalog(normalizedOptions, this.connections);
+    this.maintenance = new DuckLakeMaintenance(normalizedOptions, this.connections);
+    this.snapshotReader = new DuckLakeSnapshotReader(normalizedOptions, this.connections, this.datasets);
+    this.rows = new DuckLakeRowReader(normalizedOptions, this.connections, this.snapshotReader);
+    this.writes = new DuckLakeWriteCoordinator(normalizedOptions, this.connections, this.datasets, this.snapshotReader);
+    this.sql = new DuckLakeSqlExecutor(normalizedOptions, this.connections, this.datasets, this.snapshotReader, this.writes);
+  }
+  async createDataset(definition) {
+    return this.datasets.createDataset(definition);
+  }
+  async assertDatasetDefinitionsCompatible(definitions) {
+    await this.datasets.assertDatasetDefinitionsCompatible(definitions);
+  }
+  async getDataset(datasetId) {
+    return this.datasets.getDataset(datasetId);
+  }
+  async listDatasets() {
+    return this.datasets.listDatasets();
+  }
+  async listDatasetCatalogState(datasetIds) {
+    return this.snapshotReader.listDatasetCatalogState(datasetIds);
+  }
+  async listVersions(datasetId, limit) {
+    return this.snapshotReader.listVersions(datasetId, limit);
+  }
+  async beginWrite(input) {
+    return this.writes.beginWrite(input);
+  }
+  async getLatestVersion(datasetId) {
+    return this.snapshotReader.getLatestVersion(datasetId);
+  }
+  async getVersion(datasetId, versionId) {
+    return this.snapshotReader.getVersion(datasetId, versionId);
+  }
+  readRows(input) {
+    return this.rows.readRows(input);
+  }
+  async runMaintenance(options) {
+    return this.maintenance.runMaintenance(options);
+  }
+  async close() {
+    await this.connections.close();
+  }
+}
+export {
+  DuckLakeStorage
+};
+
+//# debugId=0B56C838FAF193D864756E2164756E21