@lix-js/sdk 0.16.1 → 0.17.0

package/dist/migration-wasm/lix_js_sdk_bg.wasm

@@ -0,0 +1,4 @@
+[diffend] Oversized file quarantined before diffing.
+name: package/dist/migration-wasm/lix_js_sdk_bg.wasm
+size: 62036052 bytes
+sha256: 5c12d6543715c9a940047dccb0e9ef5139cbe56a9acf797ad569085063e7efdf

package/dist/migration-wasm/lix_js_sdk_bg.wasm.d.ts

@@ -0,0 +1,101 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_browsercomponenthost_free: (a: number, b: number) => void;
+export const __wbg_wasmlix_free: (a: number, b: number) => void;
+export const __wbg_wasmlixtransaction_free: (a: number, b: number) => void;
+export const __wbg_wasmobserveevents_free: (a: number, b: number) => void;
+export const __wbg_wasmremotelix_free: (a: number, b: number) => void;
+export const __wbg_wasmremotelixtransaction_free: (a: number, b: number) => void;
+export const __wbg_wasmremoteobserveevents_free: (a: number, b: number) => void;
+export const __wbg_wasmsnapshotexport_free: (a: number, b: number) => void;
+export const __wbg_wasmsnapshotrestore_free: (a: number, b: number) => void;
+export const browsercomponenthost_call: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const convertJsStorageReplicaToPartial: (a: number, b: number, c: number, d: number) => number;
+export const createHosted: (a: number) => number;
+export const deleteHosted: (a: number) => number;
+export const inspectJsStorageRepository: (a: number) => number;
+export const migrateJsStorageRepository: (a: number, b: number) => number;
+export const openJsStorage: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
+export const openJsStorageFromSnapshot: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+export const openMemory: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+export const openMemoryFromSnapshot: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+export const openRemote: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+export const parseSqlScript: (a: number, b: number, c: number, d: number) => void;
+export const retryJsStorageReplicaMigrationCleanup: (a: number, b: number) => number;
+export const wasmlix_activeAccountId: (a: number) => number;
+export const wasmlix_activeBranchId: (a: number) => number;
+export const wasmlix_beginTransaction: (a: number) => number;
+export const wasmlix_close: (a: number) => number;
+export const wasmlix_createBranch: (a: number, b: number) => number;
+export const wasmlix_createHosted: (a: number, b: number) => number;
+export const wasmlix_execute: (a: number, b: number, c: number, d: number, e: number) => number;
+export const wasmlix_executeBatch: (a: number, b: number, c: number) => number;
+export const wasmlix_exportReplicaRecovery: (a: number, b: number, c: number) => number;
+export const wasmlix_exportSnapshot: (a: number) => number;
+export const wasmlix_importFilesystemPaths: (a: number, b: number) => number;
+export const wasmlix_mergeBranch: (a: number, b: number) => number;
+export const wasmlix_mergeBranchPreview: (a: number, b: number) => number;
+export const wasmlix_observe: (a: number, b: number, c: number, d: number) => number;
+export const wasmlix_openAnotherSession: (a: number, b: number, c: number) => number;
+export const wasmlix_openReport: (a: number, b: number) => void;
+export const wasmlix_recoverReplica: (a: number, b: number, c: number) => number;
+export const wasmlix_recoverReplicaWithServer: (a: number, b: number, c: number, d: number) => number;
+export const wasmlix_redo: (a: number) => number;
+export const wasmlix_replicaRecoverySources: (a: number) => number;
+export const wasmlix_setTelemetryParent: (a: number, b: number, c: number) => void;
+export const wasmlix_switchBranch: (a: number, b: number) => number;
+export const wasmlix_syncDiskToLix: (a: number) => number;
+export const wasmlix_syncHealth: (a: number) => number;
+export const wasmlix_undo: (a: number) => number;
+export const wasmlixtransaction_commit: (a: number) => number;
+export const wasmlixtransaction_execute: (a: number, b: number, c: number, d: number, e: number) => number;
+export const wasmlixtransaction_rollback: (a: number) => number;
+export const wasmobserveevents_close: (a: number) => void;
+export const wasmobserveevents_next: (a: number) => number;
+export const wasmobserveevents_setTelemetryParent: (a: number, b: number, c: number) => void;
+export const wasmremotelix_activeAccountId: (a: number) => number;
+export const wasmremotelix_activeBranchId: (a: number) => number;
+export const wasmremotelix_beginTransaction: (a: number) => number;
+export const wasmremotelix_close: (a: number) => number;
+export const wasmremotelix_createBranch: (a: number, b: number) => number;
+export const wasmremotelix_execute: (a: number, b: number, c: number, d: number, e: number) => number;
+export const wasmremotelix_executeBatch: (a: number, b: number, c: number) => number;
+export const wasmremotelix_exportReplicaRecovery: (a: number, b: number, c: number) => number;
+export const wasmremotelix_exportSnapshot: (a: number) => number;
+export const wasmremotelix_importFilesystemPaths: (a: number, b: number) => number;
+export const wasmremotelix_mergeBranch: (a: number, b: number) => number;
+export const wasmremotelix_mergeBranchPreview: (a: number, b: number) => number;
+export const wasmremotelix_observe: (a: number, b: number, c: number, d: number) => number;
+export const wasmremotelix_openAnotherSession: (a: number, b: number) => number;
+export const wasmremotelix_recoverReplica: (a: number, b: number, c: number) => number;
+export const wasmremotelix_recoverReplicaWithServer: (a: number, b: number, c: number, d: number) => number;
+export const wasmremotelix_redo: (a: number) => number;
+export const wasmremotelix_replicaRecoverySources: (a: number) => number;
+export const wasmremotelix_setTelemetryParent: (a: number, b: number) => void;
+export const wasmremotelix_switchBranch: (a: number, b: number) => number;
+export const wasmremotelix_syncDiskToLix: (a: number) => number;
+export const wasmremotelix_syncHealth: (a: number) => number;
+export const wasmremotelix_undo: (a: number) => number;
+export const wasmremotelixtransaction_commit: (a: number) => number;
+export const wasmremotelixtransaction_execute: (a: number, b: number, c: number, d: number, e: number) => number;
+export const wasmremotelixtransaction_rollback: (a: number) => number;
+export const wasmremoteobserveevents_close: (a: number) => void;
+export const wasmremoteobserveevents_next: (a: number) => number;
+export const wasmremoteobserveevents_setTelemetryParent: (a: number, b: number) => void;
+export const wasmsnapshotexport_cancel: (a: number) => number;
+export const wasmsnapshotexport_next: (a: number) => number;
+export const wasmsnapshotrestore_cancel: (a: number) => number;
+export const wasmsnapshotrestore_finish: (a: number) => number;
+export const wasmsnapshotrestore_isComplete: (a: number) => number;
+export const wasmsnapshotrestore_write: (a: number, b: number, c: number) => number;
+export const __wasm_bindgen_func_elem_105798: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_105800: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_26031: (a: number, b: number, c: number) => number;
+export const __wasm_bindgen_func_elem_26030: (a: number, b: number) => void;
+export const __wbindgen_export: (a: number, b: number) => number;
+export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_export3: (a: number) => void;
+export const __wbindgen_export4: (a: number, b: number, c: number) => void;
+export const __wbindgen_export5: (a: number, b: number) => void;
+export const __wbindgen_add_to_stack_pointer: (a: number) => number;

