@lix-js/sdk 0.12.2 → 0.14.0

package/README.md

@@ -18,10 +18,36 @@ import { openLix } from "@lix-js/sdk";
 
 const lix = await openLix();
 const result = await lix.execute("SELECT $1 AS message", ["hello"]);
-console.log(result.rows[0]?.get("message"));
+console.log(result.rows[0]?.message);
 await lix.close();
 ```
 
+## Synchronized local repositories
+
+Use sync mode when reads and writes should execute locally while Lix exchanges
+commits with a hosted repository in the background:
+
+```ts
+import { openLix } from "@lix-js/sdk";
+import { OpfsStorage } from "@lix-js/storage-opfs";
+
+const lix = await openLix({
+  storage: new OpfsStorage({ name: "acme" }),
+  server: {
+    mode: "sync",
+    url: "https://example.com/lix/01936f4e-7b6c-7c3d-8f9a-123456789abc",
+    headers: async () => ({
+      Authorization: `Bearer ${await accessToken()}`,
+    }),
+  },
+});
+```
+
+`await lix.execute(...)` means that the local transaction committed. It does
+not mean that the server has received the commit. Current data and new commits
+synchronize automatically; older history and binary content load when needed.
+See [Collaboration and Sync](https://lix.dev/docs/collaboration-and-sync).
+
 ## Remote repositories
 
 Use the same Lix client as a thin client against a hosted repository:
@@ -30,7 +56,7 @@ Use the same Lix client as a thin client against a hosted repository:
 const lix = await openLix({
   server: {
     mode: "remote",
-    url: "https://example.com/repositories/acme",
+    url: "https://example.com/lix/01936f4e-7b6c-7c3d-8f9a-123456789abc",
     headers: async () => ({
       Authorization: `Bearer ${await accessToken()}`,
     }),
@@ -78,7 +104,7 @@ const result = await lix.execute(
   "SELECT content FROM lix_file WHERE path = $1",
   ["/hello.txt"],
 );
-const bytes = result.rows[0]?.value("content").asBytes();
+const bytes = result.rows[0]?.content as Uint8Array | undefined;
 
 console.log(bytes && new TextDecoder().decode(bytes));
 
@@ -143,12 +169,16 @@ try {
 ## Notes
 
 - `openLix()` opens a fresh in-memory Lix. Install `@lix-js/storage-filesystem` and pass `new FilesystemStorage({ path })` for a filesystem repository directory backed by `<path>/.lix/.internal/rocksdb`.
-- In browsers, pass `new IndexedDbStorage({ name })` to persist a complete local Lix across reloads.
-- Only one Lix handle may open an IndexedDB storage name at a time, including across browser tabs.
+- In browsers, install a storage provider such as `@lix-js/storage-opfs` and pass its
+  storage registration to `openLix()`.
+- JavaScript storage packages register a worker-loadable module URL. That module exports
+  `createLixStorageProvider(options)` and returns the SDK's Rust-shaped `LixStorageProvider`:
+  `beginRead`, `beginWrite`, read/scan handles, write mutation methods, `commit`, and `rollback`.
+  The provider module is loaded beside the Lix Wasm engine in its dedicated worker; it does not
+  bundle or select a Lix engine version.
 - Pass `syncAllFiles: false` to start filesystem sync with no regular repository files, then call `storage.importPaths(["notes/today.md"])` on the `FilesystemStorage` instance to sync selected files. Imported paths are exact repository-relative file paths, not directories or globs.
-- In browsers, local mode and remote mode with IndexedDB storage load the Rust
-  engine as WebAssembly. In remote mode, the local engine contains only client
-  state.
+- Browser-local storage loads the Rust engine as WebAssembly. Remote mode does
+  not open a local storage provider.
 - `FilesystemStorage` is Node.js-only. Constructing it is safe in
   shared code, but passing one to `openLix()` in a browser throws an error.
 - The package is ESM-only.
@@ -161,8 +191,8 @@ try {
 - Every browser `openLix()` owns one dedicated worker, so database work does
   not block the page's main thread. Node.js uses the native binding's actor.
 - Node.js executes installed Component API v1 plugins with the Rust SDK's
-  Wasmtime runtime. The browser and Workerd bindings currently open without a
-  component runtime: they can use ordinary Lix storage and SQL, but do not
+  Wasmtime runtime. The browser binding currently opens without a component
+  runtime: it can use ordinary Lix storage and SQL, but does not
   execute installed plugins. A browser Component host is a separate follow-up.
 - A page Content Security Policy only needs to permit the package's same-origin
   worker. WebAssembly compilation happens inside that worker, so the required

package/dist/binding-types.d.ts

@@ -1,10 +1,16 @@
-import type { CreateBranchOptions, CreateBranchReceipt, CreateCheckpointReceipt, UndoReceipt, RedoReceipt, ExecuteOptions, LixBatchOptions, MergeBranchOptions, MergeBranchPreview, MergeBranchReceipt, SwitchBranchOptions, SwitchBranchReceipt, LixTelemetrySpan } from "./types.js";
+import type { CreateBranchOptions, CreateBranchReceipt, UndoReceipt, RedoReceipt, ExecuteOptions, LixBatchOptions, MergeBranchOptions, MergeBranchPreview, MergeBranchReceipt, SwitchBranchOptions, SwitchBranchReceipt, LixTelemetrySpan, LixTelemetryParentContext, LixOpenProgress, LixOpenReport, OpenAnotherSessionOptions, ResultColumn } from "./types.js";
 import type { NativeLixValue } from "./value.js";
-import type { LixStorageAdapterConfig } from "./storage-adapter.js";
+import type { LixStorageProvider } from "./storage-adapter.js";
+export type SyncServerBindingOptions = {
+    url: string;
+    headers: [string, string][];
+    headerProvider?: () => Promise<[string, string][]>;
+    fetch?: typeof fetch;
+};
 export type BindingExecuteResult = {
     statementIndex?: number;
     label?: string;
-    columns: string[];
+    columns: ResultColumn[];
     rows: NativeLixValue[][];
     rowsAffected: number;
     notices: Array<{
@@ -19,12 +25,25 @@ export type BindingObserveEvent = {
     rows: BindingExecuteResult;
 };
 export type BindingParam = NativeLixValue;
+export type SnapshotExportBinding = {
+    next(): Promise<Uint8Array | null | undefined>;
+    cancel(): void | Promise<void>;
+};
+export type SnapshotRestoreBinding<T> = {
+    write(chunk: Uint8Array): Promise<void>;
+    isComplete(): boolean;
+    finish(): Promise<T>;
+    cancel(): void | Promise<void>;
+};
 export type BindingBatchStatement = {
     sql: string;
     params: BindingParam[];
     label?: string;
 };
 export type LixBinding = {
+    openReport?(): LixOpenReport | undefined;
+    setTelemetryParent(parent?: TelemetryParentContext): void;
+    openAnotherSession(options: OpenAnotherSessionOptions): Promise<LixBinding>;
     execute(sql: string, params: BindingParam[], options?: ExecuteOptions): Promise<BindingExecuteResult>;
     executeBatch(statements: BindingBatchStatement[], options?: LixBatchOptions): Promise<BindingExecuteResult[]>;
     observe(sql: string, params: BindingParam[]): Promise<ObserveEventsBinding>;
@@ -32,7 +51,6 @@ export type LixBinding = {
     activeBranchId(): Promise<string>;
     activeAccountId(): Promise<string>;
     createBranch(options: CreateBranchOptions): Promise<CreateBranchReceipt>;
-    createCheckpoint(): Promise<CreateCheckpointReceipt>;
     undo(): Promise<UndoReceipt>;
     redo(): Promise<RedoReceipt>;
     switchBranch(options: SwitchBranchOptions): Promise<SwitchBranchReceipt>;
@@ -40,8 +58,7 @@ export type LixBinding = {
     mergeBranchPreview(options: MergeBranchOptions): Promise<MergeBranchPreview>;
     mergeBranch(options: MergeBranchOptions): Promise<MergeBranchReceipt>;
     syncDiskToLix(): Promise<void>;
-    /** Explicit snapshot utility available on direct in-memory WASM bindings. */
-    exportSnapshot?(): Promise<Uint8Array>;
+    exportSnapshot?(): SnapshotExportBinding;
     close(): Promise<void>;
 };
 export type LixTransactionBinding = {
@@ -50,13 +67,24 @@ export type LixTransactionBinding = {
     rollback(): Promise<void>;
 };
 export type ObserveEventsBinding = {
+    setTelemetryParent(parent?: TelemetryParentContext): void;
     next(): Promise<BindingObserveEvent | null | undefined>;
     close(): void;
 };
 export type TelemetryDispatch = (span: LixTelemetrySpan) => void;
+export type OpenProgressDispatch = (progress: LixOpenProgress) => void;
+export type TelemetryParentContext = LixTelemetryParentContext;
+export type LixStorageProviderModule = {
+    createLixStorageProvider(options: unknown): Promise<LixStorageProvider>;
+};
 export type LixStorageConfig = {
     kind: "memory";
 } | {
-    kind: "indexedDb";
-    name: string;
-} | LixStorageAdapterConfig;
+    kind: "jsStorage";
+    moduleUrl: string;
+    options: unknown;
+} | {
+    kind: "filesystem";
+    path: string;
+    syncAllFiles: boolean;
+};

package/dist/binding.browser.d.ts

@@ -1,2 +1,2 @@
-import type { LixStorageConfig, LixBinding, TelemetryDispatch } from "./binding-types.js";
-export declare function openLixBinding(storage: LixStorageConfig, telemetry?: TelemetryDispatch): Promise<LixBinding>;
+import type { LixStorageConfig, LixBinding, SyncServerBindingOptions, TelemetryDispatch, TelemetryParentContext, OpenProgressDispatch } from "./binding-types.js";
+export declare function openLixBinding(storage: LixStorageConfig, telemetry?: TelemetryDispatch, telemetryParent?: TelemetryParentContext, server?: SyncServerBindingOptions, openProgress?: OpenProgressDispatch, snapshot?: ReadableStream<Uint8Array>): Promise<LixBinding>;

package/dist/binding.browser.js

@@ -1,23 +1,38 @@
-import { IndexedDbBackend } from "./indexeddb-backend.js";
+import { initializeBrowserWasm } from "./browser-wasm-init.js";
+import { restoreSnapshot } from "./snapshot-restore.js";
 // Generated before TypeScript compilation and emitted beside this module.
-// @ts-expect-error Generated by build:wasm.
-import initWasm, { openIndexedDb, openMemory } from "./wasm/lix_js_sdk.js";
+// @ts-ignore Generated by build:wasm and absent in source-only checks.
+import initWasm, { openJsStorage, openJsStorageFromSnapshot, openMemory, openMemoryFromSnapshot, } from "./wasm/lix_js_sdk.js";
 let wasmInitialized;
 function initializeWasm() {
-    return (wasmInitialized ??= initWasm());
+    if (wasmInitialized !== undefined)
+        return wasmInitialized;
+    const initialization = initializeBrowserWasm(initWasm, new URL("./wasm/lix_js_sdk_bg.wasm", import.meta.url));
+    wasmInitialized = initialization;
+    return wasmInitialized;
 }
-export async function openLixBinding(storage, telemetry) {
+export async function openLixBinding(storage, telemetry, telemetryParent, server, openProgress, snapshot) {
     await initializeWasm();
     switch (storage.kind) {
         case "memory":
-            return openMemory(telemetry);
-        case "indexedDb": {
-            const backend = await IndexedDbBackend.open(storage.name);
+            return (snapshot
+                ? restoreSnapshot(snapshot, openMemoryFromSnapshot(telemetry, telemetryParent, openProgress))
+                : openMemory(telemetry, telemetryParent, server, openProgress));
+        case "jsStorage": {
+            const module = (await import(
+            /* @vite-ignore */ storage.moduleUrl));
+            if (typeof module.createLixStorageProvider !== "function") {
+                throw new TypeError(`Storage provider module '${storage.moduleUrl}' does not export createLixStorageProvider()`);
+            }
+            const provider = await module.createLixStorageProvider(storage.options);
             try {
-                return (await openIndexedDb(backend, telemetry));
+                const binding = (await (snapshot
+                    ? restoreSnapshot(snapshot, openJsStorageFromSnapshot(provider, telemetry, telemetryParent, openProgress))
+                    : openJsStorage(provider, telemetry, telemetryParent, server, openProgress)));
+                return binding;
             }
             catch (error) {
-                await backend.close().catch(() => undefined);
+                await provider.close().catch(() => undefined);
                 throw error;
             }
         }

package/dist/binding.node-wasm.d.ts

@@ -1,2 +1,2 @@
-import type { LixBinding, TelemetryDispatch } from "./binding-types.js";
-export declare function openMemoryWasmBinding(telemetry?: TelemetryDispatch): Promise<LixBinding>;
+import type { LixBinding, TelemetryDispatch, TelemetryParentContext, OpenProgressDispatch } from "./binding-types.js";
+export declare function openMemoryWasmBinding(telemetry?: TelemetryDispatch, telemetryParent?: TelemetryParentContext, openProgress?: OpenProgressDispatch, snapshot?: ReadableStream<Uint8Array>): Promise<LixBinding>;

package/dist/binding.node-wasm.js

@@ -1,14 +1,18 @@
 import { readFile } from "node:fs/promises";
+import { restoreSnapshot } from "./snapshot-restore.js";
 // Generated before TypeScript compilation and emitted beside this module.
-// @ts-expect-error Generated by build:wasm.
-import initWasm, { openMemory } from "./wasm/lix_js_sdk.js";
+// @ts-ignore Generated by build:wasm and absent in source-only checks.
+import initWasm, { openMemory, openMemoryFromSnapshot } from "./wasm/lix_js_sdk.js";
 let wasmInitialized;
 function initializeWasm() {
     return (wasmInitialized ??= initWasm({
         module_or_path: readFile(new URL("./wasm/lix_js_sdk_bg.wasm", import.meta.url)),
     }));
 }
-export async function openMemoryWasmBinding(telemetry) {
+export async function openMemoryWasmBinding(telemetry, telemetryParent, openProgress, snapshot) {
     await initializeWasm();
-    return openMemory(telemetry);
+    if (snapshot) {
+        return restoreSnapshot(snapshot, openMemoryFromSnapshot(telemetry, telemetryParent, openProgress));
+    }
+    return openMemory(telemetry, telemetryParent, undefined, openProgress);
 }

package/dist/binding.node.d.ts

@@ -1,3 +1,3 @@
-import type { LixStorageConfig, LixBinding, TelemetryDispatch } from "./binding-types.js";
-export declare function openLixBinding(storage: LixStorageConfig, telemetry?: TelemetryDispatch): Promise<LixBinding>;
-export declare function openNativeLixBinding(storage: LixStorageConfig, telemetry?: TelemetryDispatch): Promise<LixBinding>;
+import type { LixStorageConfig, LixBinding, SyncServerBindingOptions, TelemetryDispatch, TelemetryParentContext, OpenProgressDispatch } from "./binding-types.js";
+export declare function openLixBinding(storage: LixStorageConfig, telemetry?: TelemetryDispatch, telemetryParent?: TelemetryParentContext, server?: SyncServerBindingOptions, openProgress?: OpenProgressDispatch, snapshot?: ReadableStream<Uint8Array>): Promise<LixBinding>;
+export declare function openNativeLixBinding(storage: LixStorageConfig, telemetry?: TelemetryDispatch, telemetryParent?: TelemetryParentContext, server?: SyncServerBindingOptions, openProgress?: OpenProgressDispatch, snapshot?: ReadableStream<Uint8Array>): Promise<LixBinding>;

package/dist/binding.node.js

@@ -1,6 +1,32 @@
 import { existsSync } from "node:fs";
 import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
+import { restoreSnapshot } from "./snapshot-restore.js";
+function normalizeNativeObserveEvents(events) {
+    return new Proxy(events, {
+        get(target, property, receiver) {
+            if (property === "setTelemetryParent") {
+                return (parent) => target.setTelemetryParent(parent === undefined ? undefined : JSON.stringify(parent));
+            }
+            const value = Reflect.get(target, property, receiver);
+            return typeof value === "function" ? value.bind(target) : value;
+        },
+    });
+}
+function normalizeNativeBinding(binding) {
+    return new Proxy(binding, {
+        get(target, property, receiver) {
+            if (property === "setTelemetryParent") {
+                return (parent) => target.setTelemetryParent(parent === undefined ? undefined : JSON.stringify(parent));
+            }
+            if (property === "observe") {
+                return async (sql, params) => normalizeNativeObserveEvents(await target.observe(sql, params));
+            }
+            const value = Reflect.get(target, property, receiver);
+            return typeof value === "function" ? value.bind(target) : value;
+        },
+    });
+}
 const require = createRequire(import.meta.url);
 const localNativePath = fileURLToPath(new URL("../lix_js_sdk.node", import.meta.url));
 const nativePackages = {
@@ -30,6 +56,12 @@ function resolveNativePath() {
 }
 let addon;
 let addonLoadError;
+class NativeAddonUnavailableError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "NativeAddonUnavailableError";
+    }
+}
 function loadNativeAddon() {
     if (addon)
         return addon;
@@ -40,51 +72,76 @@ function loadNativeAddon() {
         return addon;
     }
     catch (cause) {
-        const error = new Error(`Failed to load @lix-js/sdk native addon for ${process.platform}-${process.arch}. ` +
+        const error = new NativeAddonUnavailableError(`Failed to load @lix-js/sdk native addon for ${process.platform}-${process.arch}. ` +
             "This package requires the matching optional native binary package. " +
             "Run `npm run build` from packages/js-sdk for local development, or install a release that includes your platform binary.", { cause });
         addonLoadError = error;
         throw error;
     }
 }
-export async function openLixBinding(storage, telemetry) {
+export async function openLixBinding(storage, telemetry, telemetryParent, server, openProgress, snapshot) {
     try {
-        return await openNativeLixBinding(storage, telemetry);
+        return await openNativeLixBinding(storage, telemetry, telemetryParent, server, openProgress, snapshot);
     }
     catch (nativeError) {
-        if (storage.kind !== "memory")
+        if (!(nativeError instanceof NativeAddonUnavailableError) ||
+            storage.kind !== "memory" ||
+            server !== undefined) {
             throw nativeError;
+        }
         try {
             const { openMemoryWasmBinding } = await import("./binding.node-wasm.js");
-            return await openMemoryWasmBinding(telemetry);
+            return await openMemoryWasmBinding(telemetry, telemetryParent, openProgress, snapshot);
         }
         catch (wasmError) {
             throw new AggregateError([nativeError, wasmError], "Failed to open in-memory Lix with either the native or WebAssembly binding.");
         }
     }
 }
-export async function openNativeLixBinding(storage, telemetry) {
+export async function openNativeLixBinding(storage, telemetry, telemetryParent, server, openProgress, snapshot) {
+    if (server?.fetch) {
+        throw new TypeError("Custom sync fetch is only supported by the browser worker");
+    }
+    const nativeOpenProgress = openProgress
+        ? (progressJson) => {
+            try {
+                openProgress(JSON.parse(progressJson));
+            }
+            catch {
+                // Open progress is observational and cannot fail repository opening.
+            }
+        }
+        : undefined;
     switch (storage.kind) {
         case "memory": {
             const nativeAddon = loadNativeAddon();
             const nativeTelemetry = telemetry
                 ? (spanJson) => telemetry(JSON.parse(spanJson))
                 : undefined;
-            if (nativeTelemetry)
-                return nativeAddon.Lix.openMemory(nativeTelemetry);
-            return nativeAddon.Lix.openMemory();
+            if (snapshot) {
+                const restore = nativeAddon.Lix.openMemoryFromSnapshot(nativeTelemetry, telemetryParent ? JSON.stringify(telemetryParent) : undefined, nativeOpenProgress);
+                return normalizeNativeBinding(await restoreSnapshot(snapshot, restore));
+            }
+            if (nativeTelemetry) {
+                return normalizeNativeBinding(await nativeAddon.Lix.openMemory(nativeTelemetry, telemetryParent ? JSON.stringify(telemetryParent) : undefined, server?.url, server?.headers, nativeOpenProgress));
+            }
+            return normalizeNativeBinding(await nativeAddon.Lix.openMemory(undefined, undefined, server?.url, server?.headers, nativeOpenProgress));
         }
-        case "indexedDb":
-            throw new Error("IndexedDbStorage is only available in browsers");
+        case "jsStorage":
+            throw new Error("JavaScript storage providers are only available in browsers");
         case "filesystem": {
             const nativeAddon = loadNativeAddon();
             const nativeTelemetry = telemetry
                 ? (spanJson) => telemetry(JSON.parse(spanJson))
                 : undefined;
+            if (snapshot) {
+                const restore = nativeAddon.Lix.openFilesystemStorageFromSnapshot(storage.path, storage.syncAllFiles, nativeTelemetry, telemetryParent ? JSON.stringify(telemetryParent) : undefined, nativeOpenProgress);
+                return normalizeNativeBinding(await restoreSnapshot(snapshot, restore));
+            }
             if (nativeTelemetry) {
-                return nativeAddon.Lix.openFilesystemStorage(storage.path, storage.syncAllFiles, nativeTelemetry);
+                return normalizeNativeBinding(await nativeAddon.Lix.openFilesystemStorage(storage.path, storage.syncAllFiles, nativeTelemetry, telemetryParent ? JSON.stringify(telemetryParent) : undefined, server?.url, server?.headers, nativeOpenProgress));
             }
-            return nativeAddon.Lix.openFilesystemStorage(storage.path, storage.syncAllFiles);
+            return normalizeNativeBinding(await nativeAddon.Lix.openFilesystemStorage(storage.path, storage.syncAllFiles, undefined, undefined, server?.url, server?.headers, nativeOpenProgress));
         }
     }
 }

package/dist/browser-wasm-init.d.ts

@@ -0,0 +1,14 @@
+type WasmInitializer = (options: {
+    module_or_path: URL;
+}) => Promise<unknown>;
+/**
+ * Initializes one fingerprinted Wasm asset without racing the browser's shared
+ * HTTP cache across tabs.
+ *
+ * Chromium can abort one consumer when separate workers cold-load the same
+ * large response concurrently. The lock lasts only for the initial streaming
+ * compilation. Once it releases, later workers consume the completed immutable
+ * cache entry and compile independently.
+ */
+export declare function initializeBrowserWasm(initialize: WasmInitializer, moduleUrl: URL): Promise<unknown>;
+export {};

package/dist/browser-wasm-init.js

@@ -0,0 +1,16 @@
+/**
+ * Initializes one fingerprinted Wasm asset without racing the browser's shared
+ * HTTP cache across tabs.
+ *
+ * Chromium can abort one consumer when separate workers cold-load the same
+ * large response concurrently. The lock lasts only for the initial streaming
+ * compilation. Once it releases, later workers consume the completed immutable
+ * cache entry and compile independently.
+ */
+export function initializeBrowserWasm(initialize, moduleUrl) {
+    const lockManager = globalThis.navigator.locks;
+    const run = () => initialize({ module_or_path: moduleUrl });
+    if (!lockManager)
+        return run();
+    return lockManager.request(`lix:browser-wasm:${moduleUrl.href}`, { mode: "exclusive" }, run);
+}

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-export { IndexedDbStorage, Lix, LixTransaction, ObserveEvents, openLix, } from "./open-lix.js";
-export type { LixStorage, LixStorageAdapterConfig, LixStorageConnection, } from "./storage-adapter.js";
+export { Lix, LixTransaction, ObserveEvents, openLix } from "./open-lix.js";
+export type { LixStorage, LixStorageBound, LixStorageChangeWatch, LixStorageCommitResult, LixStorageErrorCode, LixStorageGetManyRequest, LixStorageKeyRange, LixStoragePrecondition, LixStorageProjectedValue, LixStorageProvider, LixStorageProviderRegistration, LixStoragePutEntry, LixStorageRead, LixStorageReadEntry, LixStorageReadOptions, LixStorageScanOrder, LixStorageScanSource, LixStorageSpace, LixStorageWrite, LixStorageWriteOptions, LixStorageWriteStats, } from "./storage-adapter.js";
+export { LixStorageError } from "./storage-adapter.js";
 export { bundledPluginArchives, type BundledPluginArchive, } from "./bundled-plugins.js";
-export { Row } from "./result.js";
 export { Value } from "./value.js";
-export type { CreateBranchOptions, CreateBranchReceipt, CreateCheckpointReceipt, RedoReceipt, ExecuteOptions, ExecuteResult, LixBatchOptions, LixBatchStatement, IndexedDbStorageOptions, JsonValue, LixValue, MergeBranchOptions, MergeBranchOutcome, MergeBranchPreview, MergeBranchReceipt, MergeChangeStats, MergeConflict, MergeConflictSide, ObserveEvent, OpenLixOptions, LixTelemetryOptions, LixTelemetrySpan, RemoteLixFetch, RemoteLixServerOptions, UndoReceipt, SqlParam, SwitchBranchOptions, SwitchBranchReceipt, } from "./types.js";
+export type { CreateBranchOptions, CreateBranchReceipt, RedoReceipt, ExecuteOptions, ExecuteResult, ExecuteBatchResult, LixBatchOptions, LixBatchStatement, JsonValue, LixValue, ResultArrayRow, ResultColumn, ResultColumnType, ResultObjectRow, ResultRow, MergeBranchOptions, MergeBranchOutcome, MergeBranchPreview, MergeBranchReceipt, MergeChangeStats, MergeConflict, MergeConflictSide, ObserveEvent, OpenLixOptions, OpenAnotherSessionOptions, LixTelemetryOptions, LixTelemetryParentContext, LixTelemetrySpan, LixTelemetrySpanLink, LixOpenMigrationReport, LixOpenPhase, LixOpenProgress, LixOpenProgressOptions, LixOpenReport, RemoteLixFetch, RemoteLixServerOptions, SyncLixServerOptions, UndoReceipt, SqlParam, SwitchBranchOptions, SwitchBranchReceipt, } from "./types.js";

package/dist/index.js

@@ -1,4 +1,4 @@
-export { IndexedDbStorage, Lix, LixTransaction, ObserveEvents, openLix, } from "./open-lix.js";
+export { Lix, LixTransaction, ObserveEvents, openLix } from "./open-lix.js";
+export { LixStorageError } from "./storage-adapter.js";
 export { bundledPluginArchives, } from "./bundled-plugins.js";
-export { Row } from "./result.js";
 export { Value } from "./value.js";

package/dist/lix.d.ts

@@ -1,12 +1,27 @@
 import type { LixBinding, LixTransactionBinding, ObserveEventsBinding } from "./binding-types.js";
-import type { CreateBranchOptions, CreateBranchReceipt, CreateCheckpointReceipt, RedoReceipt, ExecuteOptions, ExecuteResult, ExecuteBatchResult, LixBatchOptions, LixBatchStatement, MergeBranchOptions, MergeBranchPreview, MergeBranchReceipt, ObserveEvent, SqlParam, SwitchBranchOptions, SwitchBranchReceipt, UndoReceipt } from "./types.js";
+import type { CreateBranchOptions, CreateBranchReceipt, RedoReceipt, ExecuteOptions, ExecuteResult, ExecuteBatchResult, LixBatchOptions, LixBatchStatement, MergeBranchOptions, MergeBranchPreview, MergeBranchReceipt, ObserveEvent, OpenAnotherSessionOptions, LixOpenReport, SqlParam, ResultArrayRow, ResultObjectRow, ResultRow, SwitchBranchOptions, SwitchBranchReceipt, UndoReceipt } from "./types.js";
 export declare class Lix {
     #private;
     private readonly binding;
+    readonly openReport: LixOpenReport | undefined;
     private closePromise;
     constructor(binding: LixBinding);
-    execute(sql: string, params?: SqlParam[], options?: ExecuteOptions): Promise<ExecuteResult>;
-    executeBatch(statements: readonly LixBatchStatement[], options?: LixBatchOptions): Promise<readonly ExecuteBatchResult[]>;
+    /** Opens an independent session over the same repository storage. */
+    openAnotherSession(options?: OpenAnotherSessionOptions): Promise<Lix>;
+    execute(sql: string, params: SqlParam[] | undefined, options: ExecuteOptions & {
+        rowMode: "array";
+    }): Promise<ExecuteResult<ResultArrayRow>>;
+    execute<TRow extends object = ResultObjectRow>(sql: string, params?: SqlParam[], options?: ExecuteOptions & {
+        rowMode?: "object";
+    }): Promise<ExecuteResult<TRow>>;
+    execute(sql: string, params: SqlParam[] | undefined, options?: ExecuteOptions): Promise<ExecuteResult<ResultRow>>;
+    executeBatch(statements: readonly LixBatchStatement[], options: LixBatchOptions & {
+        rowMode: "array";
+    }): Promise<readonly ExecuteBatchResult<ResultArrayRow>[]>;
+    executeBatch(statements: readonly LixBatchStatement[], options?: LixBatchOptions & {
+        rowMode?: "object";
+    }): Promise<readonly ExecuteBatchResult<ResultObjectRow>[]>;
+    executeBatch(statements: readonly LixBatchStatement[], options?: LixBatchOptions): Promise<readonly ExecuteBatchResult<ResultRow>[]>;
     observe(sql: string, params?: SqlParam[]): ObserveEvents;
     beginTransaction(): Promise<LixTransaction>;
     activeBranchId(): Promise<string>;
@@ -14,7 +29,8 @@ export declare class Lix {
     /** Subscribes to successful branch switches made through this Lix handle. */
     subscribeActiveBranch(listener: () => void): () => void;
     createBranch(options: CreateBranchOptions): Promise<CreateBranchReceipt>;
-    createCheckpoint(): Promise<CreateCheckpointReceipt>;
+    /** Streams a deterministic snapshot of the complete Lix. */
+    exportSnapshot(): ReadableStream<Uint8Array>;
     undo(): Promise<UndoReceipt>;
     redo(): Promise<RedoReceipt>;
     switchBranch(options: SwitchBranchOptions): Promise<SwitchBranchReceipt>;
@@ -37,7 +53,13 @@ export declare class LixTransaction {
     private finishPromise;
     private finished;
     constructor(binding: LixTransactionBinding, onFinish?: () => void);
-    execute(sql: string, params?: SqlParam[], options?: ExecuteOptions): Promise<ExecuteResult>;
+    execute(sql: string, params: SqlParam[] | undefined, options: ExecuteOptions & {
+        rowMode: "array";
+    }): Promise<ExecuteResult<ResultArrayRow>>;
+    execute<TRow extends object = ResultObjectRow>(sql: string, params?: SqlParam[], options?: ExecuteOptions & {
+        rowMode?: "object";
+    }): Promise<ExecuteResult<TRow>>;
+    execute(sql: string, params: SqlParam[] | undefined, options?: ExecuteOptions): Promise<ExecuteResult<ResultRow>>;
     commit(): Promise<void>;
     rollback(): Promise<void>;
     private finish;