@sixb/ducklake 0.0.1

package/dist/internal/catalog-key.d.ts

@@ -0,0 +1,11 @@
+import type { DuckLakeStorageOptions } from "../types";
+/**
+ * Stable key for coordinating local catalog users inside this process.
+ *
+ * PostgreSQL coordinates through the database. In-memory local catalogs have no
+ * shared file identity. File-backed local catalogs need equivalent path
+ * spellings, such as `lake.ducklake` and `dir/../lake.ducklake`, to map to the
+ * same coordination key.
+ */
+export declare function localCatalogCoordinationKey(options: Pick<DuckLakeStorageOptions, "catalog">): string | undefined;
+//# sourceMappingURL=catalog-key.d.ts.map

package/dist/internal/catalog-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog-key.d.ts","sourceRoot":"","sources":["../../src/internal/catalog-key.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAA;AAEtD;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,IAAI,CAAC,sBAAsB,EAAE,SAAS,CAAC,GAC/C,MAAM,GAAG,SAAS,CAcpB"}

package/dist/internal/dataset-row-commit.d.ts

@@ -0,0 +1,26 @@
+import type { DatasetDefinition } from "@sixb/core";
+import { type DatasetWriteMode } from "@sixb/core/lake-storage";
+import type { DuckLakeStorageOptions } from "../types";
+import type { DuckDbQueryRuntime } from "./duckdb-runtime";
+export type CommitRowCount = {
+    readonly kind: "exact";
+    readonly value: number;
+} | {
+    readonly kind: "unknown";
+};
+export interface ApplyDatasetRowsResult {
+    readonly dataChangeExpected: boolean;
+    readonly sourceRowCount: number;
+    readonly resultingRowCount: CommitRowCount;
+}
+export declare function assertDatasetWriteMode(mode: unknown, operation: string): asserts mode is DatasetWriteMode;
+export declare function applyDatasetRowsFromRelation(input: {
+    readonly options: DuckLakeStorageOptions;
+    readonly runtime: DuckDbQueryRuntime;
+    readonly dataset: DatasetDefinition;
+    readonly mode: DatasetWriteMode;
+    /** Provider-rendered relation SQL, such as a quoted staging or temp table. */
+    readonly sourceRelationSql: string;
+    readonly previousRowCount?: number;
+}): Promise<ApplyDatasetRowsResult>;
+//# sourceMappingURL=dataset-row-commit.d.ts.map

package/dist/internal/dataset-row-commit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataset-row-commit.d.ts","sourceRoot":"","sources":["../../src/internal/dataset-row-commit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AACnD,OAAO,EAAE,KAAK,gBAAgB,EAAoB,MAAM,yBAAyB,CAAA;AACjF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAA;AAEtD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAK1D,MAAM,MAAM,cAAc,GACtB;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAClD;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;CAAE,CAAA;AAEhC,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,kBAAkB,EAAE,OAAO,CAAA;IACpC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAC/B,QAAQ,CAAC,iBAAiB,EAAE,cAAc,CAAA;CAC3C;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,OAAO,EACb,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,IAAI,IAAI,gBAAgB,CAMlC;AAED,wBAAsB,4BAA4B,CAAC,KAAK,EAAE;IACxD,QAAQ,CAAC,OAAO,EAAE,sBAAsB,CAAA;IACxC,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAA;IACpC,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAA;IACnC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAA;IAC/B,8EAA8E;IAC9E,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAA;IAClC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;CACnC,GAAG,OAAO,CAAC,sBAAsB,CAAC,CA0ClC"}

package/dist/internal/duckdb-column-types.d.ts

@@ -0,0 +1,45 @@
+import type { DatasetColumnType } from "@sixb/core";
+interface DuckDbColumnTypeMapping {
+    readonly sql: string;
+    readonly matches: (typeSql: string) => boolean;
+}
+interface DuckDbDecimalTypeMapping extends DuckDbColumnTypeMapping {
+    readonly precision: number;
+    readonly scale: number;
+}
+/**
+ * DuckDB representations used for every Sixb dataset column type.
+ *
+ * Each entry owns both its CREATE TABLE representation and the metadata
+ * spellings accepted when reconstructing a Sixb dataset schema.
+ */
+export declare const DUCKDB_COLUMN_TYPES: {
+    string: DuckDbColumnTypeMapping & {
+        readonly sql: "VARCHAR";
+    };
+    boolean: DuckDbColumnTypeMapping & {
+        readonly sql: "BOOLEAN";
+    };
+    int64: DuckDbColumnTypeMapping & {
+        readonly sql: "BIGINT";
+    };
+    float64: DuckDbColumnTypeMapping & {
+        readonly sql: "DOUBLE";
+    };
+    decimal: DuckDbDecimalTypeMapping;
+    date: DuckDbColumnTypeMapping & {
+        readonly sql: "DATE";
+    };
+    timestamp: DuckDbColumnTypeMapping & {
+        readonly sql: "TIMESTAMPTZ";
+    };
+    json: DuckDbColumnTypeMapping & {
+        readonly sql: "JSON";
+    };
+    fileRef: DuckDbColumnTypeMapping & {
+        readonly sql: "STRUCT(blobId VARCHAR, digest VARCHAR, sizeBytes BIGINT, fileName VARCHAR, mediaType VARCHAR, logicalPath VARCHAR)";
+    };
+};
+export declare function findDatasetColumnTypeForDuckDbSql(typeSql: string): DatasetColumnType | undefined;
+export {};
+//# sourceMappingURL=duckdb-column-types.d.ts.map

package/dist/internal/duckdb-column-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duckdb-column-types.d.ts","sourceRoot":"","sources":["../../src/internal/duckdb-column-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAEnD,UAAU,uBAAuB;IAC/B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAA;CAC/C;AAED,UAAU,wBAAyB,SAAQ,uBAAuB;IAChE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CACvB;AA6BD;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;CAY8B,CAAA;AAE9D,wBAAgB,iCAAiC,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS,CAQhG"}

