@powersync/web 1.36.0 → 1.37.0

package/lib/src/db/adapters/wa-sqlite/DatabaseServer.d.ts

@@ -0,0 +1,47 @@
+import { ILogger } from '@powersync/common';
+import { ConcurrentSqliteConnection } from './ConcurrentConnection.js';
+import { RawQueryResult } from './RawSqliteConnection.js';
+export interface DatabaseServerOptions {
+    inner: ConcurrentSqliteConnection;
+    onClose: () => void;
+    logger: ILogger;
+}
+/**
+ * Access to a WA-sqlite connection that can be shared with multiple clients sending queries over an RPC protocol built
+ * with the Comlink package.
+ */
+export declare class DatabaseServer {
+    #private;
+    constructor(options: DatabaseServerOptions);
+    /**
+     * Called by clients when they wish to connect to this database.
+     *
+     * @param lockName A lock that is currently held by the client. When the lock is returned, we know the client is gone
+     * and that we need to clean up resources.
+     */
+    connect(lockName?: string): Promise<ClientConnectionView>;
+    forceClose(): Promise<void>;
+}
+export interface ClientConnectionView {
+    close(): Promise<void>;
+    /**
+     * Only used for testing purposes.
+     */
+    debugIsAutoCommit(): Promise<boolean>;
+    /**
+     * Requests exclusive access to this database connection.
+     *
+     * Returns a token that can be used with the query methods. It must be returned with {@link completeAccess} to
+     * give other clients access to the database afterwards.
+     */
+    requestAccess(write: boolean, timeoutMs?: number): Promise<string>;
+    execute(token: string, sql: string, params: any[] | undefined): Promise<RawQueryResult>;
+    executeBatch(token: string, sql: string, params: any[][]): Promise<RawQueryResult[]>;
+    completeAccess(token: string): Promise<void>;
+    /**
+     * Sends update notifications to the given message port.
+     *
+     * Update notifications are posted as a `string[]` message.
+     */
+    setUpdateListener(listener: MessagePort): Promise<void>;
+}

package/lib/src/db/adapters/wa-sqlite/DatabaseServer.js