package/dist/migration.d.ts

@@ -0,0 +1,23 @@
+/** Detached migration entry. Normal SDK opening never imports this module. */
+import { type LixStorage } from "./storage-adapter.js";
+import type { LixServerOptions } from "./types.js";
+export type ConvertReplicaToPartialOptions = {
+    storage: LixStorage;
+    server: LixServerOptions;
+    branchId?: string;
+};
+/** Explicit conversion of closed full-replica storage; pending edits are preserved. */
+export declare function convertReplicaToPartial(options: ConvertReplicaToPartialOptions): Promise<void>;
+export type RetryReplicaMigrationCleanupOptions = {
+    storage: LixStorage;
+    server: LixServerOptions;
+};
+/** Retry durable migration cleanup on closed storage. Returns newly completed cleanups. */
+export declare function retryReplicaMigrationCleanup(options: RetryReplicaMigrationCleanupOptions): Promise<number>;
+export type { RepositoryInspection, RepositoryMigrationReport, MigrationLimits } from "./migration-binding.browser.js";
+type MigrationBinding = typeof import("./migration-binding.browser.js");
+export declare function initializeMigration(): Promise<unknown>;
+export declare function inspectStorageProvider(...args: Parameters<MigrationBinding["inspectStorageProvider"]>): Promise<import("./migration-binding.browser.js").RepositoryInspection>;
+export declare function migrateStorageProvider(...args: Parameters<MigrationBinding["migrateStorageProvider"]>): Promise<import("./migration-binding.browser.js").RepositoryMigrationReport>;
+export declare function convertStorageProviderToPartial(...args: Parameters<MigrationBinding["convertStorageProviderToPartial"]>): Promise<void>;
+export { fetchTransport } from "./http-transport.js";