package/dist/internal/duckdb-decimal.d.ts

@@ -0,0 +1,6 @@
+import { type DecimalValue } from "@sixb/core";
+/**
+ * Normalize a dataset decimal and reject values DuckDB would round or overflow.
+ */
+export declare function normalizeDuckDbDecimalValue(value: unknown, columnName: string): DecimalValue;
+//# sourceMappingURL=duckdb-decimal.d.ts.map

package/dist/internal/duckdb-decimal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duckdb-decimal.d.ts","sourceRoot":"","sources":["../../src/internal/duckdb-decimal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAyB,MAAM,YAAY,CAAA;AAOrE;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,GAAG,YAAY,CAyB5F"}

package/dist/internal/duckdb-row.d.ts

@@ -0,0 +1,8 @@
+export type DuckDbRow = Readonly<Record<string, unknown>>;
+export declare function getString(row: DuckDbRow, key: string): string;
+export declare function getOptionalString(row: DuckDbRow, key: string): string | undefined;
+export declare function getBoolean(row: DuckDbRow, key: string): boolean;
+export declare function getBigIntLike(row: DuckDbRow, key: string): bigint;
+export declare function getOptionalBigIntLike(row: DuckDbRow, key: string): bigint | undefined;
+export declare function getDate(row: DuckDbRow, key: string): Date;
+//# sourceMappingURL=duckdb-row.d.ts.map

package/dist/internal/duckdb-row.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duckdb-row.d.ts","sourceRoot":"","sources":["../../src/internal/duckdb-row.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,SAAS,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;AAEzD,wBAAgB,SAAS,CAAC,GAAG,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAS7D;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAajF;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAS/D;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAiBjE;AAED,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAOrF;AAED,wBAAgB,OAAO,CAAC,GAAG,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAazD"}

package/dist/internal/duckdb-runtime.d.ts

@@ -0,0 +1,63 @@
+import { type DuckDBValue } from "@duckdb/node-api";
+import type { DuckDbRuntimeOptions, DuckLakeStorageOptions } from "../types";
+/**
+ * Narrow adapter around `@duckdb/node-api`.
+ *
+ * Keeping the public provider behind this interface confines the driver types to
+ * this module instead of leaking them into `DuckLakeStorage`. Calls on a runtime
+ * are serialized through one queue because a runtime owns one DuckDB connection.
+ */
+export interface DuckDbQueryRuntime {
+    run(sql: string, values?: readonly DuckDBValue[]): Promise<void>;
+    runStatements(statements: readonly string[]): Promise<void>;
+    query(sql: string, values?: readonly DuckDBValue[]): Promise<readonly Record<string, unknown>[]>;
+    withAppender<T>(tableName: string, useAppender: (appender: DuckDbAppender) => T | Promise<T>): Promise<T>;
+}
+export interface DuckDbRuntime extends DuckDbQueryRuntime {
+    streamRows(sql: string, values?: readonly DuckDBValue[]): AsyncIterable<Record<string, unknown>>;
+    /**
+     * Reserve the runtime queue for a multi-statement critical section.
+     *
+     * Use this for sequences such as BEGIN/read metadata/write/COMMIT where an
+     * interleaved read or write would observe the wrong connection state.
+     */
+    withExclusive<T>(useRuntime: (runtime: DuckDbExclusiveRuntime) => Promise<T>): Promise<T>;
+    close(): Promise<void>;
+}
+/**
+ * Runtime surface available while the caller already owns the queue slot.
+ *
+ * This is the query/appender subset only: no streaming, no close, and no nested
+ * exclusive block.
+ */
+export type DuckDbExclusiveRuntime = DuckDbQueryRuntime;
+export interface DuckDbAppender {
+    appendNull(): void;
+    appendBoolean(value: boolean): void;
+    appendVarchar(value: string): void;
+    appendBigInt(value: bigint): void;
+    appendDouble(value: number): void;
+    appendStruct(value: Readonly<Record<string, DuckDBValue>>): void;
+    endRow(): void;
+}
+interface SetupDuckLakeOptions {
+    readonly installExtensions?: boolean;
+    readonly attach?: boolean;
+}
+/**
+ * Create the DuckDB runtime used by the provider.
+ */
+export declare function createDuckDbRuntime(options?: DuckDbRuntimeOptions): Promise<DuckDbRuntime>;
+/**
+ * Install DuckLake and any catalog/data-path extensions into DuckDB's local
+ * extension directory. Installation is idempotent and can be shared by many
+ * short-lived runtimes created by one provider instance.
+ */
+export declare function installDuckLakeExtensions(runtime: DuckDbRuntime, options: DuckLakeStorageOptions): Promise<void>;
+/**
+ * Load DuckLake, load catalog extensions, run caller setup SQL, and optionally
+ * attach the configured DuckLake catalog.
+ */
+export declare function setupDuckLake(runtime: DuckDbRuntime, options: DuckLakeStorageOptions, setupOptions?: SetupDuckLakeOptions): Promise<void>;
+export {};
+//# sourceMappingURL=duckdb-runtime.d.ts.map