@@ -0,0 +1,146 @@
+/**
+ * Access to a WA-sqlite connection that can be shared with multiple clients sending queries over an RPC protocol built
+ * with the Comlink package.
+ */
+export class DatabaseServer {
+    #options;
+    #nextClientId = 0;
+    #activeClients = new Set();
+    // TODO: Don't use a broadcast channel for connections managed by a shared worker.
+    #updateBroadcastChannel;
+    #clientTableListeners = new Set();
+    constructor(options) {
+        this.#options = options;
+        const inner = options.inner;
+        this.#updateBroadcastChannel = new BroadcastChannel(`${inner.options.dbFilename}-table-updates`);
+        this.#updateBroadcastChannel.onmessage = ({ data }) => {
+            this.#pushTableUpdateToClients(data);
+        };
+    }
+    #pushTableUpdateToClients(changedTables) {
+        for (const listener of this.#clientTableListeners) {
+            listener.postMessage(changedTables);
+        }
+    }
+    get #inner() {
+        return this.#options.inner;
+    }
+    get #logger() {
+        return this.#options.logger;
+    }
+    /**
+     * Called by clients when they wish to connect to this database.
+     *
+     * @param lockName A lock that is currently held by the client. When the lock is returned, we know the client is gone
+     * and that we need to clean up resources.
+     */
+    async connect(lockName) {
+        let isOpen = true;
+        const clientId = this.#nextClientId++;
+        this.#activeClients.add(clientId);
+        let connectionLeases = new Map();
+        let currentTableListener;
+        function requireOpen() {
+            if (!isOpen) {
+                throw new Error('Client has already been closed');
+            }
+        }
+        function requireOpenAndLease(lease) {
+            requireOpen();
+            const token = connectionLeases.get(lease);
+            if (!token) {
+                throw new Error('Attempted to use a connection lease that has already been returned.');
+            }
+            return token;
+        }
+        const close = async () => {
+            if (isOpen) {
+                isOpen = false;
+                if (currentTableListener) {
+                    this.#clientTableListeners.delete(currentTableListener);
+                }
+                // If the client holds a connection lease it hasn't returned, return that now.
+                for (const { lease } of connectionLeases.values()) {
+                    this.#logger.debug(`Closing connection lease that hasn't been returned.`);
+                    await lease.returnLease();
+                }
+                this.#activeClients.delete(clientId);
+                if (this.#activeClients.size == 0) {
+                    await this.forceClose();
+                }
+                else {
+                    this.#logger.debug('Keeping underlying connection active since its used by other clients.');
+                }
+            }
+        };
+        if (lockName) {
+            navigator.locks.request(lockName, {}, () => {
+                close();
+            });
+        }
+        return {
+            close,
+            debugIsAutoCommit: async () => {
+                return this.#inner.unsafeUseInner().isAutoCommit();
+            },
+            requestAccess: async (write, timeoutMs) => {
+                requireOpen();
+                // TODO: Support timeouts, they don't seem to be supported by the async-mutex package.
+                const lease = await this.#inner.acquireConnection();
+                if (!isOpen) {
+                    // Race between requestAccess and close(), the connection was closed while we tried to acquire a lease.
+                    await lease.returnLease();
+                    return requireOpen();
+                }
+                const token = crypto.randomUUID();
+                connectionLeases.set(token, { lease, write });
+                return token;
+            },
+            completeAccess: async (token) => {
+                const lease = requireOpenAndLease(token);
+                connectionLeases.delete(token);
+                try {
+                    if (lease.write) {
+                        // Collect update hooks invoked while the client had the write connection.
+                        const { resultSet } = await lease.lease.use((conn) => conn.execute(`SELECT powersync_update_hooks('get')`));
+                        if (resultSet) {
+                            const updatedTables = JSON.parse(resultSet.rows[0][0]);
+                            if (updatedTables.length) {
+                                this.#updateBroadcastChannel.postMessage(updatedTables);
+                                this.#pushTableUpdateToClients(updatedTables);
+                            }
+                        }
+                    }
+                }
+                finally {
+                    await lease.lease.returnLease();
+                }
+            },
+            execute: async (token, sql, params) => {
+                const { lease } = requireOpenAndLease(token);
+                return await lease.use((db) => db.execute(sql, params));
+            },
+            executeBatch: async (token, sql, params) => {
+                const { lease } = requireOpenAndLease(token);
+                return await lease.use((db) => db.executeBatch(sql, params));
+            },
+            setUpdateListener: async (listener) => {
+                requireOpen();
+                if (currentTableListener) {
+                    this.#clientTableListeners.delete(currentTableListener);
+                }
+                currentTableListener = listener;
+                if (listener) {
+                    this.#clientTableListeners.add(listener);
+                }
+            }
+        };
+    }
+    async forceClose() {
+        this.#logger.debug(`Closing connection to ${this.#inner.options}.`);
+        const connection = this.#inner;
+        this.#options.onClose();
+        this.#updateBroadcastChannel.close();
+        await connection.close();
+    }
+}

package/lib/src/db/adapters/wa-sqlite/RawSqliteConnection.d.ts

@@ -0,0 +1,46 @@
+import { ResolvedWASQLiteOpenFactoryOptions } from './WASQLiteOpenFactory.js';
+export interface RawResultSet {
+    columns: string[];
+    rows: SQLiteCompatibleType[][];
+}
+export interface RawQueryResult {
+    changes: number;
+    lastInsertRowId: number;
+    autocommit: boolean;
+    resultSet: RawResultSet | undefined;
+}
+/**
+ * A small wrapper around WA-sqlite to help with opening databases and running statements by preparing them internally.
+ *
+ * This is an internal class, and it must never be used directly. Wrappers are required to ensure raw connections aren't
+ * used concurrently across tabs.
+ */
+export declare class RawSqliteConnection {
+    readonly options: ResolvedWASQLiteOpenFactoryOptions;
+    private _sqliteAPI;
+    /**
+     * The `sqlite3*` connection pointer.
+     */
+    private db;
+    private _moduleFactory;
+    constructor(options: ResolvedWASQLiteOpenFactoryOptions);
+    get isOpen(): boolean;
+    init(): Promise<void>;
+    private openSQLiteAPI;
+    requireSqlite(): SQLiteAPI;
+    /**
+     * Checks if the database connection is in autocommit mode.
+     * @returns true if in autocommit mode, false if in a transaction
+     */
+    isAutoCommit(): boolean;
+    execute(sql: string, bindings?: any[]): Promise<RawQueryResult>;
+    executeBatch(sql: string, bindings: any[][]): Promise<RawQueryResult[]>;
+    private wrapQueryResults;
+    /**
+     * This executes a single statement using SQLite3 and returns the results as a {@link RawResultSet}.
+     */
+    private executeSingleStatementRaw;
+    executeRaw(sql: string, bindings?: any[]): Promise<RawResultSet[]>;
+    private stepThroughStatement;
+    close(): Promise<void>;
+}

