@lix-js/sdk 0.16.1 → 0.17.0

package/dist/migration-binding.browser.d.ts

@@ -0,0 +1,33 @@
+import type { LixStorageConfig, LixStorageProviderModule, SyncServerBindingOptions } from "./binding-types.js";
+export declare function initializeMigration(): Promise<unknown>;
+export declare function convertReplicaBinding(storage: LixStorageConfig, server: SyncServerBindingOptions, branchId?: string): Promise<void>;
+export declare function retryReplicaMigrationCleanupBinding(storage: LixStorageConfig, server: SyncServerBindingOptions): Promise<number>;
+export type RepositoryInspection = {
+    format: number | null;
+    role: "authority" | "partial_replica" | "full_replica" | "standalone" | "empty" | "invalid";
+    layout: "active" | "legacy" | "interrupted" | "empty";
+    current: boolean;
+    protocol_epoch: number;
+};
+export type RepositoryMigrationReport = {
+    embedded_repository_id: string;
+    before: RepositoryInspection;
+    after: RepositoryInspection;
+    semantic_preservation_verified: boolean;
+    preservation_basis: string;
+    expected_content_digest: string;
+    before_content_digest: string;
+    after_content_digest: string;
+};
+type Provider = Awaited<ReturnType<LixStorageProviderModule["createLixStorageProvider"]>>;
+/** Caller owns the provider and its physical exclusion fence across all phases. */
+export declare function inspectStorageProvider(source: Provider): Promise<RepositoryInspection>;
+/** Does not close the provider or publish a browser active-store pointer. */
+export type MigrationLimits = {
+    maxChanges: number;
+    maxPreflightBytes: number;
+};
+export declare function migrateStorageProvider(source: Provider, limits?: MigrationLimits): Promise<RepositoryMigrationReport>;
+/** Explicit full->partial conversion within the caller's fenced destination. */
+export declare function convertStorageProviderToPartial(source: Provider, server: SyncServerBindingOptions, branchId?: string): Promise<void>;
+export {};

package/dist/migration-binding.browser.js

@@ -0,0 +1,46 @@
+import { withConversionProvider } from "./conversion-provider.js";
+// Generated only by build:migration:wasm, physically separate from runtime WASM.
+// @ts-ignore Detached artifact is absent in source-only checks.
+import init, { convertJsStorageReplicaToPartial, retryJsStorageReplicaMigrationCleanup, inspectJsStorageRepository, migrateJsStorageRepository } from "./migration-wasm/lix_js_sdk.js";
+let initialization;
+export async function initializeMigration() {
+    return initialization ??= (async () => {
+        const url = new URL("./migration-wasm/lix_js_sdk_bg.wasm", import.meta.url);
+        if (typeof process !== "undefined" && process.versions?.node) {
+            const { readFile } = await import("node:fs/promises");
+            return init({ module_or_path: await readFile(url) });
+        }
+        return init({ module_or_path: url });
+    })();
+}
+async function provider(storage) {
+    if (storage.kind !== "jsStorage")
+        throw new TypeError("Browser migration requires persistent JavaScript storage");
+    await initializeMigration();
+    const module = await import(/* @vite-ignore */ storage.moduleUrl);
+    if (typeof module.createLixStorageProvider !== "function")
+        throw new TypeError("Invalid storage provider module");
+    return module.createLixStorageProvider(storage.options);
+}
+export async function convertReplicaBinding(storage, server, branchId) {
+    const source = await provider(storage);
+    return withConversionProvider(source, () => convertJsStorageReplicaToPartial(source, server, branchId));
+}
+export async function retryReplicaMigrationCleanupBinding(storage, server) {
+    const source = await provider(storage);
+    return withConversionProvider(source, () => retryJsStorageReplicaMigrationCleanup(source, server));
+}
+/** Caller owns the provider and its physical exclusion fence across all phases. */
+export async function inspectStorageProvider(source) {
+    await initializeMigration();
+    return inspectJsStorageRepository(source);
+}
+export async function migrateStorageProvider(source, limits) {
+    await initializeMigration();
+    return migrateJsStorageRepository(source, limits);
+}
+/** Explicit full->partial conversion within the caller's fenced destination. */
+export async function convertStorageProviderToPartial(source, server, branchId) {
+    await initializeMigration();
+    return convertJsStorageReplicaToPartial(source, server, branchId);
+}

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