package/dist/internal/duckdb-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duckdb-runtime.d.ts","sourceRoot":"","sources":["../../src/internal/duckdb-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,WAAW,EAEjB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,KAAK,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAA;AAW5E;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IACjC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,SAAS,WAAW,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAChE,aAAa,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAC3D,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,SAAS,WAAW,EAAE,GAAG,OAAO,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAAA;IAChG,YAAY,CAAC,CAAC,EACZ,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,CAAC,QAAQ,EAAE,cAAc,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GACxD,OAAO,CAAC,CAAC,CAAC,CAAA;CACd;AAED,MAAM,WAAW,aAAc,SAAQ,kBAAkB;IACvD,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,SAAS,WAAW,EAAE,GAAG,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IAChG;;;;;OAKG;IACH,aAAa,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,OAAO,EAAE,sBAAsB,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;IACzF,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACvB;AAED;;;;;GAKG;AACH,MAAM,MAAM,sBAAsB,GAAG,kBAAkB,CAAA;AAEvD,MAAM,WAAW,cAAc;IAC7B,UAAU,IAAI,IAAI,CAAA;IAClB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAA;IACnC,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IAClC,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACjC,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACjC,YAAY,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,GAAG,IAAI,CAAA;IAChE,MAAM,IAAI,IAAI,CAAA;CACf;AAED,UAAU,oBAAoB;IAC5B,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAA;IACpC,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAC1B;AAsND;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,aAAa,CAAC,CAGxB;AAED;;;;GAIG;AACH,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,sBAAsB,GAC9B,OAAO,CAAC,IAAI,CAAC,CAMf;AAED;;;GAGG;AACH,wBAAsB,aAAa,CACjC,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,sBAAsB,EAC/B,YAAY,GAAE,oBAAyB,GACtC,OAAO,CAAC,IAAI,CAAC,CA8Bf"}

package/dist/internal/duckdb-value-converter.d.ts

@@ -0,0 +1,7 @@
+import { type DuckDBValueConverter, type JS } from "@duckdb/node-api";
+/**
+ * Preserve DuckDB decimals as exact strings while retaining the driver's normal
+ * JavaScript conversions for every other scalar and nested value.
+ */
+export declare const sixbDuckDbValueConverter: DuckDBValueConverter<JS>;
+//# sourceMappingURL=duckdb-value-converter.d.ts.map

package/dist/internal/duckdb-value-converter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duckdb-value-converter.d.ts","sourceRoot":"","sources":["../../src/internal/duckdb-value-converter.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,oBAAoB,EACzB,KAAK,EAAE,EAER,MAAM,kBAAkB,CAAA;AAGzB;;;GAGG;AACH,eAAO,MAAM,wBAAwB,EAAE,oBAAoB,CAAC,EAAE,CAa7D,CAAA"}

package/dist/internal/ducklake-catalog-schema.d.ts

@@ -0,0 +1,12 @@
+import type { DatasetSchema } from "@sixb/core";
+export interface DuckLakeCatalogColumn {
+    readonly tableName: string;
+    readonly columnId: bigint;
+    readonly columnOrder: bigint;
+    readonly columnName: string;
+    readonly columnType: string;
+    readonly nullsAllowed: boolean;
+    readonly parentColumnId?: bigint;
+}
+export declare function duckLakeCatalogColumnsToDatasetSchema(tableName: string, rows: readonly DuckLakeCatalogColumn[]): DatasetSchema;
+//# sourceMappingURL=ducklake-catalog-schema.d.ts.map

package/dist/internal/ducklake-catalog-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ducklake-catalog-schema.d.ts","sourceRoot":"","sources":["../../src/internal/ducklake-catalog-schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA2B,aAAa,EAAE,MAAM,YAAY,CAAA;AAIxE,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAA;IAC9B,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CACjC;AAWD,wBAAgB,qCAAqC,CACnD,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,SAAS,qBAAqB,EAAE,GACrC,aAAa,CAoBf"}

package/dist/internal/ducklake-connection-manager.d.ts

@@ -0,0 +1,67 @@
+import type { DuckLakeStorageOptions } from "../types";
+import { type DuckDbExclusiveRuntime, type DuckDbQueryRuntime, type DuckDbRuntime } from "./duckdb-runtime";
+export interface DuckLakeAttachedRuntimeLease {
+    readonly runtime: DuckDbRuntime;
+    release(): Promise<void>;
+}
+/**
+ * Owns DuckDB/DuckLake runtime lifecycle for DuckLakeStorage.
+ *
+ * A storage instance owns one DuckDB runtime and at most one DuckLake
+ * attachment. The runtime starts unattached so construction and non-lake setup
+ * do not immediately open DuckLake metadata connections; reads and commits
+ * attach lazily through `attachedRuntime()`.
+ */
+export declare class DuckLakeConnectionManager {
+    private readonly options;
+    private runtimePromise;
+    private installExtensionsPromise;
+    private attachPromise;
+    private refreshPromise;
+    private localAttachmentLock;
+    private observedLocalCatalogGeneration;
+    private attached;
+    private closed;
+    private runtimePoisoned;
+    constructor(options: DuckLakeStorageOptions);
+    assertOpen(): void;
+    runtime(): Promise<DuckDbRuntime>;
+    attachedRuntime(): Promise<DuckDbRuntime>;
+    withAttachedRuntime<T>(run: (runtime: DuckDbRuntime) => Promise<T>): Promise<T>;
+    acquireAttachedRuntime(): Promise<DuckLakeAttachedRuntimeLease>;
+    withExclusiveAttached<T>(run: (runtime: DuckDbExclusiveRuntime) => Promise<T>): Promise<T>;
+    stagingRuntime(): Promise<DuckDbRuntime>;
+    /**
+     * Create the one runtime owned by this manager. Setup loads extensions,
+     * secrets, setup SQL, and pre-attach Postgres pool settings, but deliberately
+     * leaves DuckLake unattached until `attachedRuntime()` is needed.
+     */
+    createRuntime(): Promise<DuckDbRuntime>;
+    resetRuntime(): Promise<void>;
+    private resetRuntimeUnlocked;
+    refreshForExternalChanges(): Promise<void>;
+    markLocalCatalogChanged(): void;
+    detachLocalCatalogAfterCommit(runtime: DuckDbQueryRuntime): Promise<void>;
+    private refreshForExternalChangesUnlocked;
+    private needsLocalCatalogRefresh;
+    close(): Promise<void>;
+    private ensureAttached;
+    private ensureExtensionsInstalled;
+    private attachRuntime;
+    private refreshAttachedRuntime;
+    private detachRuntime;
+    /**
+     * Mark the active runtime as unusable for reuse. The next lease release
+     * discards the connection so session state that could not be cleaned up
+     * (such as a SET pragma whose RESET failed) cannot reach a later operation.
+     */
+    poisonRuntime(): void;
+    private detachDuckDbCatalogAfterLease;
+    private discardRuntimeUnlocked;
+    private detachRuntimeUnlocked;
+    private withLocalAttachmentLock;
+    private acquireLocalAttachmentLock;
+    private closeRuntimePromise;
+    private closeRuntime;
+}
+//# sourceMappingURL=ducklake-connection-manager.d.ts.map