package/lib/src/db/adapters/wa-sqlite/RawSqliteConnection.js

@@ -0,0 +1,147 @@
+import { Factory as WaSqliteFactory, SQLITE_ROW } from '@journeyapps/wa-sqlite';
+import { DEFAULT_MODULE_FACTORIES } from './vfs.js';
+/**
+ * A small wrapper around WA-sqlite to help with opening databases and running statements by preparing them internally.
+ *
+ * This is an internal class, and it must never be used directly. Wrappers are required to ensure raw connections aren't
+ * used concurrently across tabs.
+ */
+export class RawSqliteConnection {
+    options;
+    _sqliteAPI = null;
+    /**
+     * The `sqlite3*` connection pointer.
+     */
+    db = 0;
+    _moduleFactory;
+    constructor(options) {
+        this.options = options;
+        this._moduleFactory = DEFAULT_MODULE_FACTORIES[this.options.vfs];
+    }
+    get isOpen() {
+        return this.db != 0;
+    }
+    async init() {
+        const api = (this._sqliteAPI = await this.openSQLiteAPI());
+        this.db = await api.open_v2(this.options.dbFilename);
+        await this.executeRaw(`PRAGMA temp_store = ${this.options.temporaryStorage};`);
+        if (this.options.encryptionKey) {
+            const escapedKey = this.options.encryptionKey.replace("'", "''");
+            await this.executeRaw(`PRAGMA key = '${escapedKey}'`);
+        }
+        await this.executeRaw(`PRAGMA cache_size = -${this.options.cacheSizeKb};`);
+        await this.executeRaw(`SELECT powersync_update_hooks('install');`);
+    }
+    async openSQLiteAPI() {
+        const { module, vfs } = await this._moduleFactory({
+            dbFileName: this.options.dbFilename,
+            encryptionKey: this.options.encryptionKey
+        });
+        const sqlite3 = WaSqliteFactory(module);
+        sqlite3.vfs_register(vfs, true);
+        /**
+         * Register the PowerSync core SQLite extension
+         */
+        module.ccall('powersync_init_static', 'int', []);
+        /**
+         * Create the multiple cipher vfs if an encryption key is provided
+         */
+        if (this.options.encryptionKey) {
+            const createResult = module.ccall('sqlite3mc_vfs_create', 'int', ['string', 'int'], [this.options.dbFilename, 1]);
+            if (createResult !== 0) {
+                throw new Error('Failed to create multiple cipher vfs, Database encryption will not work');
+            }
+        }
+        return sqlite3;
+    }
+    requireSqlite() {
+        if (!this._sqliteAPI) {
+            throw new Error(`Initialization has not completed`);
+        }
+        return this._sqliteAPI;
+    }
+    /**
+     * Checks if the database connection is in autocommit mode.
+     * @returns true if in autocommit mode, false if in a transaction
+     */
+    isAutoCommit() {
+        return this.requireSqlite().get_autocommit(this.db) != 0;
+    }
+    async execute(sql, bindings) {
+        const resultSet = await this.executeSingleStatementRaw(sql, bindings);
+        return this.wrapQueryResults(this.requireSqlite(), resultSet);
+    }
+    async executeBatch(sql, bindings) {
+        const results = [];
+        const api = this.requireSqlite();
+        for await (const stmt of api.statements(this.db, sql)) {
+            let columns;
+            for (const parameterSet of bindings) {
+                const rs = await this.stepThroughStatement(api, stmt, parameterSet, columns, false);
+                results.push(this.wrapQueryResults(api, rs));
+            }
+            // executeBatch can only use a single statement
+            break;
+        }
+        return results;
+    }
+    wrapQueryResults(api, rs) {
+        return {
+            changes: api.changes(this.db),
+            lastInsertRowId: api.last_insert_id(this.db),
+            autocommit: api.get_autocommit(this.db) != 0,
+            resultSet: rs
+        };
+    }
+    /**
+     * This executes a single statement using SQLite3 and returns the results as a {@link RawResultSet}.
+     */
+    async executeSingleStatementRaw(sql, bindings) {
+        const results = await this.executeRaw(sql, bindings);
+        return results.length ? results[0] : undefined;
+    }
+    async executeRaw(sql, bindings) {
+        const results = [];
+        const api = this.requireSqlite();
+        for await (const stmt of api.statements(this.db, sql)) {
+            let columns;
+            const rs = await this.stepThroughStatement(api, stmt, bindings ?? [], columns);
+            columns = rs.columns;
+            if (columns.length) {
+                results.push(rs);
+            }
+            // When binding parameters, only a single statement is executed.
+            if (bindings) {
+                break;
+            }
+        }
+        return results;
+    }
+    async stepThroughStatement(api, stmt, bindings, knownColumns, includeResults = true) {
+        // TODO not sure why this is needed currently, but booleans break
+        bindings.forEach((b, index, arr) => {
+            if (typeof b == 'boolean') {
+                arr[index] = b ? 1 : 0;
+            }
+        });
+        api.reset(stmt);
+        if (bindings) {
+            api.bind_collection(stmt, bindings);
+        }
+        const rows = [];
+        while ((await api.step(stmt)) === SQLITE_ROW) {
+            if (includeResults) {
+                const row = api.row(stmt);
+                rows.push(row);
+            }
+        }
+        knownColumns ??= api.column_names(stmt);
+        return { columns: knownColumns, rows };
+    }
+    async close() {
+        if (this.isOpen) {
+            await this.requireSqlite().close(this.db);
+            this.db = 0;
+        }
+    }
+}