package/dist/migration.js

@@ -0,0 +1,55 @@
+/** Detached migration entry. Normal SDK opening never imports this module. */
+import { isJsProviderLixStorage, isLixStorage } from "./storage-adapter.js";
+import { openStorages, storageAlreadyOpen } from "./storage-ownership.js";
+/** Explicit conversion of closed full-replica storage; pending edits are preserved. */
+export async function convertReplicaToPartial(options) {
+    if (!options || (!isLixStorage(options.storage) && !isJsProviderLixStorage(options.storage)) || !options.server)
+        throw new TypeError("Conversion requires storage and server");
+    if (options.branchId !== undefined && (typeof options.branchId !== "string" || !options.branchId))
+        throw new TypeError("branchId must be a nonempty string");
+    const storage = options.storage;
+    if (openStorages.has(storage))
+        throw storageAlreadyOpen();
+    openStorages.add(storage);
+    try {
+        const registration = storage.lixStorage;
+        const config = isJsProviderLixStorage(storage) ? { kind: "jsStorage", moduleUrl: storage.lixStorage.moduleUrl, options: storage.lixStorage.options } :
+            registration.config;
+        const { convertReplicaWorkerOperation } = await import("./worker/client.js");
+        await convertReplicaWorkerOperation(config, options.server, options.branchId);
+    }
+    finally {
+        openStorages.delete(storage);
+    }
+}
+/** Retry durable migration cleanup on closed storage. Returns newly completed cleanups. */
+export async function retryReplicaMigrationCleanup(options) {
+    if (!options || (!isLixStorage(options.storage) && !isJsProviderLixStorage(options.storage)) || !options.server)
+        throw new TypeError("Migration cleanup requires storage and server");
+    const storage = options.storage;
+    if (openStorages.has(storage))
+        throw storageAlreadyOpen();
+    openStorages.add(storage);
+    try {
+        const config = isJsProviderLixStorage(storage) ? { kind: "jsStorage", moduleUrl: storage.lixStorage.moduleUrl, options: storage.lixStorage.options } :
+            storage.lixStorage.config;
+        const { retryReplicaMigrationCleanupWorkerOperation } = await import("./worker/client.js");
+        return await retryReplicaMigrationCleanupWorkerOperation(config, options.server);
+    }
+    finally {
+        openStorages.delete(storage);
+    }
+}
+export async function initializeMigration() {
+    return (await import("./migration-binding.browser.js")).initializeMigration();
+}
+export async function inspectStorageProvider(...args) {
+    return (await import("./migration-binding.browser.js")).inspectStorageProvider(...args);
+}
+export async function migrateStorageProvider(...args) {
+    return (await import("./migration-binding.browser.js")).migrateStorageProvider(...args);
+}
+export async function convertStorageProviderToPartial(...args) {
+    return (await import("./migration-binding.browser.js")).convertStorageProviderToPartial(...args);
+}
+export { fetchTransport } from "./http-transport.js";