package/dist/internal/ducklake-connection-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ducklake-connection-manager.d.ts","sourceRoot":"","sources":["../../src/internal/ducklake-connection-manager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAA;AAEtD,OAAO,EAEL,KAAK,sBAAsB,EAC3B,KAAK,kBAAkB,EACvB,KAAK,aAAa,EAGnB,MAAM,kBAAkB,CAAA;AAQzB,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAA;IAC/B,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACzB;AAED;;;;;;;GAOG;AACH,qBAAa,yBAAyB;IAcxB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAbpC,OAAO,CAAC,cAAc,CAAoC;IAC1D,OAAO,CAAC,wBAAwB,CAA2B;IAC3D,OAAO,CAAC,aAAa,CAA2B;IAChD,OAAO,CAAC,cAAc,CAA2B;IAIjD,OAAO,CAAC,mBAAmB,CAAmC;IAC9D,OAAO,CAAC,8BAA8B,CAAQ;IAC9C,OAAO,CAAC,QAAQ,CAAQ;IACxB,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,eAAe,CAAQ;gBAEF,OAAO,EAAE,sBAAsB;IAI5D,UAAU,IAAI,IAAI;IAMZ,OAAO,IAAI,OAAO,CAAC,aAAa,CAAC;IAgBjC,eAAe,IAAI,OAAO,CAAC,aAAa,CAAC;IAMzC,mBAAmB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAS/E,sBAAsB,IAAI,OAAO,CAAC,4BAA4B,CAAC;IAoC/D,qBAAqB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,OAAO,EAAE,sBAAsB,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAS1F,cAAc,IAAI,OAAO,CAAC,aAAa,CAAC;IAa9C;;;;OAIG;IACG,aAAa,IAAI,OAAO,CAAC,aAAa,CAAC;IAoBvC,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;YASrB,oBAAoB;IAuC5B,yBAAyB,IAAI,OAAO,CAAC,IAAI,CAAC;IAwBhD,uBAAuB,IAAI,IAAI;IAQzB,6BAA6B,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;YAgBjE,iCAAiC;IAW/C,OAAO,CAAC,wBAAwB;IAI1B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAkBd,cAAc;YAgCd,yBAAyB;YAgBzB,aAAa;YASb,sBAAsB;YAUtB,aAAa;IAI3B;;;;OAIG;IACH,aAAa,IAAI,IAAI;YAIP,6BAA6B;YAmB7B,sBAAsB;YAOtB,qBAAqB;YAcrB,uBAAuB;YASvB,0BAA0B;YAyB1B,mBAAmB;YAqBnB,YAAY;CAe3B"}

package/dist/internal/ducklake-current-dataset-definitions.d.ts

@@ -0,0 +1,10 @@
+import type { DatasetDefinition } from "@sixb/core";
+import type { DuckLakeStorageOptions } from "../types";
+import type { DuckDbQueryRuntime } from "./duckdb-runtime";
+export interface ReadCurrentDatasetDefinitionsInput {
+    readonly options: DuckLakeStorageOptions;
+    readonly runtime: DuckDbQueryRuntime;
+    readonly datasetIds?: readonly string[];
+}
+export declare function readCurrentDatasetDefinitions(input: ReadCurrentDatasetDefinitionsInput): Promise<Map<string, DatasetDefinition>>;
+//# sourceMappingURL=ducklake-current-dataset-definitions.d.ts.map

package/dist/internal/ducklake-current-dataset-definitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ducklake-current-dataset-definitions.d.ts","sourceRoot":"","sources":["../../src/internal/ducklake-current-dataset-definitions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAEnD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAA;AAQtD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAoB1D,MAAM,WAAW,kCAAkC;IACjD,QAAQ,CAAC,OAAO,EAAE,sBAAsB,CAAA;IACxC,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAA;IACpC,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CACxC;AAED,wBAAsB,6BAA6B,CACjD,KAAK,EAAE,kCAAkC,GACxC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAkCzC"}

package/dist/internal/ducklake-dataset-catalog.d.ts

@@ -0,0 +1,33 @@
+import type { DatasetDefinition, DatasetSchema } from "@sixb/core";
+import type { DuckLakeStorageOptions } from "../types";
+import type { DuckDbQueryRuntime } from "./duckdb-runtime";
+import type { DuckLakeConnectionManager } from "./ducklake-connection-manager";
+/**
+ * Translates between Sixb dataset definitions and DuckLake table metadata.
+ *
+ * DuckLake stays the source of truth for the physical table, schema, comments,
+ * and partitioning. Sixb only decides which definition changes are safe to
+ * translate into DuckLake DDL.
+ */
+export declare class DuckLakeDatasetCatalog {
+    private readonly options;
+    private readonly connections;
+    constructor(options: DuckLakeStorageOptions, connections: DuckLakeConnectionManager);
+    createDataset(definition: DatasetDefinition): Promise<DatasetDefinition>;
+    assertDatasetDefinitionsCompatible(definitions: readonly DatasetDefinition[]): Promise<void>;
+    getDataset(datasetId: string): Promise<DatasetDefinition | null>;
+    getDatasetOnRuntime(runtime: DuckDbQueryRuntime, datasetId: string): Promise<DatasetDefinition | null>;
+    listDatasets(): Promise<readonly DatasetDefinition[]>;
+    private readCurrentDatasetDefinitions;
+    private readCurrentDatasetDefinitionsOnRuntime;
+    getDatasetSchemaAtSnapshot(runtime: DuckDbQueryRuntime, datasetId: string, tableName: string, tableId: bigint, snapshotId: string): Promise<DatasetSchema>;
+    assertSchema(definition: DatasetDefinition): void;
+    private applyExistingDatasetUpdate;
+    private applySchemaEvolutionDdl;
+    private applyMetadataDelta;
+    private applyPartitionBy;
+    private setSchemaEvolutionCommitMetadata;
+    private rollbackTransaction;
+    private readDatasetColumnsAtSnapshot;
+}
+//# sourceMappingURL=ducklake-dataset-catalog.d.ts.map