package/lib/src/db/adapters/wa-sqlite/WASQLiteOpenFactory.d.ts

@@ -1,8 +1,7 @@
-import { DBAdapter, type ILogLevel } from '@powersync/common';
-import { AbstractWebSQLOpenFactory } from '../AbstractWebSQLOpenFactory.js';
-import { AsyncDatabaseConnection } from '../AsyncDatabaseConnection.js';
+import { DBAdapter, SQLOpenFactory, type ILogLevel } from '@powersync/common';
 import { ResolvedWebSQLOpenOptions, WebSQLOpenFactoryOptions } from '../web-sql-flags.js';
-import { WASQLiteVFS } from './WASQLiteConnection.js';
+import { WASQLiteVFS } from './vfs.js';
+import { DatabaseClient } from './DatabaseClient.js';
 export interface WASQLiteOpenFactoryOptions extends WebSQLOpenFactoryOptions {
     vfs?: WASQLiteVFS;
 }
@@ -11,13 +10,22 @@ export interface ResolvedWASQLiteOpenFactoryOptions extends ResolvedWebSQLOpenOp
 }
 export interface WorkerDBOpenerOptions extends ResolvedWASQLiteOpenFactoryOptions {
     logLevel: ILogLevel;
+    /**
+     * A lock that is currently held by the client. When the lock is returned, we know the client is gone and that we need
+     * to clean up resources.
+     */
+    lockName: string;
 }
 /**
  * Opens a SQLite connection using WA-SQLite.
  */
-export declare class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
+export declare class WASQLiteOpenFactory implements SQLOpenFactory {
+    private options;
+    private resolvedFlags;
+    private logger;
     constructor(options: WASQLiteOpenFactoryOptions);
     get waOptions(): WASQLiteOpenFactoryOptions;
     protected openAdapter(): DBAdapter;
-    openConnection(): Promise<AsyncDatabaseConnection>;
+    openDB(): DBAdapter;
+    openConnection(): Promise<DatabaseClient>;
 }

package/lib/src/db/adapters/wa-sqlite/WASQLiteOpenFactory.js

@@ -1,29 +1,48 @@
+import { createLogger } from '@powersync/common';
 import * as Comlink from 'comlink';
 import { openWorkerDatabasePort, resolveWorkerDatabasePortFactory } from '../../../worker/db/open-worker-database.js';
