@lix-js/sdk 0.16.0 → 0.17.0

package/dist/lix.js

@@ -1,3 +1,4 @@
+import { fetchTransport } from "./http-transport.js";
 import { invalidArgument } from "./errors.js";
 import { normalizeOptionals, wrapExecuteBatchResult, wrapExecuteResult, } from "./result.js";
 import { normalizeParam, toNativeValue } from "./value.js";
@@ -65,7 +66,10 @@ export class Lix {
         const { rowMode = "object", ...bindingOptions } = options ?? {};
         return this.#runOperation(async () => {
             const results = await this.binding.executeBatch(normalizedStatements, bindingOptions);
-            return results.map((result) => wrapExecuteBatchResult(result, rowMode));
+            return {
+                results: results.results.map((result) => wrapExecuteBatchResult(result, rowMode)),
+                commit: results.commit ?? null,
+            };
         });
     }
     observe(sql, params = []) {
@@ -95,6 +99,36 @@ export class Lix {
             }
         });
     }
+    /** Lists preserved generations belonging to this local repository. */
+    async replicaRecoverySources() {
+        return this.#runOperation(() => this.binding.replicaRecoverySources());
+    }
+    /** Exports retained work without deleting or changing its source. */
+    async exportReplicaRecovery(id) {
+        return this.#runOperation(() => this.binding.exportReplicaRecovery(id));
+    }
+    /** Restores supported rows onto separate recovery branches; preserves the source. */
+    async recoverReplica(id) {
+        return this.#runOperation(() => this.binding.recoverReplica(id));
+    }
+    /** Explicitly hydrates retained-source recovery dependencies; does not start sync. */
+    async recoverReplicaWithServer(id, server) {
+        const entries = (headers) => {
+            const result = [];
+            new Headers(headers).forEach((value, key) => result.push([key, value]));
+            return result;
+        };
+        return this.#runOperation(() => this.binding.recoverReplicaWithServer(id, {
+            url: new URL(server.url).toString(),
+            headers: typeof server.headers === "function" ? [] : entries(server.headers),
+            headerProvider: typeof server.headers === "function" ? async () => entries(await server.headers()) : undefined,
+            transport: server.fetch ? fetchTransport(server.fetch) : undefined,
+        }));
+    }
+    /** Local worker health; independent of whether a warm SQL read succeeds. */
+    async syncHealth() {
+        return this.binding.syncHealth();
+    }
     async activeBranchId() {
         return this.#runOperation(() => this.binding.activeBranchId());
     }
@@ -113,7 +147,8 @@ export class Lix {
     async createBranch(options) {
         return this.#runOperation(() => this.binding.createBranch(options));
     }
-    /** Streams a deterministic snapshot of the complete Lix. */
+    /** Streams this handle's state. Local partial replicas include their cached
+     * inputs and pending edits; remote handles export the complete authority. */
     exportSnapshot() {
         let snapshot;
         const start = () => {
@@ -330,7 +365,6 @@ export class ObserveEvents {
 export class LixTransaction {
     binding;
     onFinish;
-    finishPromise;
     finished = false;
     constructor(binding, onFinish = () => undefined) {
         this.binding = binding;
@@ -338,37 +372,38 @@ export class LixTransaction {
         transactionFinalizer.register(this, { transaction: binding, onFinish: this.onFinish }, this);
     }
     async execute(sql, params = [], options) {
+        if (this.finished)
+            throw transactionClosedError();
         assertExecuteArgs("lixTransaction", sql, params, options);
         const { rowMode = "object", ...bindingOptions } = options ?? {};
-        return wrapExecuteResult(await this.binding.execute(sql, params.map((param, index) => toNativeValue(normalizeParam(param, index))), bindingOptions), rowMode);
+        const { commit: _commit, ...statement } = wrapExecuteResult(await this.binding.execute(sql, params.map((param, index) => toNativeValue(normalizeParam(param, index))), bindingOptions), rowMode);
+        return statement;
     }
     async commit() {
-        return this.finish("transaction.commit");
+        return (await this.finish("transaction.commit"));
     }
     async rollback() {
-        return this.finish("transaction.rollback");
+        await this.finish("transaction.rollback");
     }
     async finish(kind) {
         if (this.finished)
             throw transactionClosedError();
-        if (!this.finishPromise) {
-            this.finishPromise = (async () => {
-                try {
-                    if (kind === "transaction.commit")
-                        await this.binding.commit();
-                    else
-                        await this.binding.rollback();
-                }
-                finally {
-                    // A terminal binding call consumes the underlying transaction even
-                    // when its durable commit or rollback reports an error.
-                    this.finished = true;
-                    transactionFinalizer.unregister(this);
-                    this.onFinish();
-                }
-            })();
+        // The first terminal call owns the handle immediately. In particular,
+        // a concurrent rollback must never report a pending commit's success.
+        this.finished = true;
+        try {
+            if (kind === "transaction.commit") {
+                const receipt = await this.binding.commit();
+                return { commit: receipt.commit ?? null };
+            }
+            await this.binding.rollback();
+        }
+        finally {
+            // Keep the parent transaction lease until the binding settles. A
+            // terminal call consumes the handle even when it reports an error.
+            transactionFinalizer.unregister(this);
+            this.onFinish();
         }
-        await this.finishPromise;
     }
 }
 function transactionClosedError() {
@@ -385,6 +420,11 @@ function assertExecuteArgs(receiver, sql, params, options) {
     if (!options || typeof options !== "object" || Array.isArray(options)) {
         throw invalidArgument("execute", "options", "object", typeof options, receiver);
     }
+    if (options.maxAutoCommitRetries !== undefined &&
+        (!Number.isInteger(options.maxAutoCommitRetries) ||
+            options.maxAutoCommitRetries < 0 || options.maxAutoCommitRetries > 0xffff_ffff)) {
+        throw invalidArgument("execute", "options.maxAutoCommitRetries", "integer between 0 and 4294967295", typeof options.maxAutoCommitRetries, receiver);
+    }
     if (options.originKey !== undefined &&
         typeof options.originKey !== "string") {
         throw invalidArgument("execute", "options.originKey", "string", typeof options.originKey, receiver);
@@ -450,6 +490,11 @@ function assertBatchOptions(options) {
     if (!options || typeof options !== "object" || Array.isArray(options)) {
         throw invalidArgument("executeBatch", "options", "object", typeof options);
     }
+    if (options.maxAutoCommitRetries !== undefined &&
+        (!Number.isInteger(options.maxAutoCommitRetries) ||
+            options.maxAutoCommitRetries < 0 || options.maxAutoCommitRetries > 0xffff_ffff)) {
+        throw invalidArgument("executeBatch", "options.maxAutoCommitRetries", "integer between 0 and 4294967295", typeof options.maxAutoCommitRetries);
+    }
     if (options.originKey !== undefined &&
         typeof options.originKey !== "string") {
         throw invalidArgument("executeBatch", "options.originKey", "string", typeof options.originKey);

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>;