package/dist/internal/ducklake-dataset-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ducklake-dataset-catalog.d.ts","sourceRoot":"","sources":["../../src/internal/ducklake-dataset-catalog.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAGlE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAA;AAEtD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAK1D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAA;AAY9E;;;;;;GAMG;AACH,qBAAa,sBAAsB;IAE/B,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,WAAW;gBADX,OAAO,EAAE,sBAAsB,EAC/B,WAAW,EAAE,yBAAyB;IAGnD,aAAa,CAAC,UAAU,EAAE,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IA4CxE,kCAAkC,CACtC,WAAW,EAAE,SAAS,iBAAiB,EAAE,GACxC,OAAO,CAAC,IAAI,CAAC;IAwCV,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC;IAQhE,mBAAmB,CACvB,OAAO,EAAE,kBAAkB,EAC3B,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC;IAU9B,YAAY,IAAI,OAAO,CAAC,SAAS,iBAAiB,EAAE,CAAC;YAU7C,6BAA6B;YAY7B,sCAAsC;IAW9C,0BAA0B,CAC9B,OAAO,EAAE,kBAAkB,EAC3B,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,aAAa,CAAC;IAazB,YAAY,CAAC,UAAU,EAAE,iBAAiB,GAAG,IAAI;YAQnC,0BAA0B;YA+B1B,uBAAuB;YAYvB,kBAAkB;YAmBlB,gBAAgB;YA0BhB,gCAAgC;YAwBhC,mBAAmB;YASnB,4BAA4B;CAgC3C"}

package/dist/internal/ducklake-dataset-table-ref.d.ts

@@ -0,0 +1,9 @@
+import type { DuckLakeStorageOptions } from "../types";
+import type { DuckDbQueryRuntime } from "./duckdb-runtime";
+export interface DatasetTableRef {
+    readonly datasetId: string;
+    readonly tableName: string;
+    readonly tableId: bigint;
+}
+export declare function resolveDatasetTableRef(options: DuckLakeStorageOptions, runtime: DuckDbQueryRuntime, datasetId: string): Promise<DatasetTableRef | null>;
+//# sourceMappingURL=ducklake-dataset-table-ref.d.ts.map

package/dist/internal/ducklake-dataset-table-ref.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ducklake-dataset-table-ref.d.ts","sourceRoot":"","sources":["../../src/internal/ducklake-dataset-table-ref.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAA;AAEtD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAI1D,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAED,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,sBAAsB,EAC/B,OAAO,EAAE,kBAAkB,EAC3B,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAkBjC"}

package/dist/internal/ducklake-maintenance.d.ts

@@ -0,0 +1,9 @@
+import type { DuckLakeMaintenanceOptions, DuckLakeMaintenanceReport, DuckLakeStorageOptions } from "../types";
+import type { DuckLakeConnectionManager } from "./ducklake-connection-manager";
+export declare class DuckLakeMaintenance {
+    private readonly options;
+    private readonly connections;
+    constructor(options: DuckLakeStorageOptions, connections: DuckLakeConnectionManager);
+    runMaintenance(options?: DuckLakeMaintenanceOptions): Promise<DuckLakeMaintenanceReport>;
+}
+//# sourceMappingURL=ducklake-maintenance.d.ts.map

package/dist/internal/ducklake-maintenance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ducklake-maintenance.d.ts","sourceRoot":"","sources":["../../src/internal/ducklake-maintenance.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,0BAA0B,EAC1B,yBAAyB,EACzB,sBAAsB,EACvB,MAAM,UAAU,CAAA;AAEjB,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAA;AAW9E,qBAAa,mBAAmB;IAE5B,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,WAAW;gBADX,OAAO,EAAE,sBAAsB,EAC/B,WAAW,EAAE,yBAAyB;IAGnD,cAAc,CAClB,OAAO,GAAE,0BAA+B,GACvC,OAAO,CAAC,yBAAyB,CAAC;CAoCtC"}

package/dist/internal/ducklake-row-reader.d.ts

@@ -0,0 +1,24 @@
+import type { DatasetRow } from "@sixb/core";
+import type { ReadDatasetRowsInput } from "@sixb/core/lake-storage";
+import type { DuckLakeStorageOptions } from "../types";
+import type { DuckLakeConnectionManager } from "./ducklake-connection-manager";
+import type { DuckLakeSnapshotReader } from "./ducklake-snapshot-reader";
+/**
+ * Reads dataset rows from DuckLake snapshots.
+ *
+ * This module owns the last mile of reads: resolve the requested Sixb version
+ * to a DuckLake snapshot id, render a DuckLake time-travel query, and normalize
+ * DuckDB values back into Sixb row shape.
+ */
+export declare class DuckLakeRowReader {
+    private readonly options;
+    private readonly connections;
+    private readonly snapshots;
+    constructor(options: DuckLakeStorageOptions, connections: DuckLakeConnectionManager, snapshots: DuckLakeSnapshotReader);
+    readRows(input: ReadDatasetRowsInput): AsyncIterable<DatasetRow>;
+    private normalizeRows;
+    private resolveVersion;
+    private resolveReadColumns;
+    private throwNoCommittedVersion;
+}
+//# sourceMappingURL=ducklake-row-reader.d.ts.map