-import { AbstractWebSQLOpenFactory } from '../AbstractWebSQLOpenFactory.js';
-import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection.js';
-import { DEFAULT_CACHE_SIZE_KB, TemporaryStorageOption } from '../web-sql-flags.js';
-import { InternalWASQLiteDBAdapter } from './InternalWASQLiteDBAdapter.js';
-import { WASQLiteVFS, WASqliteConnection } from './WASQLiteConnection.js';
+import { DEFAULT_CACHE_SIZE_KB, isServerSide, resolveWebSQLFlags, TemporaryStorageOption } from '../web-sql-flags.js';
+import { SSRDBAdapter } from '../SSRDBAdapter.js';
+import { vfsRequiresDedicatedWorkers, WASQLiteVFS } from './vfs.js';
+import { MultiDatabaseServer } from '../../../worker/db/MultiDatabaseServer.js';
+import { DatabaseClient } from './DatabaseClient.js';
+import { generateTabCloseSignal } from '../../../shared/tab_close_signal.js';
+import { AsyncDbAdapter } from '../AsyncWebAdapter.js';
 /**
  * Opens a SQLite connection using WA-SQLite.
  */
-export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
+export class WASQLiteOpenFactory {
+    options;
+    resolvedFlags;
+    logger;
     constructor(options) {
-        super(options);
+        this.options = options;
         assertValidWASQLiteOpenFactoryOptions(options);
+        this.resolvedFlags = resolveWebSQLFlags(options.flags);
+        this.logger = options.logger ?? createLogger(`WASQLiteOpenFactory - ${this.options.dbFilename}`);
     }
     get waOptions() {
         // Cast to extended type
         return this.options;
     }
     openAdapter() {
-        return new InternalWASQLiteDBAdapter({
-            name: this.options.dbFilename,
-            openConnection: () => this.openConnection(),
-            debugMode: this.options.debugMode,
-            logger: this.logger
-        });
+        return new AsyncDbAdapter(this.openConnection(), this.options.dbFilename);
+    }
+    openDB() {
+        const { resolvedFlags: { disableSSRWarning, enableMultiTabs, ssrMode = isServerSide() } } = this;
+        if (ssrMode) {
+            if (!disableSSRWarning) {
+                this.logger.warn(`
+      Running PowerSync in SSR mode.
+      Only empty query results will be returned.
+      Disable this warning by setting 'disableSSRWarning: true' in options.`);
+            }
+            return new SSRDBAdapter();
+        }
+        if (!enableMultiTabs) {
+            this.logger.warn('Multiple tab support is not enabled. Using this site across multiple tabs may not function correctly.');
+        }
+        return this.openAdapter();
     }
     async openConnection() {
         const { enableMultiTabs, useWebWorker } = this.resolvedFlags;
@@ -31,6 +50,18 @@ export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
         if (!enableMultiTabs) {
             this.logger.warn('Multiple tabs are not enabled in this browser');
         }
+        const resolvedOptions = {
+            dbFilename: this.options.dbFilename,
+            dbLocation: this.options.dbLocation,
+            debugMode: this.options.debugMode,
+            vfs,
+            temporaryStorage,
+            cacheSizeKb,
+            flags: this.resolvedFlags,
+            encryptionKey: encryptionKey
+        };
+        let clientOptions;
+        let requiresPersistentTriggers = vfsRequiresDedicatedWorkers(vfs);
         if (useWebWorker) {
             const optionsDbWorker = this.options.worker;
             const workerPort = typeof optionsDbWorker == 'function'
@@ -42,22 +73,20 @@ export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
                     encryptionKey
                 }))
                 : openWorkerDatabasePort(this.options.dbFilename, enableMultiTabs, optionsDbWorker, this.waOptions.vfs);