@@ -0,0 +1,6 @@
+type MigrationAddon = {
+    convertFilesystemReplicaToPartial(path: string, syncAllFiles: boolean, url: string, headers: [string, string][], branchId?: string): Promise<void>;
+    retryFilesystemReplicaMigrationCleanup(path: string, syncAllFiles: boolean, url: string, headers: [string, string][]): Promise<number>;
+};
+export declare function loadMigrationAddon(): MigrationAddon;
+export {};

package/dist/migration-binding.node.js

@@ -0,0 +1,5 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+export function loadMigrationAddon() {
+    return require("../lix_js_sdk_migration.node");
+}

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

@@ -0,0 +1,271 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export class BrowserComponentHost {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    call(method: string, _arguments: string): string;
+}
+
+export class WasmLix {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    activeAccountId(): Promise<string>;
+    activeBranchId(): Promise<string>;
+    beginTransaction(): Promise<WasmLixTransaction>;
+    close(): Promise<void>;
+    createBranch(options: any): Promise<any>;
+    createHosted(server: any): Promise<any>;
+    execute(sql: string, params: any, options?: any | null): Promise<any>;
+    executeBatch(statements: any, options?: any | null): Promise<any>;
+    exportReplicaRecovery(id: string): Promise<any>;
+    exportSnapshot(): WasmSnapshotExport;
+    importFilesystemPaths(_paths: any): Promise<void>;
+    mergeBranch(options: any): Promise<any>;
+    mergeBranchPreview(options: any): Promise<any>;
+    observe(sql: string, params: any): Promise<WasmObserveEvents>;
+    openAnotherSession(options: any, telemetry_dispatch?: Function | null): Promise<WasmLix>;
+    openReport(): any;
+    recoverReplica(id: string): Promise<any>;
+    recoverReplicaWithServer(id: string, server: any): Promise<any>;
+    redo(): Promise<any>;
+    replicaRecoverySources(): Promise<any>;
+    setTelemetryParent(parent?: any | null): void;
+    switchBranch(options: any): Promise<any>;
+    syncDiskToLix(): Promise<void>;
+    syncHealth(): Promise<any>;
+    undo(): Promise<any>;
+}
+
+export class WasmLixTransaction {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    commit(): Promise<any>;
+    execute(sql: string, params: any, options?: any | null): Promise<any>;
+    rollback(): Promise<void>;
+}
+
+export class WasmObserveEvents {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    close(): void;
+    next(): Promise<any>;
+    setTelemetryParent(parent?: any | null): void;
+}
+
+export class WasmRemoteLix {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    activeAccountId(): Promise<string>;
+    activeBranchId(): Promise<string>;
+    beginTransaction(): Promise<WasmRemoteLixTransaction>;
+    close(): Promise<void>;
+    createBranch(options: any): Promise<any>;
+    execute(sql: string, params: any, options?: any | null): Promise<any>;
+    executeBatch(statements: any, options?: any | null): Promise<any>;
+    exportReplicaRecovery(_id: string): Promise<any>;
+    exportSnapshot(): WasmSnapshotExport;
+    importFilesystemPaths(_paths: any): Promise<void>;
+    mergeBranch(options: any): Promise<any>;
+    mergeBranchPreview(options: any): Promise<any>;
+    observe(sql: string, params: any): Promise<WasmRemoteObserveEvents>;
+    openAnotherSession(options: any): Promise<WasmRemoteLix>;
+    recoverReplica(_id: string): Promise<any>;
+    recoverReplicaWithServer(_id: string, _server: any): Promise<any>;
+    redo(): Promise<any>;
+    replicaRecoverySources(): Promise<any>;
+    setTelemetryParent(_parent?: any | null): void;
+    switchBranch(options: any): Promise<any>;
+    syncDiskToLix(): Promise<void>;
+    syncHealth(): Promise<any>;
+    undo(): Promise<any>;
+}
+
+export class WasmRemoteLixTransaction {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    commit(): Promise<any>;
+    execute(sql: string, params: any, options?: any | null): Promise<any>;
+    rollback(): Promise<void>;
+}
+
+export class WasmRemoteObserveEvents {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    close(): void;
+    next(): Promise<any>;
+    setTelemetryParent(_parent?: any | null): void;
+}
+
+export class WasmSnapshotExport {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    cancel(): Promise<void>;
+    next(): Promise<Uint8Array | undefined>;
+}
+
+export class WasmSnapshotRestore {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    cancel(): Promise<void>;
+    finish(): Promise<WasmLix>;
+    isComplete(): boolean;
+    write(chunk: Uint8Array): Promise<void>;
+}
+
+export function convertJsStorageReplicaToPartial(provider: any, server: any, branch_id?: string | null): Promise<void>;
+
+export function createHosted(server: any): Promise<any>;
+
+export function deleteHosted(server: any): Promise<void>;
+
+/**
+ * Read-only routing metadata; available in the current-format runtime.
+ */
+export function inspectJsStorageRepository(provider: any): Promise<any>;
+
+/**
+ * Detached migration artifact only. Caller owns the physical source lock and
+ * destination publication/recovery lifecycle.
+ */
+export function migrateJsStorageRepository(provider: any, limits?: any | null): Promise<any>;
+
+export function openJsStorage(provider: any, telemetry_dispatch: Function | null | undefined, telemetry_parent: any | null | undefined, server: any | null | undefined, open_progress_dispatch: Function | null | undefined, component_dispatch: Function, durability?: string | null): Promise<WasmLix>;
+
+export function openJsStorageFromSnapshot(provider: any, telemetry_dispatch: Function | null | undefined, telemetry_parent: any | null | undefined, open_progress_dispatch: Function | null | undefined, component_dispatch: Function, durability?: string | null): WasmSnapshotRestore;
+
+export function openMemory(telemetry_dispatch: Function | null | undefined, telemetry_parent: any | null | undefined, server: any | null | undefined, open_progress_dispatch: Function | null | undefined, component_dispatch: Function, durability?: string | null): Promise<WasmLix>;
+
+export function openMemoryFromSnapshot(telemetry_dispatch: Function | null | undefined, telemetry_parent: any | null | undefined, open_progress_dispatch: Function | null | undefined, component_dispatch: Function, durability?: string | null): WasmSnapshotRestore;
+
+export function openRemote(url: string, fetch: Function, headers: any, initial_active_branch_id?: string | null): Promise<WasmRemoteLix>;
+
+/**
+ * Parse the engine SQL dialect for hosts that authorize public SQL.
+ */
+export function parseSqlScript(sql: string, provided_param_count: number): any;
+
+export function retryJsStorageReplicaMigrationCleanup(provider: any, server: any): Promise<number>;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_browsercomponenthost_free: (a: number, b: number) => void;
+    readonly __wbg_wasmlix_free: (a: number, b: number) => void;
+    readonly __wbg_wasmlixtransaction_free: (a: number, b: number) => void;
+    readonly __wbg_wasmobserveevents_free: (a: number, b: number) => void;
+    readonly __wbg_wasmremotelix_free: (a: number, b: number) => void;
+    readonly __wbg_wasmremotelixtransaction_free: (a: number, b: number) => void;
+    readonly __wbg_wasmremoteobserveevents_free: (a: number, b: number) => void;
+    readonly __wbg_wasmsnapshotexport_free: (a: number, b: number) => void;
+    readonly __wbg_wasmsnapshotrestore_free: (a: number, b: number) => void;
+    readonly browsercomponenthost_call: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly convertJsStorageReplicaToPartial: (a: number, b: number, c: number, d: number) => number;
+    readonly createHosted: (a: number) => number;
+    readonly deleteHosted: (a: number) => number;
+    readonly inspectJsStorageRepository: (a: number) => number;
+    readonly migrateJsStorageRepository: (a: number, b: number) => number;
+    readonly openJsStorage: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
+    readonly openJsStorageFromSnapshot: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+    readonly openMemory: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+    readonly openMemoryFromSnapshot: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+    readonly openRemote: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+    readonly parseSqlScript: (a: number, b: number, c: number, d: number) => void;
+    readonly retryJsStorageReplicaMigrationCleanup: (a: number, b: number) => number;
+    readonly wasmlix_activeAccountId: (a: number) => number;
+    readonly wasmlix_activeBranchId: (a: number) => number;
+    readonly wasmlix_beginTransaction: (a: number) => number;
+    readonly wasmlix_close: (a: number) => number;
+    readonly wasmlix_createBranch: (a: number, b: number) => number;
+    readonly wasmlix_createHosted: (a: number, b: number) => number;
+    readonly wasmlix_execute: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly wasmlix_executeBatch: (a: number, b: number, c: number) => number;
+    readonly wasmlix_exportReplicaRecovery: (a: number, b: number, c: number) => number;
+    readonly wasmlix_exportSnapshot: (a: number) => number;
+    readonly wasmlix_importFilesystemPaths: (a: number, b: number) => number;
+    readonly wasmlix_mergeBranch: (a: number, b: number) => number;
+    readonly wasmlix_mergeBranchPreview: (a: number, b: number) => number;
+    readonly wasmlix_observe: (a: number, b: number, c: number, d: number) => number;
+    readonly wasmlix_openAnotherSession: (a: number, b: number, c: number) => number;
+    readonly wasmlix_openReport: (a: number, b: number) => void;
+    readonly wasmlix_recoverReplica: (a: number, b: number, c: number) => number;
+    readonly wasmlix_recoverReplicaWithServer: (a: number, b: number, c: number, d: number) => number;
+    readonly wasmlix_redo: (a: number) => number;
+    readonly wasmlix_replicaRecoverySources: (a: number) => number;
+    readonly wasmlix_setTelemetryParent: (a: number, b: number, c: number) => void;
+    readonly wasmlix_switchBranch: (a: number, b: number) => number;
+    readonly wasmlix_syncDiskToLix: (a: number) => number;
+    readonly wasmlix_syncHealth: (a: number) => number;
+    readonly wasmlix_undo: (a: number) => number;
+    readonly wasmlixtransaction_commit: (a: number) => number;
+    readonly wasmlixtransaction_execute: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly wasmlixtransaction_rollback: (a: number) => number;
+    readonly wasmobserveevents_close: (a: number) => void;
+    readonly wasmobserveevents_next: (a: number) => number;
+    readonly wasmobserveevents_setTelemetryParent: (a: number, b: number, c: number) => void;
+    readonly wasmremotelix_activeAccountId: (a: number) => number;
+    readonly wasmremotelix_activeBranchId: (a: number) => number;
+    readonly wasmremotelix_beginTransaction: (a: number) => number;
+    readonly wasmremotelix_close: (a: number) => number;
+    readonly wasmremotelix_createBranch: (a: number, b: number) => number;
+    readonly wasmremotelix_execute: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly wasmremotelix_executeBatch: (a: number, b: number, c: number) => number;
+    readonly wasmremotelix_exportReplicaRecovery: (a: number, b: number, c: number) => number;
+    readonly wasmremotelix_exportSnapshot: (a: number) => number;
+    readonly wasmremotelix_importFilesystemPaths: (a: number, b: number) => number;
+    readonly wasmremotelix_mergeBranch: (a: number, b: number) => number;
+    readonly wasmremotelix_mergeBranchPreview: (a: number, b: number) => number;
+    readonly wasmremotelix_observe: (a: number, b: number, c: number, d: number) => number;
+    readonly wasmremotelix_openAnotherSession: (a: number, b: number) => number;
+    readonly wasmremotelix_recoverReplica: (a: number, b: number, c: number) => number;
+    readonly wasmremotelix_recoverReplicaWithServer: (a: number, b: number, c: number, d: number) => number;
+    readonly wasmremotelix_redo: (a: number) => number;
+    readonly wasmremotelix_replicaRecoverySources: (a: number) => number;
+    readonly wasmremotelix_setTelemetryParent: (a: number, b: number) => void;
+    readonly wasmremotelix_switchBranch: (a: number, b: number) => number;
+    readonly wasmremotelix_syncDiskToLix: (a: number) => number;
+    readonly wasmremotelix_syncHealth: (a: number) => number;
+    readonly wasmremotelix_undo: (a: number) => number;
+    readonly wasmremotelixtransaction_commit: (a: number) => number;
+    readonly wasmremotelixtransaction_execute: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly wasmremotelixtransaction_rollback: (a: number) => number;
+    readonly wasmremoteobserveevents_close: (a: number) => void;
+    readonly wasmremoteobserveevents_next: (a: number) => number;
+    readonly wasmremoteobserveevents_setTelemetryParent: (a: number, b: number) => void;
+    readonly wasmsnapshotexport_cancel: (a: number) => number;
+    readonly wasmsnapshotexport_next: (a: number) => number;
+    readonly wasmsnapshotrestore_cancel: (a: number) => number;
+    readonly wasmsnapshotrestore_finish: (a: number) => number;
+    readonly wasmsnapshotrestore_isComplete: (a: number) => number;
+    readonly wasmsnapshotrestore_write: (a: number, b: number, c: number) => number;
+    readonly __wasm_bindgen_func_elem_105798: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_105800: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_26031: (a: number, b: number, c: number) => number;
+    readonly __wasm_bindgen_func_elem_26030: (a: number, b: number) => void;
+    readonly __wbindgen_export: (a: number, b: number) => number;
+    readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_export3: (a: number) => void;
+    readonly __wbindgen_export4: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_export5: (a: number, b: number) => void;
+    readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+}
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;