package/dist/internal/ducklake-row-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ducklake-row-reader.d.ts","sourceRoot":"","sources":["../../src/internal/ducklake-row-reader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA2B,UAAU,EAAE,MAAM,YAAY,CAAA;AACrE,OAAO,KAAK,EAAkB,oBAAoB,EAAE,MAAM,yBAAyB,CAAA;AAEnF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAA;AAEtD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAA;AAE9E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAA;AAKxE;;;;;;GAMG;AACH,qBAAa,iBAAiB;IAE1B,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAFT,OAAO,EAAE,sBAAsB,EAC/B,WAAW,EAAE,yBAAyB,EACtC,SAAS,EAAE,sBAAsB;IAG7C,QAAQ,CAAC,KAAK,EAAE,oBAAoB,GAAG,aAAa,CAAC,UAAU,CAAC;YAoDxD,aAAa;YAad,cAAc;IAuB5B,OAAO,CAAC,kBAAkB;IAuB1B,OAAO,CAAC,uBAAuB;CAKhC"}

package/dist/internal/ducklake-snapshot-reader.d.ts

@@ -0,0 +1,73 @@
+import type { DatasetDefinition } from "@sixb/core";
+import type { DatasetCatalogState, DatasetVersion, DatasetVersionRef } from "@sixb/core/lake-storage";
+import type { DuckLakeStorageOptions } from "../types";
+import type { DuckDbQueryRuntime } from "./duckdb-runtime";
+import type { DuckLakeConnectionManager } from "./ducklake-connection-manager";
+import type { DuckLakeDatasetCatalog } from "./ducklake-dataset-catalog";
+import { type DatasetTableRef } from "./ducklake-dataset-table-ref";
+export interface DuckLakeVersionSummary {
+    readonly datasetId: string;
+    readonly versionId: string;
+    readonly rowCount?: number;
+}
+/**
+ * Reconstructs Sixb DatasetVersion objects from DuckLake snapshots.
+ *
+ * DuckLake remains the source of truth for version ids, commit times, and
+ * historical reads. Sixb commit metadata only hydrates fields DuckLake does
+ * not know about, such as producer info and declared inputs.
+ *
+ * This class intentionally reads DuckLake metadata directly. The provider does
+ * not keep a Sixb side table for versions; a Sixb version is a DuckLake
+ * snapshot that either changed the dataset table or was explicitly tagged with
+ * Sixb dataset metadata.
+ */
+export declare class DuckLakeSnapshotReader {
+    private readonly options;
+    private readonly connections;
+    private readonly datasets;
+    constructor(options: DuckLakeStorageOptions, connections: DuckLakeConnectionManager, datasets: DuckLakeDatasetCatalog);
+    listVersions(datasetId: string, limit?: number): Promise<readonly DatasetVersion[]>;
+    getLatestVersion(datasetId: string): Promise<DatasetVersion | null>;
+    getVersion(datasetId: string, versionId: string): Promise<DatasetVersion | null>;
+    /**
+     * Bulk catalog-summary read used by the dataset list view.
+     *
+     * Resolves materialized state and a lightweight latest-version summary for
+     * many datasets with a bounded number of metadata queries, never one snapshot
+     * scan per dataset and never a count(*) over dataset contents.
+     */
+    listDatasetCatalogState(datasetIds: readonly string[]): Promise<readonly DatasetCatalogState[]>;
+    private collectDatasetCatalogState;
+    private snapshotRowToSummary;
+    private resolveDatasetTableIds;
+    /**
+     * Resolve each dataset's latest snapshot row with one shared descending walk.
+     *
+     * The walk reuses {@link candidateToSnapshotRow} so Sixb visibility, mode
+     * derivation, and the loud conflict rule match exact version hydration. Cost
+     * is bounded by the snapshot window, not by the number of datasets.
+     */
+    private resolveLatestSnapshotRows;
+    private queryCatalogSnapshotBatch;
+    private queryFileChangeFlags;
+    private assertNoMetadataConflict;
+    getLatestVersionForDefinition(runtime: DuckDbQueryRuntime, dataset: DatasetDefinition): Promise<DatasetVersion | null>;
+    getLatestVersionRefForDefinition(runtime: DuckDbQueryRuntime, dataset: DatasetDefinition): Promise<DatasetVersionRef | null>;
+    getLatestVersionSummaryForDefinition(runtime: DuckDbQueryRuntime, dataset: DatasetDefinition): Promise<DuckLakeVersionSummary | null>;
+    getVersionForSnapshot(runtime: DuckDbQueryRuntime, dataset: DatasetDefinition, snapshotId: string): Promise<DatasetVersion | null>;
+    getVersionForTableRef(runtime: DuckDbQueryRuntime, tableRef: DatasetTableRef, snapshotId: string): Promise<DatasetVersion | null>;
+    getVersionRefForSnapshot(runtime: DuckDbQueryRuntime, dataset: DatasetDefinition, snapshotId: string): Promise<DatasetVersionRef | null>;
+    listVersionsForDefinition(runtime: DuckDbQueryRuntime, dataset: DatasetDefinition, limit?: number): Promise<readonly DatasetVersion[]>;
+    private listVersionsForTableRef;
+    getLatestVersionForTableRef(runtime: DuckDbQueryRuntime, tableRef: DatasetTableRef): Promise<DatasetVersion | null>;
+    private getLatestSnapshotRowForTableRef;
+    private getSnapshotRowForTableRef;
+    private getSnapshotRowsForTableRef;
+    private collectVisibleSnapshotRows;
+    private querySnapshotCandidates;
+    private candidateToSnapshotRow;
+    private snapshotToVersion;
+    private withParentSnapshotIds;
+}
+//# sourceMappingURL=ducklake-snapshot-reader.d.ts.map

package/dist/internal/ducklake-snapshot-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ducklake-snapshot-reader.d.ts","sourceRoot":"","sources":["../../src/internal/ducklake-snapshot-reader.ts"],"names":[],"mappings":"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"}

package/dist/internal/ducklake-sql-executor.d.ts