-            const workerDBOpener = Comlink.wrap(workerPort);
-            return new WorkerWrappedAsyncDatabaseConnection({
-                remote: workerDBOpener,
+            const source = Comlink.wrap(workerPort);
+            const closeSignal = new AbortController();
+            const connection = await source.connect({
+                ...resolvedOptions,
+                logLevel: this.logger.getLevel(),
+                lockName: await generateTabCloseSignal(closeSignal.signal)
+            });
+            clientOptions = {
+                connection,
+                source,
                 // This tab owns the worker, so we're guaranteed to outlive it.
                 remoteCanCloseUnexpectedly: false,
-                baseConnection: await workerDBOpener({
-                    dbFilename: this.options.dbFilename,
-                    vfs,
-                    temporaryStorage,
-                    cacheSizeKb,
-                    flags: this.resolvedFlags,
-                    encryptionKey: encryptionKey,
-                    logLevel: this.logger.getLevel()
-                }),
-                identifier: this.options.dbFilename,
                 onClose: () => {
+                    closeSignal.abort();
                     if (workerPort instanceof Worker) {
                         workerPort.terminate();
                     }
@@ -65,21 +94,19 @@ export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
                         workerPort.close();
                     }
                 }
-            });
+            };
         }
         else {
-            // Don't use a web worker
-            return new WASqliteConnection({
-                dbFilename: this.options.dbFilename,
-                dbLocation: this.options.dbLocation,
-                debugMode: this.options.debugMode,
-                vfs,
-                temporaryStorage,
-                cacheSizeKb,
-                flags: this.resolvedFlags,
-                encryptionKey: encryptionKey
-            });
+            // Don't use a web worker. Instead, open the MultiDatabaseServer a worker would use locally.
+            const localServer = new MultiDatabaseServer(this.logger);
+            requiresPersistentTriggers = true;
+            const connection = await localServer.openConnectionLocally(resolvedOptions);
+            clientOptions = { connection, source: null, remoteCanCloseUnexpectedly: false };
         }
+        return new DatabaseClient(clientOptions, {
+            ...resolvedOptions,
+            requiresPersistentTriggers
+        });
     }
 }
 /**
@@ -89,7 +116,7 @@ function assertValidWASQLiteOpenFactoryOptions(options) {
     // The OPFS VFS only works in dedicated web workers.
     if ('vfs' in options && 'flags' in options) {
         const { vfs, flags = {} } = options;
-        if (vfs !== WASQLiteVFS.IDBBatchAtomicVFS && 'useWebWorker' in flags && !flags.useWebWorker) {
+        if (vfs && vfsRequiresDedicatedWorkers(vfs) && 'useWebWorker' in flags && !flags.useWebWorker) {
             throw new Error(`Invalid configuration: The 'useWebWorker' flag must be true when using an OPFS-based VFS (${vfs}).`);
         }
     }

package/lib/src/db/adapters/wa-sqlite/vfs.d.ts

@@ -0,0 +1,61 @@
+import type * as SQLite from '@journeyapps/wa-sqlite';
+/**
+ * List of currently tested virtual filesystems
+ */
+export declare enum WASQLiteVFS {
+    IDBBatchAtomicVFS = "IDBBatchAtomicVFS",
+    OPFSCoopSyncVFS = "OPFSCoopSyncVFS",
+    AccessHandlePoolVFS = "AccessHandlePoolVFS"
+}
+export declare function vfsRequiresDedicatedWorkers(vfs: WASQLiteVFS): vfs is WASQLiteVFS.OPFSCoopSyncVFS | WASQLiteVFS.AccessHandlePoolVFS;
+/**
+ * @internal
+ */
+export type WASQLiteModuleFactoryOptions = {
+    dbFileName: string;
+    encryptionKey?: string;
+};
+/**
+ * @internal
+ */
+export type SQLiteModule = Parameters<typeof SQLite.Factory>[0];
+/**
+ * @internal
+ */
+export type WASQLiteModuleFactory = (options: WASQLiteModuleFactoryOptions) => Promise<{
+    module: SQLiteModule;
+    vfs: SQLiteVFS;
+}>;
+/**
+ * @internal
+ */
+export declare const AsyncWASQLiteModuleFactory: () => Promise<any>;
+/**
+ * @internal
+ */
+export declare const MultiCipherAsyncWASQLiteModuleFactory: () => Promise<any>;
+/**
+ * @internal
+ */
+export declare const SyncWASQLiteModuleFactory: () => Promise<any>;
+/**
+ * @internal
+ */
+export declare const MultiCipherSyncWASQLiteModuleFactory: () => Promise<any>;
+/**
+ * @internal
+ */
+export declare const DEFAULT_MODULE_FACTORIES: {
+    IDBBatchAtomicVFS: (options: WASQLiteModuleFactoryOptions) => Promise<{
+        module: any;
+        vfs: any;
+    }>;
+    AccessHandlePoolVFS: (options: WASQLiteModuleFactoryOptions) => Promise<{
+        module: any;
+        vfs: any;
+    }>;
+    OPFSCoopSyncVFS: (options: WASQLiteModuleFactoryOptions) => Promise<{
+        module: any;
+        vfs: any;
+    }>;
+};