package/dist/open-lix.js

@@ -1,7 +1,7 @@
 import { Lix } from "./lix.js";
 import { isJsProviderLixStorage, isLixStorage, } from "./storage-adapter.js";
 export { Lix, LixTransaction, ObserveEvents } from "./lix.js";
-const openStorages = new WeakSet();
+import { openStorages, storageAlreadyOpen } from "./storage-ownership.js";
 export function openLix(options = {}) {
     return openLixInternal(options);
 }
@@ -9,6 +9,11 @@ async function openLixInternal(options, snapshot) {
     if (!options || typeof options !== "object") {
         throw new TypeError("openLix() options must be an object");
     }
+    if (options.durability !== undefined &&
+        options.durability !== "durable" &&
+        options.durability !== "buffered") {
+        throw new TypeError('openLix() durability must be "durable" or "buffered"');
+    }
     if ("backend" in options) {
         throw new TypeError("openLix() option 'backend' was removed; use 'storage' instead");
     }
@@ -26,19 +31,30 @@ async function openLixInternal(options, snapshot) {
         throw new TypeError("openLix() onProgress must be a function");
     }
     if (options.server !== undefined) {
-        if ("mode" in options.server)
-            throw new TypeError("server.mode was removed; provide storage for synchronization or omit it for remote execution");
+        const mode = options.server.mode ?? "remote";
+        if (mode !== "remote" && mode !== "partial_replica") {
+            throw new TypeError('server.mode must be "remote" or "partial_replica"');
+        }
         if (snapshot) {
             throw new TypeError("openLix.fromSnapshot() does not accept server mode");
         }
-        if (options.storage === undefined) {
-            if (options.telemetry !== undefined || options.onProgress !== undefined)
-                throw new TypeError("remote execution does not accept local telemetry or onProgress");
+        if (mode === "remote") {
+            if (options.durability !== undefined) {
+                throw new TypeError("remote persistence is configured by the authority; durability requires local storage");
+            }
+            if (options.storage !== undefined) {
+                throw new TypeError('remote mode does not accept storage; set server.mode to "partial_replica" for on-demand sync');
+            }
+            if (options.telemetry !== undefined)
+                throw new TypeError("remote execution does not accept local telemetry");
             const { openRemoteLixBinding } = await import("./remote/client.js");
-            return new Lix(await openRemoteLixBinding(options.server));
+            return new Lix(await openRemoteLixBinding(options.server, { onProgress: options.onProgress }));
+        }
+        if (options.storage === undefined) {
+            throw new TypeError('server.mode "partial_replica" requires storage');
         }
     }
-    const syncServer = options.server !== undefined && options.storage !== undefined
+    const syncServer = options.server?.mode === "partial_replica"
         ? {
             url: new URL(options.server.url).toString(),
             headers: options.server.headers,
@@ -56,11 +72,11 @@ async function openLixInternal(options, snapshot) {
     }
     const { openLixWorkerBinding } = await import("./worker/client.js");
     if (options.storage === undefined) {
-        const binding = await openLixWorkerBinding({ kind: "memory" }, undefined, options.telemetry, syncServer, options.onProgress, snapshot);
+        const binding = await openLixWorkerBinding({ kind: "memory", durability: options.durability ?? "durable" }, undefined, options.telemetry, syncServer, options.onProgress, snapshot);
         return new Lix(binding);
     }
     if (isJsProviderLixStorage(options.storage)) {
-        return openJsProviderStorage(options.storage, options.telemetry, syncServer, options.onProgress, snapshot);
+        return openJsProviderStorage(options.storage, options.durability ?? "durable", options.telemetry, syncServer, options.onProgress, snapshot);
     }
     if (isLixStorage(options.storage)) {
         const storage = options.storage;
@@ -74,7 +90,7 @@ async function openLixInternal(options, snapshot) {
             openStorages.delete(storage);
         };
         try {
-            binding = await openLixWorkerBinding(storage.lixStorage.config, disconnect, options.telemetry, syncServer, options.onProgress, snapshot);
+            binding = await openLixWorkerBinding({ ...storage.lixStorage.config, durability: options.durability ?? "durable" }, disconnect, options.telemetry, syncServer, options.onProgress, snapshot);
             const routed = routeStorageBinding(binding);
             storage.lixStorage.connect({
                 importFilesystemPaths: (paths) => routed.current().importFilesystemPaths(paths),
@@ -122,7 +138,7 @@ function routeStorageBinding(root) {
         },
     };
 }
-async function openJsProviderStorage(storage, telemetry, syncServer, onProgress, snapshot) {
+async function openJsProviderStorage(storage, durability, telemetry, syncServer, onProgress, snapshot) {
     const { openLixWorkerBinding } = await import("./worker/client.js");
     if (openStorages.has(storage))
         throw storageAlreadyOpen();
@@ -131,6 +147,7 @@ async function openJsProviderStorage(storage, telemetry, syncServer, onProgress,
     try {
         const opened = await openLixWorkerBinding({
             kind: "jsStorage",
+            durability,
             moduleUrl: storage.lixStorage.moduleUrl,
             options: storage.lixStorage.options,
         }, () => openStorages.delete(storage), telemetry, syncServer, onProgress, snapshot);
@@ -218,9 +235,3 @@ function prepareSnapshotSource(source) {
     }, { highWaterMark: 0 });
     return { stream, cancel };
 }
-function storageAlreadyOpen() {
-    const error = new Error("openLix() storage is already open; close the existing Lix or create a new storage adapter");
-    error.name = "LixError";
-    error.code = "LIX_STORAGE_IN_USE";
-    return error;
-}

package/dist/open-progress.d.ts

@@ -0,0 +1,10 @@
+import { type HttpTransport } from "./http-transport.js";
+import type { LixOpenProgress } from "./types.js";
+/** Notifications cannot change an opening operation's result. */
+export declare function emitOpenProgress(callback: ((progress: LixOpenProgress) => void) | undefined, progress: LixOpenProgress): void;
+/** Observe bounded admission responses without taking ownership of retries. */
+export declare function observeOpenProgress(callback?: (progress: LixOpenProgress) => void): {
+    transport(transport: HttpTransport): HttpTransport;
+    complete(): void;
+    stop(): void;
+};

package/dist/open-progress.js

@@ -0,0 +1,59 @@
+import { boundedResponseBody } from "./http-transport.js";
+import { ADMISSION_STORAGE_EPOCH } from "./worker/shared-admission.js";
+/** Notifications cannot change an opening operation's result. */
+export function emitOpenProgress(callback, progress) {
+    try {
+        callback?.(progress);
+    }
+    catch { /* Observational only. */ }
+}
+/** Observe bounded admission responses without taking ownership of retries. */
+export function observeOpenProgress(callback) {
+    let active = callback !== undefined;
+    let migrating = false;
+    let observed = false;
+    let fromFormat;
+    const emit = (phase) => active && emitOpenProgress(callback, { phase, scope: "authority", ...(fromFormat === undefined ? {} : { fromFormat }), toFormat: ADMISSION_STORAGE_EPOCH });
+    return {
+        transport(transport) {
+            if (!callback)
+                return transport;
+            return async (request) => {
+                const response = await transport(request);
+                if (!active || request.response.mode !== "buffered" ||
+                    (request.init.method ?? "GET").toUpperCase() !== "GET" ||
+                    !/\/lix\/v1\/[^/]+(?:\/admission)?\/?$/.test(new URL(request.url).pathname))
+                    return response;
+                if (response.status === 503) {
+                    // The ABI already supplies a byte budget. Consume once and return the
+                    // same bounded bytes; do not tee or clone a potentially live body.
+                    const bytes = await boundedResponseBody(response, request.response.maxBytes);
+                    let body;
+                    try {
+                        body = JSON.parse(new TextDecoder().decode(bytes));
+                    }
+                    catch { /* Preserve malformed errors. */ }
+                    if (body?.error?.code === "LIX_REPOSITORY_MIGRATING" || body?.error?.code === "LIX_ERROR_MIGRATING") {
+                        const from = body.error.details?.fromVersion ?? body.error.details?.fromFormat;
+                        if (Number.isSafeInteger(from) && from >= 0 && from <= 0xffff_ffff)
+                            fromFormat = from;
+                        observed = true;
+                        if (!migrating) {
+                            migrating = true;
+                            emit("migrating");
+                        }
+                    }
+                    return new Response(bytes, { status: response.status, statusText: response.statusText, headers: response.headers });
+                }
+                if (response.ok && migrating) {
+                    migrating = false;
+                    emit("opening");
+                }
+                return response;
+            };
+        },
+        complete() { if (active && observed)
+            emit("complete"); active = false; },
+        stop() { active = false; },
+    };
+}

package/dist/remote/client.d.ts

@@ -1,7 +1,8 @@
 import type { LixBinding } from "../binding-types.js";
-import type { LixServerOptions } from "../types.js";
+import type { LixOpenProgress, LixServerOptions } from "../types.js";
 type RemoteLixClientOptions = {
     initialActiveBranchId?: string;
+    onProgress?: (progress: LixOpenProgress) => void;
 };
 export declare function openRemoteLixBinding(options: LixServerOptions, clientOptions?: RemoteLixClientOptions): Promise<LixBinding>;
 export {};

package/dist/remote/client.js

@@ -1,3 +1,5 @@
+import { observeOpenProgress } from "../open-progress.js";
+import { fetchTransport } from "../http-transport.js";
 import { initializeWasm } from "../wasm-init.js";
 // Generated before TypeScript compilation and emitted beside the JS SDK.
 // @ts-ignore Generated by build:wasm and absent in source-only checks.
@@ -22,7 +24,15 @@ export async function openRemoteLixBinding(options, clientOptions = {}) {
     const locator = connectionUrl(options.url);
     const protocolLocator = locator.toString();
     await initializeWasm();
-    return await openRemote(protocolLocator, remoteFetch, options.headers, clientOptions.initialActiveBranchId);
+    const progress = observeOpenProgress(clientOptions.onProgress);
+    try {
+        const binding = await openRemote(protocolLocator, progress.transport(fetchTransport(options.fetch)), options.headers, clientOptions.initialActiveBranchId);
+        progress.complete();
+        return binding;
+    }
+    finally {
+        progress.stop();
+    }
 }
 function connectionUrl(value) {
     let locator;

package/dist/result.d.ts

@@ -1,12 +1,13 @@
 import { type NativeLixValue } from "./value.js";
-import type { ExecuteBatchResult, ExecuteResult, ResultArrayRow, ResultObjectRow, ResultRow } from "./types.js";
-type NativeExecuteResult = Omit<ExecuteResult, "rows"> & {
+import type { ExecuteBatchStatementResult, CommitSpan, ExecuteResult, ResultArrayRow, ResultObjectRow, ResultRow } from "./types.js";
+type NativeExecuteResult = Omit<ExecuteResult, "rows" | "commit"> & {
+    commit?: CommitSpan | null;
     rows: NativeLixValue[][];
 };
 export declare function wrapExecuteResult(result: NativeExecuteResult): ExecuteResult;
 export declare function wrapExecuteResult(result: NativeExecuteResult, rowMode: "object"): ExecuteResult<ResultObjectRow>;
 export declare function wrapExecuteResult(result: NativeExecuteResult, rowMode: "array"): ExecuteResult<ResultArrayRow>;
 export declare function wrapExecuteResult(result: NativeExecuteResult, rowMode: "object" | "array"): ExecuteResult<ResultRow>;
-export declare function wrapExecuteBatchResult(result: NativeExecuteResult, rowMode?: "object" | "array"): ExecuteBatchResult<ResultRow>;
+export declare function wrapExecuteBatchResult(result: NativeExecuteResult, rowMode?: "object" | "array"): ExecuteBatchStatementResult<ResultRow>;
 export declare function normalizeOptionals<T>(value: T): T;
 export {};

package/dist/result.js

@@ -2,6 +2,7 @@ import { fromNativeValue, Value } from "./value.js";
 export function wrapExecuteResult(result, rowMode = "object") {
     return {
         ...result,
+        commit: result.commit ?? null,
         rows: result.rows.map((row) => {
             const values = row.map((value) => Value._fromNative(fromNativeValue(value)).toJS());
             if (rowMode === "array")
@@ -17,10 +18,8 @@ export function wrapExecuteBatchResult(result, rowMode = "object") {
         statementIndex < 0) {
         throw new Error("executeBatch result is missing a valid statementIndex");
     }
-    return {
-        ...wrapExecuteResult(result, rowMode),
-        statementIndex,
-    };
+    const { commit: _commit, ...statement } = wrapExecuteResult(result, rowMode);
+    return { ...statement, statementIndex };
 }
 export function normalizeOptionals(value) {
     if (Array.isArray(value))

package/dist/storage-adapter.d.ts

@@ -135,6 +135,12 @@ export type LixStorageCommitResult = {
 export interface LixStorageProvider {
     /** Joins the active generation and returns its canonical unsigned 64-bit base-10 token. */
     acquireSession(): Promise<string>;
+    /** Optional exclusive physical-store owner for partial replicas. The handle
+     * exists before asynchronous acquisition so close cancels even a granted lock. */
+    acquirePartialReplicaOwner?(sessionToken: string): {
+        readonly ready: Promise<void>;
+        close(): void;
+    };
     beginRead(options: LixStorageReadOptions): Promise<LixStorageRead>;
     beginWrite(options: LixStorageWriteOptions): Promise<LixStorageWrite>;
     watchForChanges(): Promise<LixStorageChangeWatch>;
@@ -172,7 +178,7 @@ export interface LixStorageWrite {
     commit(): Promise<LixStorageCommitResult>;
     rollback(): Promise<void>;
 }
-export type LixStorageErrorCode = "LIX_STORAGE_UNSUPPORTED" | "LIX_STORAGE_INVALID_KEY" | "LIX_STORAGE_INVALID_CURSOR" | "LIX_STORAGE_READ_EXPIRED" | "LIX_STORAGE_WRITE_CONFLICT" | "LIX_STORAGE_PRECONDITION_FAILED" | "LIX_STORAGE_DURABILITY" | "LIX_STORAGE_FENCED" | "LIX_STORAGE_CLOSED" | "LIX_STORAGE_COMMIT_OUTCOME_UNKNOWN" | "LIX_STORAGE_CORRUPTION" | "LIX_STORAGE_IO";
+export type LixStorageErrorCode = "LIX_STORAGE_UNSUPPORTED" | "LIX_STORAGE_INVALID_KEY" | "LIX_STORAGE_INVALID_CURSOR" | "LIX_STORAGE_READ_EXPIRED" | "LIX_STORAGE_WRITE_CONFLICT" | "LIX_STORAGE_PRECONDITION_FAILED" | "LIX_STORAGE_DURABILITY" | "LIX_STORAGE_IN_USE" | "LIX_STORAGE_FENCED" | "LIX_STORAGE_CLOSED" | "LIX_STORAGE_COMMIT_OUTCOME_UNKNOWN" | "LIX_STORAGE_CORRUPTION" | "LIX_STORAGE_IO";
 /** Error representation decoded back into `lix::storage::StorageError`. */
 export declare class LixStorageError extends Error {
     readonly code: LixStorageErrorCode;

package/dist/storage-ownership.d.ts

@@ -0,0 +1,5 @@
+import type { LixStorage } from "./storage-adapter.js";
+export declare const openStorages: WeakSet<LixStorage>;
+export declare function storageAlreadyOpen(): Error & {
+    code: string;
+};

package/dist/storage-ownership.js

@@ -0,0 +1,4 @@
+export const openStorages = new WeakSet();
+export function storageAlreadyOpen() {
+    return Object.assign(new Error("Storage is already open; close its sessions before migration or reopening"), { name: "LixError", code: "LIX_STORAGE_IN_USE" });
+}