@@ -0,0 +1,33 @@
+import type { DatasetRow } from "@sixb/core";
+import { type DatasetWriteCommitResult, type ExecuteSqlTransformInput, type LakeSqlExecutor, type PreviewSqlTransformInput } from "@sixb/core/lake-storage";
+import type { DuckLakeStorageOptions } from "../types";
+import type { DuckLakeConnectionManager } from "./ducklake-connection-manager";
+import type { DuckLakeDatasetCatalog } from "./ducklake-dataset-catalog";
+import type { DuckLakeSnapshotReader } from "./ducklake-snapshot-reader";
+import type { DuckLakeWriteCoordinator } from "./ducklake-write-coordinator";
+/**
+ * DuckDB-backed SQL transform executor for DuckLakeStorage.
+ */
+export declare class DuckLakeSqlExecutor implements LakeSqlExecutor<"duckdb"> {
+    private readonly options;
+    private readonly connections;
+    private readonly datasets;
+    private readonly snapshots;
+    private readonly writes;
+    readonly dialect: "duckdb";
+    readonly capabilities: {
+        preview: boolean;
+        supportsAppend: boolean;
+        supportsSnapshot: boolean;
+    };
+    constructor(options: DuckLakeStorageOptions, connections: DuckLakeConnectionManager, datasets: DuckLakeDatasetCatalog, snapshots: DuckLakeSnapshotReader, writes: DuckLakeWriteCoordinator);
+    preview(input: PreviewSqlTransformInput<"duckdb">): AsyncIterable<DatasetRow>;
+    execute(input: ExecuteSqlTransformInput<"duckdb">): Promise<DatasetWriteCommitResult>;
+    private resolveSources;
+    private resolveSourceDataset;
+    private resolveTargetDataset;
+    private resolveSourceVersion;
+    private assertResultSchemaMatchesTarget;
+    private applySqlTransform;
+}
+//# sourceMappingURL=ducklake-sql-executor.d.ts.map

package/dist/internal/ducklake-sql-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ducklake-sql-executor.d.ts","sourceRoot":"","sources":["../../src/internal/ducklake-sql-executor.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAA8C,UAAU,EAAE,MAAM,YAAY,CAAA;AACxF,OAAO,EAEL,KAAK,wBAAwB,EAE7B,KAAK,wBAAwB,EAC7B,KAAK,eAAe,EAEpB,KAAK,wBAAwB,EAC9B,MAAM,yBAAyB,CAAA;AAChC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAA;AAQtD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAA;AAC9E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAA;AACxE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAA;AACxE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAA;AAyB5E;;GAEG;AACH,qBAAa,mBAAoB,YAAW,eAAe,CAAC,QAAQ,CAAC;IASjE,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,MAAM;IAZzB,QAAQ,CAAC,OAAO,EAAG,QAAQ,CAAS;IACpC,QAAQ,CAAC,YAAY;;;;MAIpB;gBAGkB,OAAO,EAAE,sBAAsB,EAC/B,WAAW,EAAE,yBAAyB,EACtC,QAAQ,EAAE,sBAAsB,EAChC,SAAS,EAAE,sBAAsB,EACjC,MAAM,EAAE,wBAAwB;IAG5C,OAAO,CAAC,KAAK,EAAE,wBAAwB,CAAC,QAAQ,CAAC,GAAG,aAAa,CAAC,UAAU,CAAC;IAkB9E,OAAO,CAAC,KAAK,EAAE,wBAAwB,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,wBAAwB,CAAC;YAkC7E,cAAc;YA2Bd,oBAAoB;YAcpB,oBAAoB;YAepB,oBAAoB;YAuBpB,+BAA+B;YAsC/B,iBAAiB;CA+BhC"}

package/dist/internal/ducklake-write-coordinator.d.ts

@@ -0,0 +1,53 @@
+import type { DatasetDefinition } from "@sixb/core";
+import type { BeginDatasetWriteInput, DatasetWriteCommitResult, DatasetWriteMode, LakeWriteSession } from "@sixb/core/lake-storage";
+import type { DuckLakeStorageOptions } from "../types";
+import { type ApplyDatasetRowsResult } from "./dataset-row-commit";
+import type { DuckDbQueryRuntime } from "./duckdb-runtime";
+import type { DuckLakeConnectionManager } from "./ducklake-connection-manager";
+import type { DuckLakeDatasetCatalog } from "./ducklake-dataset-catalog";
+import type { DuckLakeSnapshotReader } from "./ducklake-snapshot-reader";
+export interface DuckLakeCommitDatasetVersionInput {
+    readonly dataset: DatasetDefinition;
+    readonly mode: DatasetWriteMode;
+    readonly expectedLatestVersionId?: string;
+    readonly commitMessage: string;
+    readonly producer?: BeginDatasetWriteInput["producer"];
+    readonly inputs?: BeginDatasetWriteInput["inputs"];
+    applyChanges(runtime: DuckDbQueryRuntime, context: DuckLakeApplyChangesContext): Promise<ApplyDatasetRowsResult>;
+}
+export interface DuckLakeApplyChangesContext {
+    readonly previousRowCount?: number;
+}
+/**
+ * Owns the durable DuckLake transaction for a staged Sixb write.
+ *
+ * Write sessions keep validation and temp staging table mechanics close to the
+ * caller. This coordinator handles everything that changes shared DuckLake
+ * state: attachment refresh, optimistic guards, row replacement/append,
+ * commit_extra_info, no-op detection, and DatasetVersion hydration.
+ */
+export declare class DuckLakeWriteCoordinator {
+    private readonly options;
+    private readonly connections;
+    private readonly datasets;
+    private readonly snapshots;
+    constructor(options: DuckLakeStorageOptions, connections: DuckLakeConnectionManager, datasets: DuckLakeDatasetCatalog, snapshots: DuckLakeSnapshotReader);
+    beginWrite(input: BeginDatasetWriteInput): Promise<LakeWriteSession>;
+    private commitWrite;
+    commitDatasetVersion(input: DuckLakeCommitDatasetVersionInput): Promise<DatasetWriteCommitResult>;
+    withCommitRuntime<T>(run: (runtime: DuckDbQueryRuntime) => Promise<T>): Promise<T>;
+    commitDatasetVersionOnExclusiveRuntime(runtime: DuckDbQueryRuntime, input: DuckLakeCommitDatasetVersionInput): Promise<DatasetWriteCommitResult>;
+    private withGuardedRetrySetting;
+    private commitDatasetVersionUnlocked;
+    private versionForCommittedWrite;
+    private applyStagedRows;
+    private setCommitMetadata;
+    private versionForNoOpCommit;
+    private rollbackTransaction;
+    private latestVersionForCommit;
+    private lastCommittedSnapshotId;
+    private findSnapshotIdByCommitId;
+    private findOwnSnapshotId;
+    private assertExpectedLatestVersion;
+}
+//# sourceMappingURL=ducklake-write-coordinator.d.ts.map

package/dist/internal/ducklake-write-coordinator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ducklake-write-coordinator.d.ts","sourceRoot":"","sources":["../../src/internal/ducklake-write-coordinator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AACnD,OAAO,KAAK,EACV,sBAAsB,EAEtB,wBAAwB,EACxB,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,yBAAyB,CAAA;AAEhC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAA;AAEtD,OAAO,EACL,KAAK,sBAAsB,EAI5B,MAAM,sBAAsB,CAAA;AAE7B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAC1D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAA;AAC9E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAA;AACxE,OAAO,KAAK,EAAE,sBAAsB,EAA0B,MAAM,4BAA4B,CAAA;AAKhG,MAAM,WAAW,iCAAiC;IAChD,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAA;IACnC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAA;IAC/B,QAAQ,CAAC,uBAAuB,CAAC,EAAE,MAAM,CAAA;IACzC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAC9B,QAAQ,CAAC,QAAQ,CAAC,EAAE,sBAAsB,CAAC,UAAU,CAAC,CAAA;IACtD,QAAQ,CAAC,MAAM,CAAC,EAAE,sBAAsB,CAAC,QAAQ,CAAC,CAAA;IAClD,YAAY,CACV,OAAO,EAAE,kBAAkB,EAC3B,OAAO,EAAE,2BAA2B,GACnC,OAAO,CAAC,sBAAsB,CAAC,CAAA;CACnC;AAMD,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;CACnC;AAED;;;;;;;GAOG;AACH,qBAAa,wBAAwB;IAEjC,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAHT,OAAO,EAAE,sBAAsB,EAC/B,WAAW,EAAE,yBAAyB,EACtC,QAAQ,EAAE,sBAAsB,EAChC,SAAS,EAAE,sBAAsB;IAG9C,UAAU,CAAC,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAAC,gBAAgB,CAAC;YA4B5D,WAAW;IAyBnB,oBAAoB,CACxB,KAAK,EAAE,iCAAiC,GACvC,OAAO,CAAC,wBAAwB,CAAC;IAM9B,iBAAiB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,OAAO,EAAE,kBAAkB,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAQlF,sCAAsC,CAC1C,OAAO,EAAE,kBAAkB,EAC3B,KAAK,EAAE,iCAAiC,GACvC,OAAO,CAAC,wBAAwB,CAAC;YAOtB,uBAAuB;YA2CvB,4BAA4B;YAwD5B,wBAAwB;YAoDxB,eAAe;YAyBf,iBAAiB;YA4BjB,oBAAoB;YAcpB,mBAAmB;YASnB,sBAAsB;YAUtB,uBAAuB;YAYvB,wBAAwB;YAiCxB,iBAAiB;IA0B/B,OAAO,CAAC,2BAA2B;CAepC"}

package/dist/internal/ducklake-write-session.d.ts

@@ -0,0 +1,17 @@
+import type { BeginDatasetWriteInput, CommitDatasetWriteInput, DatasetWriteCommitResult, LakeWriteSession } from "@sixb/core/lake-storage";
+import type { DuckDbRuntime } from "./duckdb-runtime";
+export interface DuckLakeCommitWriteInput {
+    readonly write: BeginDatasetWriteInput;
+    readonly commit?: CommitDatasetWriteInput;
+    readonly stagingTableName: string;
+    readonly rowsWritten: number;
+}
+type DuckLakeCommitWrite = (options: DuckLakeCommitWriteInput) => Promise<DatasetWriteCommitResult>;
+interface CreateDuckLakeWriteSessionInput {
+    readonly commitWrite: DuckLakeCommitWrite;
+    readonly runtime: DuckDbRuntime;
+    readonly write: BeginDatasetWriteInput;
+}
+export declare function createDuckLakeWriteSession(input: CreateDuckLakeWriteSessionInput): Promise<LakeWriteSession>;
+export {};
+//# sourceMappingURL=ducklake-write-session.d.ts.map

package/dist/internal/ducklake-write-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ducklake-write-session.d.ts","sourceRoot":"","sources":["../../src/internal/ducklake-write-session.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,sBAAsB,EACtB,uBAAuB,EACvB,wBAAwB,EACxB,gBAAgB,EACjB,MAAM,yBAAyB,CAAA;AAEhC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAKrD,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,KAAK,EAAE,sBAAsB,CAAA;IACtC,QAAQ,CAAC,MAAM,CAAC,EAAE,uBAAuB,CAAA;IACzC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAA;IACjC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;CAC7B;AAED,KAAK,mBAAmB,GAAG,CAAC,OAAO,EAAE,wBAAwB,KAAK,OAAO,CAAC,wBAAwB,CAAC,CAAA;AAOnG,UAAU,+BAA+B;IACvC,QAAQ,CAAC,WAAW,EAAE,mBAAmB,CAAA;IACzC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAA;IAC/B,QAAQ,CAAC,KAAK,EAAE,sBAAsB,CAAA;CACvC;AAED,wBAAsB,0BAA0B,CAC9C,KAAK,EAAE,+BAA+B,GACrC,OAAO,CAAC,gBAAgB,CAAC,CAa3B"}